vqcore/0000755000076500007650000000000010637717020011762 5ustar jcwjcw00000000000000vqcore/data/0000755000076500007650000000000010574360066012677 5ustar jcwjcw00000000000000vqcore/data/gtest.db0000644000076500007650000000111610574360066014333 0ustar jcwjcw00000000000000LJNadamwoodysamnormwiltnormlolanormwoodypierreeTUUvlolascheerscheerscheersjoesjoeslolaslolaslolasfrankiesvwUfQ5&…adamwiltsamnormnormnanwoodylolaUTEVbudrollingrockbudrollingrockbudsierranevadapabstmickiesԆ2RÀDŽcheerscheersjoesjoesjoeslolaslolaswinkosfrankieswUev budsamaddamsbudsamaddamsmickiesmickiespabstrollingrocksnafu Mڀ߅frequents[drinker:S,bar:S,perweek:I],likes[drinker:S,beer:S,perday:I],serves[bar:S,beer:S,quantity:I]>qvqcore/data/lkit-be.db0000644000076500007650000005001510574360066014536 0ustar jcwjcw00000000000000#!/bin/sh # \ exec tclkit "$0" ${1+"$@"} package require starkit starkit::header mk4 -readonly ################################################################################################################################################################LJO dirs[name:S,parent:I,files[name:S,size:I,date:I,contents:B]]dA#LJ Nlibapp-listkcgi1.6GzChangeLogmain.tclC>Z1=jx= 0{bnB%DO>4k)6f1^9l5c W)N)&ޟA" 4+#&,%.ZWmUMHB?^w[&}g4x+HLNLOU(J-,,JU(.I,,VV FIiWĂݜl.iQ6listk.tclpkgIndex.tcltcl2html.tcl H>Z.=>ZxVmOH9c*8Er⥇t@'c!^;8:$P}^OwgfyY/Ua9- T*"CԒ@"5TJA|hϿo5pTIH +kU:G#mf:;rsytwp(ӗ?='I!!2dURA-#|B$I !0@sx $0oܢ]4_;wY+@ `pQYV=.!JPVeY#@ ,Q>|`|AT=  VN FB*8M/_2*tfhpjZTM˪018#\4УG"nz*Z=Msa*TLApcY$2aG'B$Nk >=t}{u0Cdje*QB2^Z^mQ-,6箭NU҆@*U=2 aAyYN7P!`Y&r3|D%Ҧ=-4[~ZyW 0z  q=/a|>c ?EIS|SERXVH)ɿT)UJ6{TeB]uY ~^f7d1y{=)݁k#u%t7Q(qZP=F dȬ. u]fs6Emz=(t xKx&6 R)Sop6Ֆ>z9HʅRodhOjg<۴Qۧޠ7\u3طlk `-*İQ-J\ĭa##\ću_An4o{Ȅ j(E2{| ! <(LދA`J()I9fnkЫ„ɱ} - C66V h$p4 pAYKEzZv~ĭ&]nRѨ /ć/ن0~tgB mYlbDitx~*VlJgHbPM2HJ$xҽ>#̍"B) RpJFv+u y&q"ՙ:m˩2FYu!3'Er,ә:XTyD%R6!S)VwPb" Gf*b{@|H7\a ]Lclsr*ONg >yT&!sEwRGrqB \:93tx;&`.$68av RQc NI:';'iW(i4"?%BNyVA$!8 dDLLA]n߁A]ܛ@{i7b0σs%SI; f v T4d sfoZ.il(_¡@2DIV:.o^u(2)(U«Wz$=b-)b_ Ƌ}'VBEi .= cWγ(eY5@.dݮ)n-E3_3N-26K=D"ќs\D’b7WW'?< ѨkbΫ[2M TRϖNǐ1T#1X]Z*c3P,VUg%IߵE8}!^I0jE) H;\DK_vy׫•ゥl]o؊iu~~dht& B~gMj 8or%9W"pyN>jyV ]Cbb e&qQ<품ptulĖ"eɇ\#<9Y b!-f2TU7˕ड़WV't]D6.Ș.P}^4?j_?jw/Ύ|6ݴv$JUɉK(V-[5BCgځ8& yL*%xy_rT&`+­lB/oG^odvvl))|, 98Lm,h0̨L<41ɗ=>]墙rU5KNsI[/~Ko!MQx.lFže]hWXF uQKx¸U0ʪw]?׷H!k OV ,%mNX0j<>ቛAP=aI+*:0"4?~͔[gh*9d!dH/I2T(tX$~>u 3c,e=eY vEЍ8+~i?c\0D ?HPe܆ @O'S ;E2'ݏT<1t.g;guY%ʰWg Z;i\+t*7+8.ikme21 EE\(Ȕ[L: T-fk+c(NIn\z @RGU(͂zOŹꅿ v$Ȳ0-~$׹T2?'^ݙ$Wqyq9^]oc-?+ a'!k)܆~Faa3]>`:IocjpA|2lhwN:.QfаhxORU6ilH cgi.tclpkgIndex.tcl]+㽽"3ֽ `|nSFzf4_\,ҬU, P*T~6ͯ妢8:#&Uei":˓~a$gm[Y&!Xfâ%gԑi/~Iɴ:vm4Yqĕ c`zH}}(JԣRM4WT4]a^9X~htJ4oKB5##ECöm#wFzїߧQaf>/%K=>I ,,/(KL*VʏܖNbIW/$\HBCgX8*eqћ7o^=?w J%ؼe.\EBגTQ'欸p4/~/:ѣ^xpEJjLH$4K]PHS01WIxN:#vis:m`h?jdoVʑWTN_˸~V^Q]=4زd-ᮏr ?j}12[BGoDtuY܆VZS70ps8g/1xYr%;^Q)1(+إ=.@8uʫt} f>9ϗyA$K<" ׺B'=KM2jW;8C&hkR,Ʌ"mmO.q@@[=Jb.]5^f@V \ @i+4^>L{!$-Eo¿/H+\=,a}7*\'cP9SixsYXXWDX-܅**3[F&+ A8ZN3Hi8[#7zEyH;D1n*M( 7.6lI_Ty(h,_T_uytV^sb"=&{vd~:lި!s/ds{6ԅ~xv&\$dI N\r2骓FxJ$/<tdpp;$邦MsԼyIZjuƵpX&q!m_Sy%:iߧ]#]²gjZisckLI["r{2 k |_DE*(Z3B(b20|U0@#-:U:Jjߩ>iA]f<(ZnðhP==hj|]-O[W8EGL3ڐϗ$յ!umiІA1rQv\Cȱ~P{MoU~~N9Y#Sͫb/5zG??WR`Qf)ڕNa +t(ˋ[mJ桕hz R_~W5,N!|~ʣDi)z2|N U{'敂|<Ϟ<{/~|>in8|N Cğ.k`=tA]%Ti ]3>\se_,eXc.uJ,f9RLX^QDj( =HiEfg *]>p-%,K5b+O |6Tc\-%/fĒ(Kϩ7DǠUcVݗVb^.񏞯[);)Wr4 ذL'3?!$YSa_t#xP=SkOԑέD&%)Ox|"P۟; {o_E([)}2WTHVNlӊVmI$|Or<`,R ddyfLhRQQ5>a{QQmQa֖k߷TVxnI9Y$q`F6bKըcq lڭyyR":tʚX̶)}Ul)*]9@r'EY8R8'6鼈9}~G(&{'!Qjo+prSnq#TDL3/h2a&dݍ,"]f* 5{`X# e=ɩi6rM)v&;6X96ؼ̹ U>CIqN>jq'(Ts?HSK{١J)DEWd)Z",=RU/^c >\tV(,Ǟ]tgf*Mט6>V_;"I2"&~(r7Һ ډGzmk/~uYw߽p9&Y0g{ Z!tCwLwQxM5o^ϻ겫닶 F֨f1_A:zwtQAlV 2V#lb_m}tD<3RBXvt}T5=۝#c9 YJk>фkjFG"lqhq)S|nrC*=a H/ @ITs.%,cCl'3hrܱ|W v_m{`yPN]:Ю6نwt@zKOMLae_$QbZN-)RƆm;_N&隆?ΡחzߦJUG c#0I˵I]ķ'K^LHs;A *YJE]dE'  SP|LD8ː '|АN&?'6fE8X˱E0@BH^t a+ֽ||04d R;!k4 cHܟ|/Д+&.?>?ϝ+t!K7!jD|2Bxg46Y)w'( ZQ(NsOۧu)q)%#Y60,kFly2 ϙO:̾ןSzIWI.!N=='HnU|~zuAO\PKO@,X12'ld8σM!^Jpu)$)k rѱg8N #ߊ%W|jeN/t9N؃=fMUZtM?Em,~cdJWGEݙQ1AK;?oT&Q-8O=m49p9h{Nu7ƭ2”uRaR,@R 2;L^ 4 Ї=ViT6(h. maƯP;A5dLJ ' B( cv^:e%*)_`A8wnB[SQbƤ5%h/@r_@WWR&+q7(-qqv,<)s@oȇaFW\^'wkjmy qPKʑ(G$Fc8a<de]",^^^t`Yx)g8XJ lj B8lC"k-ߪ 1(o \>j"- y!nqYVsRi$1^H+y^R? EލD([[.u$>+dDU$吷P2fϤ'i0:AK9ouka+iӌ0Jc>, z&dC S9e23ǐr:N'[N%LhO#o T}SafP`39S_U:ܩf;t`c' +/F9iܚGj6~c"Z; zVMwئj-JRBG@Lwj.h% "L>!|h!5Ĉ9Xu~bzaQ>mGc"q#2MLgw3#]G*p*p>0!Ab&UO$  29xqEXp&6PG[Z{w!1 *z7WRvȪ=nҽ}u/f})\ešu%qK:1ĭ6>csXI ZI/Dw.JvP뛕5^g)ؾII6,VޡgJƭl&jA l3*QDbp0))%F+^l0*Rfo'id8+c: 11* -n8/"*2v4Ϊ3$eRFĻcQ ~%ҷgDgR>VgkYqn[)T{%E >yLKxx)rຖx)'u1W"#FFdgs;XI@vB;Ba4sX̖_Fg{o+8z@Iy^ϑZ jvz1#9&~OXi;oZMV()Iq4q}QG,Əesӗ[9n:7Jy\Jt> ~mGnvReIzlAGd4C`vpJUMJ[i\}f)_Ս Jk"Qij_^Ӡo :{3USs.O+ڥfP[;™ IIn~/oصm?PZ>ꇈngQ)BgD B{+P= GäD}+I4kT}OC!ļ]ן(Qp.A$8ShV9l+oh,l(DV9GƗ= ca;ii.iPޔh&Ȋ޴7Meoae_nCnGA1[XW΢nVA ED̐DYl bk VWiR}IG=w~׹0P}N* ;g+6<$;P|._uW7-Bri}oœ?.GRo`~2N @;lΉWujIWmZ嵆H:Wn,i~rݲVMhr3?gT l#㚰18˪quΏLUE `†;D 'Js Qb 5U٦muͱvr w$Nn9UWÌ '@YHR~ =4]ˮKs`y?;/T-~$r'k^`lًIF蒟M@pi `^ jlwQ?*mƥxXIz6 8 Le씞YP?6@]m7 0 T|S t[s^{5ht5Q=oz͋ؖ QeR}z}:;QVĚ!З%WsN91'TՇu}-h_2 YC*,ͺi7J|ܼZk>0)ݨhÃ}I'w@4Y.#k%1"VDS:OEv10P7aG|{4kW8 ͕h(!\}=v U8+oюcaKQ%W Ѧ=Q/JRwBS&E8[eDG6U9:ZSlpkD\Q{LtT~bgrcͯeF$= F3 ۴:ADl/pp y~@PC4a_rӲإw#[ B}YEI*46evNotwM:6"17.(]m!0soMh_DS8l}DwDq!]#to 7X X\$ה|5lCOqJH\JqgOXrxN*̺&gpz29&$$ } `KP[⍘}D7v|9tS\md3ʤwj;|P^J @߫5޻ N?6OhrD96H6qctNwj_ )Im'U?4k}e kiSǫ{Lm:|Fv)%eNgZ.:4y,I*DNCDl'7jP0RĊX[UEf&")Y\q慾d!lw0pI<iaV6×T*vG.|$ PAJ{( FYlw>L;X@_9%"3U,쌄kJ||J.m5\llڭ M >Ɯۉ'>Sz>X%@hO" ."\MTKIxyV5l~_+߯M*)u|F +!B&@Ui!0@G B紥*Z-8ej6 hzנaoV]>NVTV∳W!8¿zmc4I=v%-U'da(Ziv*qj<&p1ig)#sq5cvm;7 Ƣ_jvDSb|)Ü:ŢS~y $sޠqU!_n0y8\a,GIZ Hk,YqN*Z!rZh7RE'0|L/M+yxO ;w,h8XfЬ'}8Ivea<8+@zC 3i1vb־ɥ\ŕE=]c䮺]לA.I;1̭MkQv{8%2{v\HuضENb] w60 ٸf6څua-8u7ԿSdͬNɞ U]IoiZu{{TSmLK5QgL7'9ISn{'Z8w~fjy ivu;Tn\\D]b9b{R?Dg2;uvu&.9Gs?*M%ZZ1LDyj~#{0ֲ%)jG2bgi/e{Y1qi+#pCT bˑZ*V.3I @>BGbK1Rg35UDإ^=r akz9ehtc̜#F$Ҥ0\dp-YQ]xœmn^1]k(6L] K3Mayh2S8~Lb(458 ²B(dJEiIh dawFA3Ɉۦ@FB 6Q,P!`p] ZJ+n5ߘ~ v/W PX1rW]uAk:!ί+3̖Ӑ[GC8^b3e 0.0&TN&T(.ٜ.r4 T>H2CL^bx=G W%4oUw(5l!izWs09w|u F]rcıN/,"w?Qq!TmDC^KQ< sV۸lqV5$ޯ@MźHiikiDO0ӿkǕ$5R7d¼Ϊijf|lY'WU Jϴ*h뿉l'r mX+I6DԄ@j`5dBUY[}10vKUF܅įA&w ӯ#zؖbKq,X̷+'Yh &aѬFVWBNuU1:vmFۿ Q3`D|RA {Lv1HʀUy,goVI۲'awC>sujڵ&8Y7;cn{pg67$H[4OBmSNReIy"]sJ)D\*'o9!97tQq鸂KV Kq[C:ޕD=e$N )YEܳ,rA<+]-6{*P%j^N.\EYq,mYPfÀ_pbH]hZ{&m15[0J-OΥ6eaCO=FÓV!gs\A䤌UCmz9>uIƉSXUϢ 䦹LZ>Ҽx'Wsؗe 7̡:އ2JV{ڔyֱi T DJRXOTT 81,FBc xS*Wu5XJѯy-[g1GuX $+ڭ w;JhWVtf.i; U5ʀ8OYi:{O9zٖ/oW܈|Ŵ.ti45b^_<Bs6^_V}@m¿f]VHvzxvXH5Q9OtǞ>/_`H4*TWb69huNVcM PMa 9|1ö>-BCU~;ixIx'cy6a$bJD~6# @-K'*ֽ_u@exedA1#~}I^ _/~|/)n8g2{1['OmsI3Wnnnd |/gͰ=ӹD`<6-gpp U$MP BF,}2M 7 4$=[TR7~W-f+㍹ UX; _و]QN/̲ϹV]C<{h\A`;J{ms8d0M (g.UÞQ!.6F9 eњAL;HY{΁KAzBm®H\3qj;ܙ(PG+gJ["^NݎJ9JugcZmfD]T jrV*]J}0$ƧmVTwC寅En }2y>wyu{occ8# w8FE;oƓ v<7w fG]E٫q6񽳴&}- z&B# +'EC2,Z;&VW-E{2W@geZ[lj|""oRuH}ia==gyO5 0c~1XJ37'zXu.J+LX<-XXqc&\<TrHzJ04 v܉m᭼^T' yrTG*nTCء٩,4abIiog{q4C[7>N O:|#AK+Q@ $]"*Zb>"2E!ՒZpf-|LE\=uZKeʞ L (J:PyJ.~4_pNIaE k9zMic=Tv/cp2& oݦ^;87ՁԣoN77$]q$?G]R!1U(!ۍV\!$_K/_kYMJ;x5^{cuڴQ[7h9wunPMUSnprWGU~Ȍ2bkB՗-;=C۟H3D*L fĄ]=pĹ#/i"04&V]VH, {Vjn [y,/щE] <=cժކEܳ캒%\}d݃6öDB̳{$j??zG_?OJVkum}.mmntڒ擎˪ ?B]0֞lM+ w5|ހ>1xQcM­15ʯ,,4ryC:Nҝ.n$xuW9E5Rt᪶}m6tRmlp;;7n¹BYgd&c_\ q N㪼U$}Y&dU2 })!sG@q&VLrhmTBnPϛ=1}֞p*[x:@yO^isUux-r}<Þ54Z=}z7ey' dk@vFq#n(S&kG kHy-ji )je!Yvl͙N2<s?[7GޜO9x|?Mob>r^·>gᆟ ɏw%t E/8@,8s/>q^.WJ×goCXt w]]x_}'8].z-BUlc*uǛ鹎& p'[T([-vUhB1Й `b9q1~԰vfib>8&?'p)//5\g~d@FXp<&3A+}"QI'8 /?נVGY Q+u} œG {|1g)眣ej1$n :q X(5[mķa2~0o>6x7B"͜<~gn[㍺fҹJ~|ɬG!o$<1g8z"q:I`NwJSamGpЦ&6avG t9A[eC@oMa&Ӳ@v薢Z&AlJ)\&:13_px8k2甊%\bIPǹ ]~|_ Bew8~Rn,B]t1iw 䯍\ G]d*̣q8 BqEx}F;2$s(p6^p3ͩ}ΨDԺ3b)QnS)*;N;%~~^s0.lqZ5pUiE4" 4?Y VԷz<.ԏ$Qla A [lq0N %lHLE_Blzv1Ӕư]zGviR2!Az۬XyT$=:gd`?`z ZqQsDO@C$Rr *#<Ӊc\ؖz4lN4#NET{~g:bXTU>+74 YH+bWŸxsLaſuK߽~;Hl&HǒG6E+!m܆߳4-wFRmJy#GsMЄ08˼p埱Dẞ\K.yrx \- -Xbp_xɈBŦNlRg al/;"I"}NJBIo fE<Őx<$%3@ed[ RX/$sVJٗ5i@##಑ #ӘuU[{ɋ ?qZb15XΟ/1I=z 耀 օڀ߀dirs[name:S,parent:I,files[name:S,size:I,date:I,contents:B]]NCNvqcore/data/lkit-le.db0000644000076500007650000005001510574360066014550 0ustar jcwjcw00000000000000#!/bin/sh # \ exec tclkit "$0" ${1+"$@"} package require starkit starkit::header mk4 -readonly ################################################################################################################################################################JLO dirs[name:S,parent:I,files[name:S,size:I,date:I,contents:B]]dA#JL Nlibapp-listkcgi1.6Gzmain.tclChangeLogCj=1Z>x+HLNLOU(J-,,JU(.I,,VV FIiWĂݜl.iQx= 0{bnB%DO>4k)6f1^9l5c W)N)&ޟA" 4+#&,%.ZWmUMHB?^w[&}g46pkgIndex.tcllistk.tcltcl2html.tcl H =.Z>Z>package ifneeded app-listk 1.0 [list source [file join $dir listk.tcl]] xVmOH9c*8Er⥇t@'c!^;8:$P}^OwgfyY/Ua9- T*"CԒ@"5TJA|hϿo5pTIH +kU:G#mf:;rsytwp(ӗ?='I!!2dURA-#|B$I !0@sx $0oܢ]4_;wY+@ `pQYV=.!JPVeY#@ ,Q>|`|AT=  VN FB*8M/_2*tfhpjZTM˪018#\4УG"nz*Z=Msa*TLApcY$2aG'B$Nk >=t}{u0Cdje*QB2^Z^mQ-,6箭NU҆@*U=2 aAyYN7P!`Y&r3|D%Ҧ=-4[~ZyW 0z  q=/a|>c ?EIS|SERXVH)ɿT)UJ6{TeB]uY ~^f7d1y{=)݁k#u%t7Q(qZP=F dȬ. u]fs6Emz=(t xKx&6 R)Sop6Ֆ>z9HʅRodhOjg<۴Qۧޠ7\u3طlk `-*İQ-J\ĭa##\ću_An4o{Ȅ j(E2{| ! <(LދA`J()I9fnkЫ„ɱ} - C66V h$p4 pAYKEzZv~ĭ&]nRѨ /ć/ن0~tgB mYlbDitx~*VlJgHbPM2HJ$xҽ>#̍"B) RpJFv+u y&q"ՙ:m˩2FYu!3'Er,ә:XTyD%R6!S)VwPb" Gf*b{@|H7\a ]Lclsr*ONg >yT&!sEwRGrqB \:93tx;&`.$68av RQc NI:';'iW(i4"?%BNyVA$!8 dDLLA]n߁A]ܛ@{i7b0σs%SI; f v T4d sfoZ.il(_¡@2DIV:.o^u(2)(U«Wz$=b-)b_ Ƌ}'VBEi .= cWγ(eY5@.dݮ)n-E3_3N-26K=D"ќs\D’b7WW'?< ѨkbΫ[2M TRϖNǐ1T#1X]Z*c3P,VUg%IߵE8}!^I0jE) H;\DK_vy׫•ゥl]o؊iu~~dht& B~gMj 8or%9W"pyN>jyV ]Cbb e&qQ<품ptulĖ"eɇ\#<9Y b!-f2TU7˕ड़WV't]D6.Ș.P}^4?j_?jw/Ύ|6ݴv$JUɉK(V-[5BCgځ8& yL*%xy_rT&`+­lB/oG^odvvl))|, 98Lm,h0̨L<41ɗ=>]墙rU5KNsI[/~Ko!MQx.lFže]hWXF uQKx¸U0ʪw]?׷H!k OV ,%mNX0j<>ቛAP=aI+*:0"4?~͔[gh*9d!dH/I2T(tX$~>u 3c,e=eY vEЍ8+~i?c\0D ?HPe܆ @O'S ;E2'ݏT<1t.g;guY%ʰWg Z;i\+t*7+8.ikme21 EE\(Ȕ[L: T-fk+c(NIn\z @RGU(͂zOŹꅿ v$Ȳ0-~$׹T2?'^ݙ$Wqyq9^]oc-?+ a'!k)܆~Faa3]>`:IocjpA|2lhwN:.QfаhxORU6iHl pkgIndex.tclcgi.tcl]CQ+㽽"3ֽ `|nSFzf4_\,ҬU, P*T~6ͯ妢8:#&Uei":˓~a$gm[Y&!Xfâ%gԑi/~Iɴ:vm4Yqĕ c`zH}}(JԣRM4WT4]a^9X~htJ4oKB5##ECöm#wFzїߧQaf>/%K=>I ,,/(KL*VʏܖNbIW/$\HBCgX8*eqћ7o^=?w J%ؼe.\EBגTQ'欸p4/~/:ѣ^xpEJjLH$4K]PHS01WIxN:#vis:m`h?jdoVʑWTN_˸~V^Q]=4زd-ᮏr ?j}12[BGoDtuY܆VZS70ps8g/1xYr%;^Q)1(+إ=.@8uʫt} f>9ϗyA$K<" ׺B'=KM2jW;8C&hkR,Ʌ"mmO.q@@[=Jb.]5^f@V \ @i+4^>L{!$-Eo¿/H+\=,a}7*\'cP9SixsYXXWDX-܅**3[F&+ A8ZN3Hi8[#7zEyH;D1n*M( 7.6lI_Ty(h,_T_uytV^sb"=&{vd~:lި!s/ds{6ԅ~xv&\$dI N\r2骓FxJ$/<tdpp;$邦MsԼyIZjuƵpX&q!m_Sy%:iߧ]#]²gjZisckLI["r{2 k |_DE*(Z3B(b20|U0@#-:U:Jjߩ>iA]f<(ZnðhP==hj|]-O[W8EGL3ڐϗ$յ!umiІA1rQv\Cȱ~P{MoU~~N9Y#Sͫb/5zG??WR`Qf)ڕNa +t(ˋ[mJ桕hz R_~W5,N!|~ʣDi)z2|N U{'敂|<Ϟ<{/~|>in8|N Cğ.k`=tA]%Ti ]3>\se_,eXc.uJ,f9RLX^QDj( =HiEfg *]>p-%,K5b+O |6Tc\-%/fĒ(Kϩ7DǠUcVݗVb^.񏞯[);)Wr4 ذL'3?!$YSa_t#xP=SkOԑέD&%)Ox|"P۟; {o_E([)}2WTHVNlӊVmI$|Or<`,R ddyfLhRQQ5>a{QQmQa֖k߷TVxnI9Y$q`F6bKըcq lڭyyR":tʚX̶)}Ul)*]9@r'EY8R8'6鼈9}~G(&{'!Qjo+prSnq#TDL3/h2a&dݍ,"]f* 5{`X# e=ɩi6rM)v&;6X96ؼ̹ U>CIqN>jq'(Ts?HSK{١J)DEWd)Z",=RU/^c >\tV(,Ǟ]tgf*Mט6>V_;"I2"&~(r7Һ ډGzmk/~uYw߽p9&Y0g{ Z!tCwLwQxM5o^ϻ겫닶 F֨f1_A:zwtQAlV 2V#lb_m}tD<3RBXvt}T5=۝#c9 YJk>фkjFG"lqhq)S|nrC*=a H/ @ITs.%,cCl'3hrܱ|W v_m{`yPN]:Ю6نwt@zKOMLae_$QbZN-)RƆm;_N&隆?ΡחzߦJUG c#0I˵I]ķ'K^LHs;A *YJE]dE'  SP|LD8ː '|АN&?'6fE8X˱E0@BH^t a+ֽ||04d R;!k4 cHܟ|/Д+&.?>?ϝ+t!K7!jD|2Bxg46Y)w'( ZQ(NsOۧu)q)%#Y60,kFly2 ϙO:̾ןSzIWI.!N=='HnU|~zuAO\PKO@,X12'ld8σM!^Jpu)$)k rѱg8N #ߊ%W|jeN/t9N؃=fMUZtM?Em,~cdJWGEݙQ1AK;?oT&Q-8O=m49p9h{Nu7ƭ2”uRaR,@R 2;L^ 4 Ї=ViT6(h. maƯP;A5dLJ ' B( cv^:e%*)_`A8wnB[SQbƤ5%h/@r_@WWR&+q7(-qqv,<)s@oȇaFW\^'wkjmy qPKʑ(G$Fc8a<de]",^^^t`Yx)g8XJ lj B8lC"k-ߪ 1(o \>j"- y!nqYVsRi$1^H+y^R? EލD([[.u$>+dDU$吷P2fϤ'i0:AK9ouka+iӌ0Jc>, z&dC S9e23ǐr:N'[N%LhO#o T}SafP`39S_U:ܩf;t`c' +/F9iܚGj6~c"Z; zVMwئj-JRBG@Lwj.h% "L>!|h!5Ĉ9Xu~bzaQ>mGc"q#2MLgw3#]G*p*p>0!Ab&UO$  29xqEXp&6PG[Z{w!1 *z7WRvȪ=nҽ}u/f})\ešu%qK:1ĭ6>csXI ZI/Dw.JvP뛕5^g)ؾII6,VޡgJƭl&jA l3*QDbp0))%F+^l0*Rfo'id8+c: 11* -n8/"*2v4Ϊ3$eRFĻcQ ~%ҷgDgR>VgkYqn[)T{%E >yLKxx)rຖx)'u1W"#FFdgs;XI@vB;Ba4sX̖_Fg{o+8z@Iy^ϑZ jvz1#9&~OXi;oZMV()Iq4q}QG,Əesӗ[9n:7Jy\Jt> ~mGnvReIzlAGd4C`vpJUMJ[i\}f)_Ս Jk"Qij_^Ӡo :{3USs.O+ڥfP[;™ IIn~/oصm?PZ>ꇈngQ)BgD B{+P= GäD}+I4kT}OC!ļ]ן(Qp.A$8ShV9l+oh,l(DV9GƗ= ca;ii.iPޔh&Ȋ޴7Meoae_nCnGA1[XW΢nVA ED̐DYl bk VWiR}IG=w~׹0P}N* ;g+6<$;P|._uW7-Bri}oœ?.GRo`~2N @;lΉWujIWmZ嵆H:Wn,i~rݲVMhr3?gT l#㚰18˪quΏLUE `†;D 'Js Qb 5U٦muͱvr w$Nn9UWÌ '@YHR~ =4]ˮKs`y?;/T-~$r'k^`lًIF蒟M@pi `^ jlwQ?*mƥxXIz6 8 Le씞YP?6@]m7 0 T|S t[s^{5ht5Q=oz͋ؖ QeR}z}:;QVĚ!З%WsN91'TՇu}-h_2 YC*,ͺi7J|ܼZk>0)ݨhÃ}I'w@4Y.#k%1"VDS:OEv10P7aG|{4kW8 ͕h(!\}=v U8+oюcaKQ%W Ѧ=Q/JRwBS&E8[eDG6U9:ZSlpkD\Q{LtT~bgrcͯeF$= F3 ۴:ADl/pp y~@PC4a_rӲإw#[ B}YEI*46evNotwM:6"17.(]m!0soMh_DS8l}DwDq!]#to 7X X\$ה|5lCOqJH\JqgOXrxN*̺&gpz29&$$ } `KP[⍘}D7v|9tS\md3ʤwj;|P^J @߫5޻ N?6OhrD96H6qctNwj_ )Im'U?4k}e kiSǫ{Lm:|Fv)%eNgZ.:4y,I*DNCDl'7jP0RĊX[UEf&")Y\q慾d!lw0pI<iaV6×T*vG.|$ PAJ{( FYlw>L;X@_9%"3U,쌄kJ||J.m5\llڭ M >Ɯۉ'>Sz>X%@hO" ."\MTKIxyV5l~_+߯M*)u|F +!B&@Ui!0@G B紥*Z-8ej6 hzנaoV]>NVTV∳W!8¿zmc4I=v%-U'da(Ziv*qj<&p1ig)#sq5cvm;7 Ƣ_jvDSb|)Ü:ŢS~y $sޠqU!_n0y8\a,GIZ Hk,YqN*Z!rZh7RE'0|L/M+yxO ;w,h8XfЬ'}8Ivea<8+@zC 3i1vb־ɥ\ŕE=]c䮺]לA.I;1̭MkQv{8%2{v\HuضENb] w60 ٸf6څua-8u7ԿSdͬNɞ U]IoiZu{{TSmLK5QgL7'9ISn{'Z8w~fjy ivu;Tn\\D]b9b{R?Dg2;uvu&.9Gs?*M%ZZ1LDyj~#{0ֲ%)jG2bgi/e{Y1qi+#pCT bˑZ*V.3I @>BGbK1Rg35UDإ^=r akz9ehtc̜#F$Ҥ0\dp-YQ]xœmn^1]k(6L] K3Mayh2S8~Lb(458 ²B(dJEiIh dawFA3Ɉۦ@FB 6Q,P!`p] ZJ+n5ߘ~ v/W PX1rW]uAk:!ί+3̖Ӑ[GC8^b3e 0.0&TN&T(.ٜ.r4 T>H2CL^bx=G W%4oUw(5l!izWs09w|u F]rcıN/,"w?Qq!TmDC^KQ< sV۸lqV5$ޯ@MźHiikiDO0ӿkǕ$5R7d¼Ϊijf|lY'WU Jϴ*h뿉l'r mX+I6DԄ@j`5dBUY[}10vKUF܅įA&w ӯ#zؖbKq,X̷+'Yh &aѬFVWBNuU1:vmFۿ Q3`D|RA {Lv1HʀUy,goVI۲'awC>sujڵ&8Y7;cn{pg67$H[4OBmSNReIy"]sJ)D\*'o9!97tQq鸂KV Kq[C:ޕD=e$N )YEܳ,rA<+]-6{*P%j^N.\EYq,mYPfÀ_pbH]hZ{&m15[0J-OΥ6eaCO=FÓV!gs\A䤌UCmz9>uIƉSXUϢ 䦹LZ>Ҽx'Wsؗe 7̡:އ2JV{ڔyֱi T DJRXOTT 81,FBc xS*Wu5XJѯy-[g1GuX $+ڭ w;JhWVtf.i; U5ʀ8OYi:{O9zٖ/oW܈|Ŵ.ti45b^_<Bs6^_V}@m¿f]VHvzxvXH5Q9OtǞ>/_`H4*TWb69huNVcM PMa 9|1ö>-BCU~;ixIx'cy6a$bJD~6# @-K'*ֽ_u@exedA1#~}I^ _/~|/)n8g2{1['OmsI3Wnnnd |/gͰ=ӹD`<6-gpp U$MP BF,}2M 7 4$=[TR7~W-f+㍹ UX; _و]QN/̲ϹV]C<{h\A`;J{ms8d0M (g.UÞQ!.6F9 eњAL;HY{΁KAzBm®H\3qj;ܙ(PG+gJ["^NݎJ9JugcZmfD]T jrV*]J}0$ƧmVTwC寅En }2y>wyu{occ8# w8FE;oƓ v<7w fG]E٫q6񽳴&}- z&B# +'EC2,Z;&VW-E{2W@geZ[lj|""oRuH}ia==gyO5 0c~1XJ37'zXu.J+LX<-XXqc&\<TrHzJ04 v܉m᭼^T' yrTG*nTCء٩,4abIiog{q4C[7>N O:|#AK+Q@ $]"*Zb>"2E!ՒZpf-|LE\=uZKeʞ L (J:PyJ.~4_pNIaE k9zMic=Tv/cp2& oݦ^;87ՁԣoN77$]q$?G]R!1U(!ۍV\!$_K/_kYMJ;x5^{cuڴQ[7h9wunPMUSnprWGU~Ȍ2bkB՗-;=C۟H3D*L fĄ]=pĹ#/i"04&V]VH, {Vjn [y,/щE] <=cժކEܳ캒%\}d݃6öDB̳{$j??zG_?OJVkum}.mmntڒ擎˪ ?B]0֞lM+ w5|ހ>1xQcM­15ʯ,,4ryC:Nҝ.n$xuW9E5Rt᪶}m6tRmlp;;7n¹BYgd&c_\ q N㪼U$}Y&dU2 })!sG@q&VLrhmTBnPϛ=1}֞p*[x:@yO^isUux-r}<Þ54Z=}z7ey' dk@vFq#n(S&kG kHy-ji )je!Yvl͙N2<s?[7GޜO9x|?Mob>r^·>gᆟ ɏw%t E/8@,8s/>q^.WJ×goCXt w]]x_}'8].z-BUlc*uǛ鹎& p'[T([-vUhB1Й `b9q1~԰vfib>8&?'p)//5\g~d@FXp<&3A+}"QI'8 /?נVGY Q+u} œG {|1g)眣ej1$n :q X(5[mķa2~0o>6x7B"͜<~gn[㍺fҹJ~|ɬG!o$<1g8z"q:I`NwJSamGpЦ&6avG t9A[eC@oMa&Ӳ@v薢Z&AlJ)\&:13_px8k2甊%\bIPǹ ]~|_ Bew8~Rn,B]t1iw 䯍\ G]d*̣q8 BqEx}F;2$s(p6^p3ͩ}ΨDԺ3b)QnS)*;N;%~~^s0.lqZ5pUiE4" 4?Y VԷz<.ԏ$Qla A [lq0N %lHLE_Blzv1Ӕư]zGviR2!Az۬XyT$=:gd`?`z ZqQsDO@C$Rr *#<Ӊc\ؖz4lN4#NET{~g:bXTU>+74 YH+bWŸxsLaſuK߽~;Hl&HǒG6E+!m܆߳4-wFRmJy#GsMЄ08˼p埱Dẞ\K.yrx \- -Xbp_xɈBŦNlRg al/;"I"}NJBIo fE<Őx<$%3@ed[ RX/$sVJٗ5i@##಑ #ӘuU[{ɋ ?qZb15XΟ/1I=z 耀 օڀ߀dirs[name:S,parent:I,files[name:S,size:I,date:I,contents:B]]NCNvqcore/data/mkblk.db0000644000076500007650000002355410574360066014317 0ustar jcwjcw00000000000000LJ'l  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~~}|{zyxwvutsrqponmlkjihgfedcba`_^]\[ZYXWVUTSRQPONMLKJIHGFEDCBA@?>=<;:9876543210/.-,+*)('&%$#"!  ~}|{zyxwvutsrqponmlkjihgfedcba`_^]\[ZYXWVUTSRQPONMLKJIHGFEDCBA@?>=<;:9876543210/.-,+*)('&%$#"!  ~}|{zyxwvutsrqponmlkjihgfedcba`_^]\[ZYXWVUTSRQPONMLKJIHGFEDCBA@?>=<;:9876543210/.-,+*)('&%$#"!  ~}|{zyxwvutsrqponmlkjihgfedcba`_^]\[ZYXWVUTSRQPONMLKJIHGFEDCBA@?>=<;:9876543210/.-,+*)('&%$#"!       !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ ~}|{zyxwvutsrqponmlkjihgfedcba`_^]\[ZYXWVUTSRQPONMLKJIHGFEDCBA@?>=<;:9876543210/.-,+*)('&%$#"!  ~}|{zyxwvutsrqponmlkjihgfedcba`_^]\[ZYXWVUTSRQPONMLKJIHGFEDCBA@?>=<;:9876543210/.-,+*)('&%$#"!  ~}|{zyxwvutsrqponmlkjihgfedcba`_^]\[ZYXWVUTSRQPONMLKJIHGFEDCBA@?>=<;:9876543210/.-,+*)('&%$#"!  ~}|{zyxwvutsrqponmlkjihgfedcba`_^]\[ZYXWVUTSRQPONMLKJIHGFEDCBA@?>=<;:98765432      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                           ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~  0/.-,+*)('&%$#"!  ~}|{zyxwvutsrqponmlkjihgfedcba`_^]\[ZYXWVUTSRQPONMLKJIHGFEDCBA@?>=<;:9876543210/.-,+*)('&%$#"!  ~}|{zyxwvutsrqponmlkjihgfedcba`_^]\[ZYXWVUTSRQPONMLKJIHGFEDCBA@?>=1Έր.>FNNNbv[_B[k1:I,k2:I]]N'\'Evqcore/etc/0000755000076500007650000000000010604271327012534 5ustar jcwjcw00000000000000vqcore/etc/includer.tcl0000755000076500007650000000211010575021060015034 0ustar jcwjcw00000000000000#!/usr/bin/env tclkit # includer -=- expand includes into source files if {[llength $argv] < 1} { puts stderr "Usage: $argv0 file ?omit...? >result" exit 1 } proc expand {fn} { global files seen set f [file tail $fn] if {![info exists files($f)]} { return 0 } if {![info exists seen($f)]} { set seen($f) $fn set fd [open $files($f)] set re {#include\s*[<"]([^"]+)[>"]} ;# "]"]" while {[gets $fd line] >= 0} { if {[regexp $re $line - path] && [expand $path]} { continue } puts $line } close $fd } return 1 } set f [lindex $argv 0] set ifd [open $f] foreach x $argv { set omit($x) "" } set prefix [file dirname $f] while {[gets $ifd line] >= 0} { if {[regexp {%includeDir<(.*)>%} $line - path]} { foreach g [glob [file join $prefix $path/*]] { set t [file tail $g] if {![info exists omit($t)]} { set files($t) $g } } #parray files } if {[regexp {%include<(.*)>%} $line - match]} { puts $line if {$match ne ""} { expand $match } } else { puts $line } } close $ifd vqcore/etc/lua.c0000644000076500007650000000072510575021060013457 0ustar jcwjcw00000000000000/* vlerq.c - this is the single-source-file version of Vlerq for Lua */ /* %includeDir<../src>% */ /* %includeDir<../src_lua>% */ /* %include% */ /* %include% */ /* %include% */ /* %include% */ /* %include% */ /* %include% */ /* %include% */ /* %include% */ /* %include% */ /* %include% */ /* %include% */ /* %include% */ /* end of generated code */ vqcore/etc/lua.h0000644000076500007650000000035610575021060013464 0ustar jcwjcw00000000000000/* vlerq.h - this is the single-source-file header of Vlerq for Lua */ /* %includeDir<../src>% */ /* %includeDir<../src_lua>% */ /* %include% */ /* %include% */ /* %include% */ /* end of generated code */ vqcore/etc/objc.c0000644000076500007650000000073610575021060013615 0ustar jcwjcw00000000000000/* vlerq.c - this is the single-source-file version of Vlerq for Objective-C */ /* %includeDir<../src>% */ /* %includeDir<../src_objc>% */ /* %include% */ /* %include% */ /* %include% */ /* %include% */ /* %include% */ /* %include% */ /* %include% */ /* %include% */ /* %include% */ /* %include% */ /* %include% */ /* %include% */ /* end of generated code */ vqcore/etc/objc.h0000644000076500007650000000036710575021060013622 0ustar jcwjcw00000000000000/* vlerq.h - this is the single-source-file header of Vlerq for Objective-C */ /* %includeDir<../src>% */ /* %includeDir<../src_objc>% */ /* %include% */ /* %include% */ /* %include% */ /* end of generated code */ vqcore/etc/opgen.tcl0000755000076500007650000003102310575021060014344 0ustar jcwjcw00000000000000#!/usr/bin/env tclkit # Detect Web Preview mode (TextMate): if {[lappend env(PWD)] eq "/" && [info exists env(TM_MODE)]} { catch { cd $env(TM_DIRECTORY) } puts {
}
}

proc : {name in out {def ""}} {
  set id [string tolower $name]
  set ::defs($id) [list $out $in $def $name]
  if {[info exists ::only]} {
    set ::include($::only,$id) $name
    set ::exclude($id) $name
  }
}
proc tcl {cmds} {
  set ::only tcl
  uplevel 1 $cmds
  unset ::only
}
proc python {cmds} {
  set ::only python
  uplevel 1 $cmds
  unset ::only
}
proc ruby {cmds} {
  set ::only ruby
  uplevel 1 $cmds
  unset ::only
}
proc objc {cmds} {
  set ::only objc
  uplevel 1 $cmds
  unset ::only
}
proc lua {cmds} {
  set ::only lua
  uplevel 1 $cmds
  unset ::only
}
proc unsafe {args} {
  foreach x $args {
    set ::unsafecmds([string tolower $x]) $x
  }
}
proc prepare {} {
  global names defs
  set names [lsort -dict [array names defs]]
}
proc fieldname {type} {
  string map {C .c I .i L .w F .d D .d S .s B .s \
              V .v i .c s .c n .c N .i O .o} $type
}
proc fieldtype {type} {
  string map {C Column I int L int64_t F float D double S {const char*} \
              V View_p i Column s Column n Column N int O Object_p} $type
}
proc itemtype {out} {
  set last [string index $out end]
  set type [string map {I int S string V view C column U unknown} $last]
  return IT_$type
}
proc gen-headers {} {
  set o1 {}
  set o2 {}
  foreach name $::names {
    foreach {out in def ident} $::defs($name) break
    if {$name eq $ident} continue
    #if {[llength $def] == 0} continue

    if {[llength $def] == 1} {
      set r {}
      foreach x [split $in ""] {
        lappend r [fieldtype $x]
      }
      if {$r eq ""} { set r void }
      lappend o1 "[format %-6s [fieldtype $out]] ($def) ([join $r {, }]);"
    }

    append o2 "ItemTypes (${ident}Cmd_$in) (Item_p a);\n"
  }
  emit src/wrap_gen.h "[join [lsort -index 1 $o1] \n]\n\n$o2"
}
proc gen-simple {} {
  set o {}
  foreach name $::names {
    foreach {out in def ident} $::defs($name) break
    if {$name eq $ident} continue
    if {[llength $def] != 1} continue

    if {$def eq ""} { set def $ident }

    set i 0
    set r {}
    foreach x [split $in ""] {
      lappend r "a\[$i][fieldname $x]"
      incr i
    }
    set avec [join $r ", "]

    set last [string index $out end]

    append o "
ItemTypes ${ident}Cmd_$in (Item_p a) {
  a\[0][fieldname $last] = ${def}($avec);
  return [itemtype $out];
}
"
  }
  return $o
}
proc gen-compound {} {
  set o {}
  foreach name $::names {
    foreach {out in def ident} $::defs($name) break
    if {$name eq $ident} continue
    if {[string first " " $def] < 0} continue

    append o "
/* : $name ( $in-$out ) $def ; */
ItemTypes ${ident}Cmd_$in (Item_p a) {
"
    if {$def != " "} {
      append o "  ItemTypes t;\n"
    }
    
    set l [string length $in]
    foreach d $def {
      if {[string is int $d]} {
        append o "  a\[$l].i = $d;\n"
        incr l
      } else {
        if {![info exists ::defs($d)]} {
          error "$name: can't find definition of '$d'"
        }
        foreach {out2 in2 def2 ident2} $::defs($d) break
        incr l -[string length $in2]
        if {$l < 0} {
          error "$name: stack underflow with call to '$d'"
        }
        set a a
        if {$l > 0} { append a + $l }
        if {$d eq $ident2} {
          foreach x {0 1 2 3 4} {
            set $x "a\[[expr {$l+$x}]]"
          }
          append o "  /* $d $l */ [subst -nocommands $def2]\n"
        } else {
          set x [expr {$l + [string length $out2]}]
          append o "  t = ${ident2}Cmd_${in2}($a);\n"
        }
        incr l [string length $out2]
      }
    }
    if {[incr l -1] > 0} {
      append o "  a\[0] = a\[$l];\n"
    }
    set u [itemtype $out]
    if {$u eq "IT_unknown"} {
      set u t
    }
    append o "  return $u;
}
"
  }
  return $o
}
proc gen-tcl-index {input} {
  set n 0
  foreach name $::names {
    foreach {out in def ident} $::defs($name) break
    if {$name eq $ident || ([info exists ::exclude($name)] &&
                            ![info exists ::include(tcl,$name)])} continue
    incr n
  }
  set o "/* $n definitions generated for Tcl:\n$input*/\n\n"
  set n 0
  foreach safe {0 1} {
    foreach name $::names {
      if {[info exists ::unsafecmds($name)] == $safe} continue
      foreach {out in def ident} $::defs($name) break
      if {$name eq $ident || ([info exists ::exclude($name)] &&
                              ![info exists ::include(tcl,$name)])} continue
      append o [format {  { %-13s %-11s %-18s },} \
                          \"$name\", \"$out:$in\", ${ident}Cmd_$in] \n
      incr n
    }
    if {!$safe} {
      append o "#define UNSAFE $n\n"
    }
  }
  emit src_tcl/opdefs_gen.h $o
}
proc gen-ruby-index {input} {
  set n 0
  foreach name $::names {
    foreach {out in def ident} $::defs($name) break
    if {$name eq $ident || ([info exists ::exclude($name)] &&
                            ![info exists ::include(ruby,$name)])} continue
    incr n
  }
  set o "/* $n definitions generated for Ruby:\n$input*/\n\n"
  set n 0
  foreach name $::names {
    foreach {out in def ident} $::defs($name) break
    if {$name eq $ident || ([info exists ::exclude($name)] &&
                            ![info exists ::include(ruby,$name)])} continue

    append o [format {  { %-13s %-11s %-18s },} \
                        \"$name\", \"$out:$in\", ${ident}Cmd_$in] \n
    incr n
  }
  emit src_ruby/vlerq_ext.h $o
}
proc gen-objc-index {input} {
  set n 0
  foreach name $::names {
    foreach {out in def ident} $::defs($name) break
    if {$name eq $ident || ([info exists ::exclude($name)] &&
                            ![info exists ::include(objc,$name)])} continue
    incr n
  }
  set o "/* $n definitions generated for Objective-C:\n$input*/\n\n"
  set n 0
  foreach name $::names {
    foreach {out in def ident} $::defs($name) break
    if {$name eq $ident || ([info exists ::exclude($name)] &&
                            ![info exists ::include(objc,$name)])} continue

    append o [format {  { %-13s %-11s %-18s },} \
                        \"$name\", \"$out:$in\", ${ident}Cmd_$in] \n
    incr n
  }
  emit src_objc/vlerq_ext.h $o
}
proc gen-lua-index {input} {
  set n 0
  foreach name $::names {
    foreach {out in def ident} $::defs($name) break
    if {$name eq $ident || ([info exists ::exclude($name)] &&
                            ![info exists ::include(lua,$name)])} continue
    incr n
  }
  set o "/* $n definitions generated for Lua:\n$input*/\n\n"
  set n 0
  foreach name $::names {
    foreach {out in def ident} $::defs($name) break
    if {$name eq $ident || ([info exists ::exclude($name)] &&
                            ![info exists ::include(lua,$name)])} continue

    append o [format {  { %-13s %-11s %-18s },} \
                        \"$name\", \"$out:$in\", ${ident}Cmd_$in] \n
    incr n
  }
  emit src_lua/vlerq_ext.h $o
}
proc gen-python-index {input} {
  set n 0
  foreach name $::names {
    foreach {out in def ident} $::defs($name) break
    if {$name eq $ident || ([info exists ::exclude($name)] &&
                            ![info exists ::include(python,$name)])} continue
    incr n
  }
  set o "/* $n definitions generated for Python:\n$input*/\n\n"
  set n 0
  foreach name $::names {
    foreach {out in def ident} $::defs($name) break
    if {$name eq $ident || ([info exists ::exclude($name)] &&
                            ![info exists ::include(python,$name)])} continue

    append o [format {  { %-13s %-11s %-18s },} \
                        \"$name\", \"$out:$in\", ${ident}Cmd_$in] \n
    incr n
  }
  emit src_python/vlerq_ext.h $o
}
proc emit {name text} {
  set path [file normalize [file dirname [info script]]/../$name]
  set text "/* [file tail $name] - generated code, do not edit */\n
[string trim $text]\n
/* end of generated code */"
  if {[info script] eq ""} {
    puts $text
  } else {
    set fd [open $path w]
    puts $fd $text
    close $fd
  }
  puts "$path: [llength [split $text \n]] lines"
}
proc gen-wrappers {} {
  set o {
#include 

#include "intern.h"
#include "wrap_gen.h"
  }
  append o [gen-simple] [gen-compound]
  emit src/wrap_gen.c $o
}
proc generate {input} {
  uplevel $input
  prepare
  gen-headers
  gen-tcl-index $input
  gen-ruby-index $input
  gen-objc-index $input
  gen-python-index $input
  gen-lua-index $input
  gen-wrappers
  #puts $errorInfo
}

generate {
  # name       in     out    inline-code
  : drop       U      {}     {}
  : dup        U      UU     {$1 = $0;}
  : imul       II     I      {$0.i *=  $1.i;}
  : nip        UU     U      {$0 = $1;}
  : over       UU     UUU    {$2 = $0;}
  : rot        UUU    UUU    {$3 = $0; $0 = $1; $1 = $2; $2 = $3;}
  : rrot       UUU    UUU    {$3 = $2; $2 = $1; $1 = $0; $0 = $3;}
  : swap       UU     UU     {$2 = $0; $0 = $1; $1 = $2;}
  : tuck       UU     UUU    {$1 = $2; $0 = $1; $2 = $0;}
  
  tcl {
    # name       in    out
    : Def        OO     V
    : Deps       O      O
    : Emit       V      O
    : EmitMods   V      O
    : Get        VX     U
    : Load       O      V
    : LoadMods   OV     V
    : Loop       X      O
    : MutInfo    V      O
    : Ref        OX     O
    : Refs       O      I
    : Rename     VO     V
    : Save       VS     I
    : To         OO     O
    : Type       O      O
    : View       X      O
  }
  
  python {
    # name       in    out
  }
  
  ruby {
    # name       in    out
    : AtRow      OI     O
  }
  
  lua {
    # name       in    out
  }
  
  objc {
    # name       in    out
    : At         VIO    O
  }
  
  # name       in    out
  : BitRuns    i      C
  : Data       VX     V
  : Debug      I      I
  : HashCol    SO     C
  : Max        VN     O
  : Min        VN     O
  : Open       S      V
  : ResizeCol  iII    C
  : Set        MIX    V
  : StructDesc V      S
  : Structure  V      S
  : Sum        VN     O
  : Write      VO     I

  # name       in    out  internal-name
  : Blocked    V      V   BlockedView
  : Clone      V      V   CloneView
  : ColMap     Vn     V   ColMapView
  : ColOmit    Vn     V   ColOmitView
  : Coerce     OS     C   CoerceCmd
  : Compare    VV     I   ViewCompare
  : Compat     VV     I   ViewCompat
  : Concat     VV     V   ConcatView
  : CountsCol  C      C   NewCountsColumn
  : CountView  I      V   NoColumnView
  : First      VI     V   FirstView
  : GetCol     VN     C   ViewCol
  : Group      VnS    V   GroupCol
  : HashFind   VIViii I   HashDoFind
  : Ijoin      VV     V   IjoinView
  : GetInfo    VVI    C   GetHashInfo
  : Grouped    ViiS   V   GroupedView
  : HashView   V      C   HashValues
  : IsectMap   VV     C   IntersectMap
  : Iota       I      C   NewIotaColumn
  : Join       VVS    V   JoinView
  : Last       VI     V   LastView
  : Mdef       O      V   ObjAsMetaView
  : Mdesc      S      V   DescToMeta
  : Meta       V      V   V_Meta
  : OmitMap    iI     C   OmitColumn
  : OneCol     VN     V   OneColView
  : Pair       VV     V   PairView
  : RemapSub   ViII   V   RemapSubview
  : Replace    VIIV   V   ViewReplace
  : RowCmp     VIVI   I   RowCompare
  : RowEq      VIVI   I   RowEqual
  : RowHash    VI     I   RowHash
  : Size       V      I   ViewSize
  : SortMap    V      C   SortMap
  : Step       VIIII  V   StepView
  : StrLookup  Ss     I   StringLookup
  : Tag        VS     V   TagView
  : Take       VI     V   TakeView
  : Ungroup    VN     V   UngroupView
  : UniqueMap  V      C   UniqMap
  : ViewAsCol  V      C   ViewAsCol
  : Width      V      I   ViewWidth
               
  # name       in    out  compound-definition
  : Append     VV     V   {over size swap insert}
  : ColConv    C      C   { }
  : Counts     VN     C   {getcol countscol}
  : Delete     VII    V   {0 countview replace}
  : Except     VV     V   {over swap exceptmap remap}
  : ExceptMap  VV     C   {over swap isectmap swap size omitmap}
  : Insert     VIV    V   {0 swap replace}
  : Intersect  VV     V   {over swap isectmap remap}
  : NameCol    V      V   {meta 0 onecol}
  : Names      V      C   {meta 0 getcol}
  : Product    VV     V   {over over size spread rrot swap size repeat pair}
  : Repeat     VI     V   {over size imul 0 1 1 step}
  : Remap      Vi     V   {0 -1 remapsub}
  : Reverse    V      V   {dup size -1 1 -1 step}
  : Slice      VIII   V   {rrot 1 swap step}
  : Sort       V      V   {dup sortmap remap}
  : Spread     VI     V   {over size 0 rot 1 step}
  : Types      V      C   {meta 1 getcol}
  : Unique     V      V   {dup uniquemap remap}
  : Union      VV     V   {over except concat}
  : UnionMap   VV     C   {swap exceptmap}
  : ViewConv   V      V   { }
  
  # some operators are omitted from restricted execution environments
  unsafe Open Save
}
vqcore/etc/python.c0000644000076500007650000000073310575021060014216 0ustar  jcwjcw00000000000000/* vlerq.c - this is the single-source-file version of Vlerq for Python */

/* %includeDir<../src>% */
/* %includeDir<../src_python>% */

/* %include% */
/* %include% */
/* %include% */
/* %include% */
/* %include% */
/* %include% */
/* %include% */
/* %include% */
/* %include% */
/* %include% */
/* %include% */
/* %include% */

/* end of generated code */
vqcore/etc/python.h0000644000076500007650000000036410575021060014223 0ustar  jcwjcw00000000000000/* vlerq.h - this is the single-source-file header of Vlerq for Python */

/* %includeDir<../src>% */
/* %includeDir<../src_python>% */

/* %include% */
/* %include% */
/* %include% */

/* end of generated code */
vqcore/etc/ruby.c0000644000076500007650000000072710575021060013661 0ustar  jcwjcw00000000000000/* vlerq.c - this is the single-source-file version of Vlerq for Ruby */

/* %includeDir<../src>% */
/* %includeDir<../src_ruby>% */

/* %include% */
/* %include% */
/* %include% */
/* %include% */
/* %include% */
/* %include% */
/* %include% */
/* %include% */
/* %include% */
/* %include% */
/* %include% */
/* %include% */

/* end of generated code */
vqcore/etc/ruby.h0000644000076500007650000000036010575021060013657 0ustar  jcwjcw00000000000000/* vlerq.h - this is the single-source-file header of Vlerq for Ruby */

/* %includeDir<../src>% */
/* %includeDir<../src_ruby>% */

/* %include% */
/* %include% */
/* %include% */

/* end of generated code */
vqcore/etc/tcl.c0000644000076500007650000000112610575021060013454 0ustar  jcwjcw00000000000000/* vlerq.c - this is the single-source-file version of Vlerq for Tcl */

/* %includeDir<../src>% */
/* %includeDir<../src_tcl>% */

/* %include% */
/* %include% */
/* %include% */
/* %include% */
/* %include% */
/* %include% */
/* %include% */
/* %include% */
/* %include% */
/* %include% */
/* %include% */
/* %include% */

/* %include% */
/* %include% */
/* %include% */
/* %include% */
/* %include% */

/* end of generated code */
vqcore/etc/xcode-tests.tcl0000644000076500007650000000040010604271327015474 0ustar  jcwjcw00000000000000# used by xcode with tclg from the build/{Debug,Release}/ directories

puts "Running [file normalize [info script]]"
lappend auto_path [pwd] /System/Library/Tcl

set argv {-v pe}
source ../../tests/all.tcl
#source ../../tests/ref.test

#puts [info loaded]
vqcore/make.deps0000644000076500007650000000157010574360066013563 0ustar  jcwjcw00000000000000# DO NOT DELETE

bits.o: src/intern.h src_tcl/defs.h
buffer.o: src/intern.h src_tcl/defs.h
column.o: src/intern.h src_tcl/defs.h src/wrap_gen.h
emit.o: src/intern.h src_tcl/defs.h src/wrap_gen.h
file.o: src/intern.h src_tcl/defs.h src/wrap_gen.h
getters.o: src/intern.h src_tcl/defs.h
hash.o: src/intern.h src_tcl/defs.h src/wrap_gen.h
indirect.o: src/intern.h src_tcl/defs.h src/wrap_gen.h
mutable.o: src/intern.h src_tcl/defs.h src/wrap_gen.h
sorted.o: src/intern.h src_tcl/defs.h src/wrap_gen.h
view.o: src/intern.h src_tcl/defs.h src/wrap_gen.h
wrap_gen.o: src/intern.h src_tcl/defs.h src/wrap_gen.h
colobj.o: src_tcl/ext_tcl.h src/intern.h src_tcl/defs.h
colobj.o: src/wrap_gen.h
ext_tcl.o: src_tcl/ext_tcl.h src/intern.h src_tcl/defs.h
ext_tcl.o: src/wrap_gen.h src_tcl/stubs.h src_tcl/opdefs_gen.h
viewobj.o: src_tcl/ext_tcl.h src/intern.h src_tcl/defs.h
viewobj.o: src/wrap_gen.h
vqcore/make.syms0000644000076500007650000000003410574360066013615 0ustar  jcwjcw00000000000000_Vlerq_Init
_Vlerq_SafeInit
vqcore/Makefile0000644000076500007650000001276210634054601013426 0ustar  jcwjcw00000000000000# Makefile - Build the Vlerq Tcl extension on Mac OS X and some other platforms
#
# NOTE: when this file or an include dependency changes, do "make clean"

GEN_SRCS = bits.c buffer.c cmds.c column.c emit.c file.c getters.c hash.c \
 	   indirect.c loop.c mutable.c sorted.c view.c wrap_gen.c
TCL_SRCS = colobj.c ext_tcl.c viewobj.c

# support compilation on a few platforms, the default is for Linux
#   on Mac OS X: include "ARCHSUFFIX=.macosx" in the environment
#   for Windows: include "ARCHSUFFIX=.win32" in the environment

ifeq ($(ARCHSUFFIX),)
# find Tcl headers on Ubuntu Linux:
	CFLAGS += -I/usr/include/tcl8.4 -fPIC -fomit-frame-pointer -Wno-long-long
	dll = .so
	dyn = -shared
endif
ifeq ($(ARCHSUFFIX),.macosx)
	dll = .dylib
	dyn = -dynamiclib -fno-common -exported_symbols_list make.syms
endif
ifeq ($(ARCHSUFFIX),.win32)
	CC = gcc
# find Tcl headers when cross-compiling via xmingw32.sh:
	CFLAGS += -I/System/Library/Frameworks/Tcl.framework/Headers
	CFLAGS += -fomit-frame-pointer -Wno-long-long
	dll = .dll
	dyn = -shared
endif

CFLAGS += -DDEBUG -Isrc_tcl -g -Wall -pedantic -Wstrict-prototypes -O0
TARGET = libvlerq4$(dll)
VPATH = src_tcl:src
RATDIR = ../ratcl/lib/vlerq4
RBYDIR = ../ruby
TEADIR = ../tcl
OBCDIR = ../objc
LUADIR = ../lua
PYTDIR = ../python
K64DIR = ../kitgen/8.4/kit-b64

SRCS = $(GEN_SRCS:%=src/%) $(TCL_SRCS:%=src_tcl/%)
OBJS = $(GEN_SRCS:.c=.o) $(TCL_SRCS:.c=.o)

.PHONY: all test smoke crosstest rat clean docs macosx macppc mac_64 win32 \
	release linux puppie-fixclock puppie teevie drakie bunnie gennie \
	tea ruby python objc lua bindings debbie-fixclock debbie etchie

all: $(TARGET)

$(TARGET): $(OBJS)
	@echo Linking $(TARGET)
	@$(CC) $(dyn) -o $@ $(OBJS) $(LDFLAGS)
	@echo OK

test: $(TARGET)
	tests/all.tcl

smoke: $(TARGET)
	tests/basic.test

release: macppc linux win32 test
	ls -l libvlerq4.*.gz

# macppc uses a universal build and a ppc binary to test in a big-endian context
 macppc: macosx
	cp build/Release/libvlerq4.dylib .
	tclkit84ppc tests/all.tcl
	rm libvlerq4.dylib
	
# mac_64 uses a 64-bit intel binary built by kitgen to test in a 64-bit context
# must update kitgen and use tests from tea dir to get the version numbers right
 mac_64: tea
	cd $(K64DIR) && rm -rf build/vlerq && make
	$(K64DIR)/tclkit-cli $(TEADIR)/tests/all.tcl

# macosx builds an optimized ppc/ppc64/i386/x86_64 universal library using xcode
 macosx:
	xcodebuild -project vlerq.xcodeproj -configuration Release && \
	  cp build/Release/libvlerq4.dylib . && gzip -f libvlerq4.dylib

# win32 builds a dll using a mingw cross-compiler from macosx
 win32: clean
	( . xmingw32.sh; \
	  make && strip libvlerq4.dll && gzip -f libvlerq4.dll; \
	  make clean )

# linux builds use remote machines, though puppie & debbie run under a vm
 linux: debbie-fixclock debbie
	mv libvlerq4.so-debbie.gz libvlerq4.so.gz
 debbie-fixclock:
	setdate-ssh debbie
 puppie-fixclock:
	setdate-ssh puppie
# bunnie: Ubuntu, drakie: Mandrake 7.2, gennie: Gentoo, puppie: Puppy Linux,
# teevie: Ubuntu 64b, debbie: Debian 3.1, etchie: Debian 4.0
# these targets expect to find a tclkit in the path to run the tests
 bunnie debbie drakie etchie gennie puppie teevie: clean
	rsync -a --exclude=libvlerq4.* --exclude=testfiles.tmp . $@:/tmp/vlerq
	sleep 2 ;# avoid clock skew problems
	ssh $@ 'cd /tmp/vlerq && make clean && PATH=~/bin:$$PATH make test && \
		strip libvlerq4.so && gzip -f libvlerq4.so'
	rsync -a $@:/tmp/vlerq/libvlerq4.so.gz libvlerq4.so-$@.gz

# build binaries for multiple platforms for the ratcl.kit package
rat:
	gzip -d $(RATDIR)/libvlerq4.dll
	gzip -d $(RATDIR)/libvlerq4.dylib
	gzip -d $(RATDIR)/libvlerq4.so
	rsync -a src_tcl/{m2mvfs,mkclvfs,mklite,ratcl}.tcl $(RATDIR)/
	
# generate a merged source file for the TEA3 Tcl extension
tea:
	etc/includer.tcl etc/tcl.c >$(TEADIR)/generic/vlerq.c
	rsync -a --exclude=.svn data tests $(TEADIR)
	rsync -a src_tcl/m2mvfs.tcl src_tcl/mkclvfs.tcl \
		  src_tcl/mklite.tcl src_tcl/ratcl.tcl $(TEADIR)/library/

# generate a merged source file for the Ruby extension
ruby:
	etc/includer.tcl etc/ruby.h >$(RBYDIR)/ext/vlerq.h
	etc/includer.tcl etc/ruby.c >$(RBYDIR)/ext/vlerq.c
	rsync -a src_ruby/vlerq_ext.h $(RBYDIR)/ext/vlerq_ext.h

# generate a merged source file for the Python extension
python:
	etc/includer.tcl etc/python.h >$(PYTDIR)/vlerq.h
	etc/includer.tcl etc/python.c >$(PYTDIR)/vlerq.c

# generate a merged source file for the Objective-C extension
objc:
	etc/includer.tcl etc/objc.h >$(OBCDIR)/vlerq.h
	etc/includer.tcl etc/objc.c >$(OBCDIR)/vlerq.c

# generate a merged source file for the Lua extension
lua:
	etc/includer.tcl etc/lua.h >$(LUADIR)/vlerq.h
	etc/includer.tcl etc/lua.c >$(LUADIR)/vlerq.c

# generate all bindings and run some quick tests
bindings: tea ruby python objc lua
	cd $(TEADIR) && sh configure && make test
	cd $(RBYDIR) && rake test
	cd $(PYTDIR) && python setup.py build && try.py
	cd ../js/mywkpi && xcodebuild -configuration Release
	
# grind does a valgrind run on puppie, with startup messages suppressed
grind: puppie
	ssh puppie 'cd /tmp/vlerq && make && \
	  valgrind -q --suppressions=/home/jcw/vg.supp --leak-check=full \
	           ~/kitgen/8.4/base-std/build/bin/tclsh8.4 tests/all.tcl'

# this is not for general use, due to the custom script and hard-wired paths
docs:
	markdown-tm 'Vlerq tech notes' \
	  ~/Sites/www.equi4.com/vlerqnotes.html
	
clean:
	rm -f $(OBJS) $(TARGET)
ifeq ($(ARCHSUFFIX),.macosx)
	makedepend -f- -Y -- $(CFLAGS) -- $(SRCS) 2>/dev/null | \
		sed 's|^src[_a-z]*/||' >make.deps
endif

-include make.deps
vqcore/pkgIndex.tcl0000644000076500007650000000045510574360066014247 0ustar  jcwjcw00000000000000if {[file exists [file join $dir libvlerq4[info sharedlibext]]]} {
  package ifneeded vlerq 4 \
    [list load [file join $dir libvlerq4[info sharedlibext]]]
}

if {[file exists [file join $dir src_tcl ratcl.tcl]]} {
  package ifneeded ratcl 4 \
    [list source [file join $dir src_tcl ratcl.tcl]]
}
vqcore/README0000644000076500007650000002170110606405316012641 0ustar  jcwjcw00000000000000VLERQ TECH NOTES
================

These work-in-progress notes describe various design aspects of Vlerq.

The functionality of Vlerq is divided into two layers: _views_ and _dataflow_.
The views layer does the "real" processing. The dataflow layer is built on top
and is responsible for lazy evaluation and change propagation.

The views layer doesn't know about the dataflow layer and has no pointers to it.


Basic data types
----------------

**Views** are a general purpose data structure. At the views level, there are
many fairly straightforward functions, implementing operations on views and
dealing with their construction and destruction.

Views are manually reference-counted, using `IncViewRef` and `DecViewRef`.

Views are made up of columns, the C struct name for that is `Sequence`, which
are also reference-counted using `AdjustSeqRefs`.

A view is also a sequence, i.e. a sequence of columns. The `{Inc,Dec}ViewRef`
functions are thin wrappers around `AdjustSeqRefs`. Which also means that there
is only one ref-counted type of object, and that a single uniform ref-counting
mechanism is used for both views and columns.

A **column** is a (seqptr, colnum) tuple, i.e. a sequence pointer and a column
index. The C struct name is `Column`, they are usually passed around by value.

An **item** is a union which holds all sorts of values. Items are used to pass
data around which can have varying types. Items are not used inside columns,
only between functions - to get around static typing in C. The `Item` struct is
a C union without type tag - these are either implicit in each context or they
must be passed around separately. The `ItemTypes` enum defines `IT_*` constants
for all the possible types.

To extract an item from a column `c` at row `r`, when its type is _not_ known:

    Item item;
    ItemTypes type;
    
    item.c = column;
    type = GetItem(r, &item);

The result is left in the `item` variable, and the type is returned.

If the type is known to be -say- a string, things become a lot more convenient:

    const char* s = GetColItem(r, c, IT_string).s;

The `IT_string` type is only passed in for debugging purposes, failure to match
will throw an error during development.


The Views layer
---------------

The views layer can be used by itself, without any dataflow. In this mode, the
Vlerq code becomes very similar to Metakit: a set of operators on views.

This has been used to implement a basic Vlerq binding for Python. It does not
know about lazy evaluation or dataflow, it just interfaces to view operators.

Views are sequences of columns.  Views with zero columns are allowed, in which 
case they can only have a non-negative size.  To represent such views, a fake
column is used since it is the column which provides a row count.

Columns are used by views, but they can be shared by more than one view.
Operators such as `cremap` do nothing but shuffle columns around. As another
example, the `pair` operator takes the columns of two input views and constructs
a new view with all columns combined side-by-side. The sequences in these
columns are not copied - the same column gets used in both its original view and
the result. Reference counts on columns (on sequences, to be precise) make sure
that no bad things happen when the original view is no longer in use.

An **indirect view** is a view which uses one common sequence for all columns.
These are used for views which are based on other views, but which need to apply
some common processing for all accesses, i.e. regardless of which column. One
example of this is the `remap` operator, which applies a mapping to the row
before passing an access request on to an underlying view. In this case, a
special remapping sequence is used to pass-through all accesses. It has the map
and the reference to the parent view. The crucial point here is that the
incoming access column index is available and gets passed on after the row
number has been adjusted through the map.

All sequences, i.e. both for views and for columns, have a number of spare slots
which can be used depending on the type of view or column involved. This number
is currently set to 4, which seems sufficient to handle all cases. Each slot can
hold either an integer or a pointer. Again, it is up to the specific view or
column implementation to use these slots in whatever way they like.


The Dataflow layer
------------------

The dataflow layer is currently (early 2007) only being implemented for Tcl.
All dataflow objects are based on `Tcl_obj*` pointers (a.k.a. `Object_p`).

Dataflow is based on a simple "lazy instantiation" mechanism: an `Object_p`
initially contains a **description** of a view, as a Tcl list. This can be
either a materialized view, in the form of a `def` or a `data` view operator
with data provided in Tcl lists, or it is a view derived from other views, such
as joins, sorts, slices. In this case too, the `Object_p` contains a Tcl list,
naming the operator and all its operands - some of which may be views.

The instantiation aspect is brought in when a `View_p` is requested from the
`Object_p` using the `ObjAsView` C function.   Several things happen next:

  * the list is converted or the requested view operator is evaluated
  * the resulting `View_p` will be stored in `internalRep.twoPtrValue.ptr1`
  * the list is converted to a `Seq_p` before its internal rep is lost
  * that `Seq_p` will be stored in `internalRep.twoPtrValue.ptr2`
  * add this object as dependency to all arguments which are view objects
  * finish off by setting the Tcl `typePtr` of this object to "view"

After these steps, the `Object_p` will have transformed itself from a Tcl list
to a Tcl view object. An essential aspect for dataflow is that this object has
now also become _dependent_ on all the view objects it is based on.

Whenever a view changes (this complicated topic is treated separately below),
the logic is such that changes are always initiated from the dataflow layer.
What the change will do is to invalidate all dependent views, by asking each
dependent object to revert to its original Tcl list representation. As a result,
this removes all dependencies and will recursively trigger invalidation of all
_their_ dependencies as well.

The next time a `View_p` is needed, the whole process repeats itself: i.e.
reconstruct the view, and add all dependencies back in again.


Mutable views
-------------

All changes to views are handled by special "mutable views". On the outside,
these look like the original view with all changes applied, but internally
mutable views track all changes as _differences_ w.r.t. the original.

Mutable views come into existence when one of two modifying view operators is
applied to a view. The two operators are `set` and `replace` - with `insert`,
`append`, and `delete` built on top as special cases of `replace`.

When a modification is made to a non-mutable view, a new empty mutable view is
created, pointing to the original view but with no changes yet. Once mutable,
the requested operation is applied to it. All further modifications will be
accumulated in that same mutable view.

**MORE INFO TO BE ADDED LATER**


Building and testing
--------------------

Vlerq needs to run in many different configurations. The darcs repository is
only intended for use on my own personal machine, although several targets in
the top-level `Makefile` will probably work elsewhere. Out of the box, `make`
and `make test` will build and run a test suite on Linux, respectively.

By setting a special `ARCHSUFFIX` environment variable appropriately, this same
makefile should also work as is on two other systems:

  * `export ARCHSUFFIX=.macosx` - build on Mac OS X (ppc or intel)
  * `export ARCHSUFFIX=.win32` - build on Windows using Mingw and MSYS

For general use, the idea is to _generate_ a more conventional portable project.
For example: for Tcl, `make tea` will generate a single C source file
which ends up as `generic/vlerq.c` inside a standard TEA3-based Tcl extension,
called "vqtcl". This generated source code ends up in a public CVS repository
which can be accessed as follows:

    cvs -d :pserver:anonymous@equi4.com:/home/cvs co -d vqtcl vlerq/tcl

The reason for these paths and naming choices is to support more languages, each
with their own different source tree and build conventions. Early versions exist
for Ruby, Python, and Objective-C, using make targets `ruby`, `python`, and
`objc`, respectively.

Version numbers are used in a very specific way: the development version is
always built with a _fixed_ version number of "4". True releases will always
have a fractional part in the version number. This is "4.0" as of early Dec
2006, it will probably progress as both "4.0.1" and so on for bug fixes, and as
"4.1", "4.1.1", ... for functionality changes & additions. That way, development
builds do not constantly change versions, while sources and binaries which are
likely to end up all over the place will be properly tagged. This translates
directly to: sources in darcs have one fixed version number, whereas sources in
cvs have properly tracked version number changes.
vqcore/src/0000755000076500007650000000000010637226473012560 5ustar  jcwjcw00000000000000vqcore/src/bits.c0000644000076500007650000001321510614456523013663 0ustar  jcwjcw00000000000000/*
 * bits.c - Implementation of bitwise operations.
 */

#include 
#include 

#include "intern.h"

int TestBit (Seq_p bitmap, int row) {
    if (bitmap != NULL && row < bitmap->count) {
        const Byte_t *bits = bitmap->data[0].p;
        return (bits[row>>3] >> (row&7)) & 1;
    }
    return 0;
}

int SetBit (Seq_p *pbitmap, int row) {
    Byte_t *bits;
    Seq_p bitmap = *pbitmap;
    
    if (bitmap == NULL)
        *pbitmap = bitmap = IncRefCount(NewBitVec(row+1));

    if (TestBit(bitmap, row))
        return 0;
    
    if (row >= bitmap->count) {
        int bytes = bitmap->data[1].i;
        if (row >= 8 * bytes) {
            Seq_p newbitmap = IncRefCount(NewBitVec(12 * bytes));
            memcpy(newbitmap->data[0].p, LoseRef(bitmap)->data[0].p, bytes);
            *pbitmap = bitmap = newbitmap;
        }
        bitmap->count = row + 1;
    }

    bits = bitmap->data[0].p;
    bits[row>>3] |= 1 << (row&7);
    
    return 8 * bitmap->data[1].i;
}

void ClearBit (Seq_p bitmap, int row) {
    if (TestBit(bitmap, row)) {
        Byte_t *bits = bitmap->data[0].p;
        bits[row>>3] &= ~ (1 << (row&7));
    }
}

void SetBitRange (Seq_p bits, int from, int count) {
    while (--count >= 0)
        SetBit(&bits, from++);
}

Seq_p MinBitCount (Seq_p *pbitmap, int count) {
    if (*pbitmap == NULL || (*pbitmap)->count < count) {
        SetBit(pbitmap, count);
        ClearBit(*pbitmap, count);
        --(*pbitmap)->count;
    }
    return *pbitmap;
}

int NextBits (Seq_p bits, int *fromp, int *countp) {
    int curr = *fromp + *countp;
    
    while (curr < bits->count && !TestBit(bits, curr))
        ++curr;
        
    *fromp = curr;
    
    while (curr < bits->count && TestBit(bits, curr))
        ++curr;
        
    *countp = curr - *fromp;
    return *countp;
}

int TopBit (int v) {
#define Vn(x) (v < (1<> 3);
    int bit = 8 - (*ppos & 7);
    int top = TopBit(val), n = top + 1;
    
    Assert(val > 0);
    
    while (top >= bit) {
        ++curr;
        top -= bit;
        bit = 8;
    }
    
    bit -= top;
    
    while (n >= bit) {
        *curr++ |= (char) (val >> (n-bit));
        val &= (1 << (n-bit)) - 1;
        n -= bit;
        bit = 8;
    }
    
    *curr |= (char) (val << (bit - n));
    *ppos = ((curr - bytes) << 3) + (8 - bit) + n;
}

char *Bits2elias (const char *bytes, int count, int *outbits) {
    int i, last, bits = 0;
    char *out;
    
    if (count <= 0) {
        *outbits = 0;
        return NULL;
    }
    
    out = calloc(1, (count+count/2)/8+1);
    last = *bytes & 1;
    *out = last << 7;
    *outbits = 1;
    for (i = 0; i < count; ++i) {
        if (((bytes[i>>3] >> (i&7)) & 1) == last)
            ++bits;
        else {
            EmitBits(out, bits, outbits);
            bits = 1;
            last ^= 1;
        }
    }

    if (bits)
        EmitBits(out, bits, outbits);
    
    return out;
}

int NextElias (const char *bytes, int count, int *inbits) {
    int val = 0;
    const char *in;
    
    if (*inbits == 0)
        *inbits = 1;
    
    in = bytes + (*inbits >> 3);
    if (in < bytes + count) {
        int i = 0, bit = 8 - (*inbits & 7);
        
        for (;;) {
            ++i;
            if (*in & (1 << (bit-1)))
                break;
            if (--bit <= 0) {
                if (++in >= bytes + count)
                    return 0;
                bit = 8;
            }
        }
        
        while (i >= bit) {
            val <<= bit;
            val |= (*in++ & ((1 << bit) - 1));
            i -= bit;
            bit = 8;
        }
        
        val <<= i;
        val |= (*in >> (bit - i)) & ((1 << i) - 1);
        *inbits = ((in - bytes) << 3) + (8 - bit) + i;
    }
    
    return val;
}

int CountBits (Seq_p seq) {
    int result = 0, from = 0, count = 0;

    if (seq != NULL)
        while (NextBits(seq, &from, &count))
            result += count;

    return result;
}

ItemTypes BitRunsCmd_i (Item_p a) {
    int i, outsize, count = a->c.seq->count, pos = 0;
    char *data;
    struct Buffer buffer;
    Seq_p temp;

    temp = NewBitVec(count);
    
    for (i = 0; i < count; ++i) {
        if (GetColItem(i, a->c, IT_int).i)
            SetBit(&temp, i);
    }

    data = Bits2elias(temp->data[0].p, count, &outsize);

    count = (outsize + 7) / 8;
    InitBuffer(&buffer);
    
    if (count > 0) {
        ADD_INT_TO_BUF(buffer, (*data & 0x80) != 0);
        while ((i = NextElias(data, count, &pos)) != 0)
            ADD_INT_TO_BUF(buffer, i);
    }
    
    free(data);
    
    a->c = SeqAsCol(BufferAsIntVec(&buffer));
    return IT_column;
}
vqcore/src/buffer.c0000644000076500007650000000605010611154237014164 0ustar  jcwjcw00000000000000/*
 * buffer.c - Implementation of a simple temporary buffer.
 */

#include 
#include 

#include "intern.h"

typedef struct Overflow {
    char                b[4096];    /* must be first member */
    Overflow_p  next;
} Overflow;

void InitBuffer (Buffer_p bp) {
    bp->fill.c = bp->buf;
    bp->limit = bp->buf + sizeof bp->buf;
    bp->head = 0;
    bp->ofill = 0;
    bp->saved = 0;
    bp->result = 0;
}

void ReleaseBuffer (Buffer_p bp, int keep) {
    while (bp->head != 0) {
        Overflow_p op = bp->head;
        bp->head = op->next;
        free(op);
    }
    if (!keep && bp->result != 0)
        free(bp->result);
}

void AddToBuffer (Buffer_p bp, const void *data, Int_t len) {
    Int_t n;
    while (len > 0) {
        if (bp->fill.c >= bp->limit) {
            if (bp->head == 0 || 
                    bp->ofill >= bp->head->b + sizeof bp->head->b) {
                Overflow_p op = (Overflow_p) malloc(sizeof(Overflow));
                op->next = bp->head;
                bp->head = op;
                bp->ofill = op->b;
            }
            memcpy(bp->ofill, bp->buf, sizeof bp->buf);
            bp->ofill += sizeof bp->buf;
            bp->saved += sizeof bp->buf;
            n = bp->fill.c - bp->slack;
            memcpy(bp->buf, bp->slack, n);
            bp->fill.c = bp->buf + n;
        }
        n = len;
        if (n > bp->limit - bp->fill.c)
            n = bp->limit - bp->fill.c; /* TODO: copy big chunks to overflow */
        memcpy(bp->fill.c, data, n);
        bp->fill.c += n;
        data = (const char*) data + n;
        len -= n;
    }
}

int NextBuffer (Buffer_p bp, char **firstp, int *countp) {
    int count;
    
    if (*firstp == NULL) {
        Overflow_p p = bp->head, q = NULL;
        while (p != NULL) {
            Overflow_p t = p->next;
            p->next = q;
            q = p;
            p = t;
        }
        
        bp->head = q;
        bp->used = 0;
    } else if (*firstp == bp->head->b) {
        bp->head = bp->head->next;
        bp->used += *countp;
        free(*firstp);
    } else if (*firstp == bp->buf)
        return *countp == 0;
    
    if (bp->head != NULL) {
        *firstp = bp->head->b;
        count = bp->saved - bp->used;
        if (count > sizeof bp->head->b)
            count = sizeof bp->head->b;
    } else {
        count = bp->fill.c - bp->buf;
        *firstp = bp->buf;
    }
    
    *countp = count;
    return *countp;
}

void *BufferAsPtr (Buffer_p bp, int fast) {
    Int_t len;
    char *data, *ptr = NULL;
    int cnt;

    if (fast && bp->saved == 0)
        return bp->buf;

    len = BufferFill(bp);
    if (bp->result == 0)
        bp->result = malloc(len);
        
    for (data = bp->result; NextBuffer(bp, &ptr, &cnt); data += cnt)
        memcpy(data, ptr, cnt);

    return bp->result;
}

Seq_p BufferAsIntVec (Buffer_p bp) {
    int cnt;
    char *data, *ptr = NULL;
    Seq_p seq;
    
    seq = NewIntVec(BufferFill(bp) / sizeof(int), (void*) &data);

    for (; NextBuffer(bp, &ptr, &cnt); data += cnt)
        memcpy(data, ptr, cnt);

    return seq;
}
vqcore/src/column.c0000644000076500007650000003163210634025061014211 0ustar  jcwjcw00000000000000/*
 * column.c - Implementation of sequences, columns, and items.
 */

#include 
#include 
#include 

#include "intern.h"
#include "wrap_gen.h"

ItemTypes DebugCmd_I (Item_p a) {
	Shared_p sh = GetShared();
	a->i = sh->debug ^= a[0].i;
	return IT_int;
}

void *AdjustSeqRefs (void *refs, int count) {
	/*if (count > 0)*/
	if (refs != NULL) {
		Seq_p ptr = refs;
		ptr->refs += count;
		if (ptr->refs <= 0) {
			if (ptr->type != NULL) {
				int i, f;
				
				if (ptr->type->cleaner != NULL)
					ptr->type->cleaner(ptr);

				for (i = 0, f = ptr->type->cleanups; f > 0; ++i, f >>= 3)
					if (f & 1)
						DecRefCount(ptr->data[i].p);
					else if (f & 2)
						free(ptr->data[i].p);
			}
			free(refs);
			refs = NULL;
		}
	}
	return refs;
}

Seq_p LoseRef (Seq_p seq) {
	ADD_PTR_TO_BUF(*GetShared()->keeps, seq);
	return seq;
}

Column SeqAsCol (Seq_p seq) {
	Column result;
	result.seq = seq;
	result.pos = -1;
	return result;
}

Seq_p NewSequenceNoRef (int count, SeqType_p type, int bytes) {
	Seq_p seq;
	
	seq = calloc(1, sizeof(struct Sequence) + bytes);
	seq->count = count;
	seq->type = type;
	seq->getter = type->getfun;

	/* default for data[0].p is to point to the aux bytes after the sequence */
	/* default for data[1].i is to contain number of extra bytes allocated */
	seq->data[0].p = seq + 1;
	seq->data[1].i = bytes;
	
	/* make sure 64-bit values have a "natural" 8-byte alignment */
	Assert(((Int_t) seq->data[0].p) % 8 == 0);

	return seq;
}

Seq_p NewSequence (int count, SeqType_p type, int bytes) {
	return KeepRef(NewSequenceNoRef(count, type, bytes));
}

void ReleaseSequences (Buffer_p keep) {
	int cnt;
	char *ptr = NULL;
	
	while (NextBuffer(keep, &ptr, &cnt)) {
		Seq_p *refs = (Seq_p*) ptr;
		int count = cnt / sizeof(Seq_p);

		while (--count >= 0)
			DecRefCount(refs[count]);
	}
}

/* TODO: not used yet, should review refcount scenarios, might be wrong now */
Seq_p ResizeSeq (Seq_p seq, int pos, int diff, int elemsize) {
	int newcnt, olimit, nlimit = 0, bytes;
	Seq_p result = seq;
	
	Assert(seq->refs == 1);
	
	newcnt = seq->count + diff;
	bytes = seq->data[1].i;
	olimit = bytes / elemsize;
	
	if (diff > 0) { /* grow when limit is reached */
		if (newcnt > olimit) {
			nlimit = (olimit / 2) * 3 + 4;
			if (nlimit < newcnt)
				nlimit = newcnt + 4;
		}
	} else { /* shrink when less than half full */
		if (newcnt < olimit / 2) {
			nlimit = newcnt + 2;
			bytes = seq->count * elemsize;
		}
	}

	if (nlimit > 0) {
		result = IncRefCount(NewSequence(seq->count, seq->type,
		                                                nlimit * elemsize));
		result->getter = seq->getter;
		result->data[2] = seq->data[2];
		result->data[3] = seq->data[3];
		memcpy(result+1, seq+1, pos * elemsize);

		seq->type = NULL; /* release and prevent from calling cleaner */
		/*LoseRef(seq);*/
	}

	if (diff > 0) {
		memmove((char*) (result+1) + (pos + diff) * elemsize,
						(char*) (seq+1) + pos * elemsize,
						(seq->count - pos) * elemsize);
		memset((char*) (result+1) + pos * elemsize, 0, diff * elemsize);
	} else
		memmove((char*) (result+1) + pos * elemsize,
						(char*) (seq+1) + (pos - diff) * elemsize,
						(seq->count - (pos - diff)) * elemsize);
	
	result->count += diff;
	return result;
}

ItemTypes ResizeColCmd_iII (Item_p a) {
	int r, *data;
	Seq_p seq, result;
	
	seq = a[0].c.seq;
	result = NewIntVec(seq->count, &data);
	for (r = 0; r < seq->count; ++r)
		data[r] = GetSeqItem(r, seq, IT_int).i;
		
	a->c.seq = ResizeSeq(result, a[1].i, a[2].i, sizeof(int));
	return IT_column;
}

Seq_p NewBitVec (int count) {
	return NewSequence(count, PickIntGetter(1), (count + 7) / 8);
}

Seq_p NewIntVec (int count, int **dataptr) {
	const int w = sizeof(int);
	Seq_p seq = NewSequence(count, PickIntGetter(8 * w), w * count);
	if (dataptr != NULL)
		*dataptr = seq->data[0].p;
	return seq;
}

Seq_p NewPtrVec (int count, Int_t **dataptr) {
	const int w = sizeof(Int_t);
	Seq_p result = NewSequence(count, PickIntGetter(8 * w), w * count);
	if (dataptr != NULL)
		*dataptr = result->data[0].p;
	return result;
}

ItemTypes GetItem (int row, Item_p item) {
	Seq_p seq = item->c.seq;
	
	if (row < 0 || row >= seq->count) {
		item->e = EC_rioor;
		return IT_error;
	}
		
	return seq->getter(row, item);
}

Item GetColItem (int row, Column column, ItemTypes type) {
	Item item;
	ItemTypes got;
	
	item.c = column;
	got = GetItem(row, &item);
	Assert(got == type);
	return item;
}

Item GetSeqItem (int row, Seq_p seq, ItemTypes type) {
	Item item;
	ItemTypes got;
	
	item.c.seq = seq;
	item.c.pos = -1;
	got = GetItem(row, &item);
	Assert(got == type);
	return item;
}

Item GetViewItem (View_p view, int row, int col, ItemTypes type) {
	Item item;
	ItemTypes got;
	
	item.c = ViewCol(view, col);
	got = GetItem(row, &item);
	Assert(got == type);
	return item;
}

#if 0 /* unused */
const char *ItemTypeAsString (ItemTypes type) {
	static const char *typeTable[] = {
		"",	 /* IT_unknown */
		"I", /* IT_int */
		"L", /* IT_wide */
		"D", /* IT_double */
		"S", /* IT_string */
		"O", /* IT_object */
		"C", /* IT_column */
		"V", /* IT_view */
		"E", /* IT_error */
	};

	return typeTable[type];
}
#endif

ItemTypes CharAsItemType (char type) {
	switch (type) {
		case 0:		return IT_unknown;
		case 'I': return IT_int;
		case 'L': return IT_wide;
		case 'F': return IT_float;
		case 'D': return IT_double;
		case 'S': return IT_string;
		case 'B': return IT_bytes;
		case 'O': return IT_object;
		case 'C': return IT_column;
		case 'V': return IT_view;
	}
	return IT_error;
}

static ItemTypes StringGetter (int row, Item_p item) {
	char **ptrs = (char**) item->c.seq->data[0].p;
	item->s = ptrs[row];
	return IT_string;
}

static struct SeqType ST_String = { "string", StringGetter, 0102 };

static ItemTypes BytesGetter (int row, Item_p item) {
	char **ptrs = (char**) item->c.seq->data[0].p;
	item->u.ptr = (const Byte_t*) ptrs[row];
	item->u.len = ptrs[row+1] - ptrs[row];
	return IT_bytes;
}

static struct SeqType ST_Bytes = { "string", BytesGetter, 0102 };

Seq_p NewStrVec (int istext) {
	Seq_p seq;
	Buffer_p bufs;

	bufs = malloc(2 * sizeof(struct Buffer));
	InitBuffer(bufs);
	InitBuffer(bufs+1);

	seq = NewSequence(0, istext ? &ST_String : &ST_Bytes, 0);
	/* data[0] starts as two buffers, then becomes vector of string pointers */
	/* data[1] is not used */
	/* data[2] is an optional pointer to hash map sequence, see StringLookup */
	seq->data[0].p = bufs;
	
	return seq;
}

void AppendToStrVec (const void *string, int bytes, Seq_p seq) {
	Buffer_p bufs = seq->data[0].p;

	if (bytes < 0)
		bytes = strlen((const char*) string) + 1;
	
	/* TODO: consider tracking pointers i.s.o. making actual copies here */
	AddToBuffer(bufs, string, bytes);
	ADD_INT_TO_BUF(bufs[1], bytes);
	
	++seq->count;
}

Seq_p FinishStrVec (Seq_p seq) {
	int r = 0, cnt = 0, *iptr = NULL;
	char *fill, **ptrs, *cptr = NULL;
	Buffer_p bufs = seq->data[0].p;

	ptrs = malloc((seq->count+1) * sizeof(char*) + BufferFill(bufs));

	fill = (char*) (ptrs + seq->count + 1);
	while (NextBuffer(bufs+1, (void*) &iptr, &cnt)) {
		int i, n = cnt / sizeof(int);
		for (i = 0; i < n; ++i) {
			ptrs[r++] = fill;
			fill += iptr[i];
		}
	}
	ptrs[r] = fill; /* past-end mark needed to provide length of last entry */

	fill = (char*) (ptrs + seq->count + 1);
	while (NextBuffer(bufs, &cptr, &cnt)) {
		memcpy(fill, cptr, cnt);
		fill += cnt;
	}
	
	ReleaseBuffer(bufs, 0);
	ReleaseBuffer(bufs+1, 0);
	free(seq->data[0].p);
	
	seq->data[0].p = ptrs;
	return seq;
}

Column ForceStringColumn (Column column) {
	int r, rows;
	Seq_p result;
	
	/* this code needed to always make name column of meta views string cols */
	
	if (column.seq == NULL || column.seq->getter == StringGetter)
		return column;
		
	rows = column.seq->count;
	result = NewStrVec(1);
	
	for (r = 0; r < rows; ++r)
		AppendToStrVec(GetColItem(r, column, IT_string).s, -1, result);
	
	return SeqAsCol(FinishStrVec(result));
}

static ItemTypes IotaGetter (int row, Item_p item) {
	item->i = row;
	return IT_int;
}

static struct SeqType ST_Iota = { "iota", IotaGetter };

Column NewIotaColumn (int count) {
	return SeqAsCol(NewSequence(count, &ST_Iota, 0));
}

static void SequenceCleaner (Seq_p seq) {
	int i;
	View_p *items = seq->data[0].p;

	for (i = 0; i < seq->count; ++i)
		DecRefCount(items[i]);
}

static ItemTypes SequenceGetter (int row, Item_p item) {
	void **items = (void**) item->c.seq->data[0].p;
	ItemTypes type = item->c.seq->data[1].i;

	switch (type) {

		case IT_view:
			item->v = items[row];
			return IT_view;

		case IT_column:
			item->c.seq = items[row];
			item->c.pos = -1;
			return IT_column;

		default:
			return IT_unknown;
	}
}

static struct SeqType ST_Sequence = {
	"sequence", SequenceGetter, 0, SequenceCleaner
};

Seq_p NewSeqVec (ItemTypes type, const Seq_p *items, int count) {
	int i, bytes;
	Seq_p seq;

	bytes = count * sizeof(View_p);
	seq = NewSequence(count, &ST_Sequence, bytes);
	/* data[0] points to a list of pointers */
	/* data[1] is the type of the returned items */
	seq->data[1].i = type;

	if (items != NULL) {
		memcpy(seq->data[0].p, items, bytes);
		for (i = 0; i < count; ++i)
			IncRefCount(items[i]);
	}

	return seq;
}

static ItemTypes CountsGetter (int row, Item_p item) {
	const View_p *items = (const View_p*) item->c.seq->data[0].p;

	item->i = ViewSize(items[row]);
	return IT_int;
}

Column NewCountsColumn (Column column) {
	int r, rows;
	View_p *items;
	Seq_p seq;
	
	rows = column.seq->count;	 
	seq = NewSeqVec(IT_view, NULL, rows);
	seq->getter = CountsGetter;

	items = seq->data[0].p;
	for (r = 0; r < rows; ++r)
		items[r] = IncRefCount(GetColItem(r, column, IT_view).v);

	return SeqAsCol(seq);
}

Column OmitColumn (Column omit, int size) {
	int i, *data, j = 0, outsize;
	Seq_p seq, map;
	
	if (omit.seq == NULL)
		return omit;
		
	outsize = size - omit.seq->count;
	
	/* FIXME: wasteful for large views, consider sorting input col instead */
	map = NewBitVec(size);
	for (i = 0; i < omit.seq->count; ++i)
		SetBit(&map, GetColItem(i, omit, IT_int).i);

	seq = NewIntVec(outsize, &data);
	
	for (i = 0; i < size; ++i)
		if (!TestBit(map, i)) {
			Assert(j < outsize);
			data[j++] = i;
		}
		
	return SeqAsCol(seq);
}

#if 0
static ItemTypes UnknownGetter (int row, Item_p item) {
	return IT_unknown;
}

static struct SeqType ST_Unknown = { "unknown", UnknownGetter };

static Seq_p NewUnknownVec (int count) {
	return NewSequence(count, &ST_Unknown, 0);
}
#endif

Column CoerceColumn (ItemTypes type, Object_p obj) {
	int i, n;
	void *data;
	Seq_p seq;
	Item item;
	Column out, column = ObjAsColumn(obj);

	if (column.seq == NULL)
		return column;
		
	/* determine the input column type by fetching one item */
	item.c = column;
	n = column.seq->count;

	if (GetItem(0, &item) == type)
		return column;
		
	switch (type) {
		case IT_int:	seq = NewIntVec(n, (void*) &data); break;
		case IT_wide:	seq = NewSequence(n, PickIntGetter(64), 8 * n); break;
		case IT_float:	seq = NewSequence(n, FixedGetter(4,1,1,0), 4 * n);
		                break;
		case IT_double: seq = NewSequence(n, FixedGetter(8,1,1,0), 8 * n);
		                break;
		case IT_string: seq = NewStrVec(1); break;
		case IT_bytes:	seq = NewStrVec(0); break;
		case IT_view:	seq = NewSeqVec(IT_view, NULL, n); break;
		default:		Assert(0);
	}

	out = SeqAsCol(seq);
	data = out.seq->data[0].p;

	for (i = 0; i < n; ++i) {
		item.o = GetColItem(i, column, IT_object).o;
		if (!ObjToItem(type, &item)) {
			out.seq = NULL;
			out.pos = i;
			break;
		}
	
		switch (type) {
			case IT_int:	((int*) data)[i] = item.i; break;
			case IT_wide:	((int64_t*) data)[i] = item.w; break;
			case IT_float:	((float*) data)[i] = item.f; break;
			case IT_double: ((double*) data)[i] = item.d; break;
			case IT_string: AppendToStrVec(item.s, -1, out.seq); break;
			case IT_bytes:	AppendToStrVec(item.u.ptr, item.u.len, out.seq);
			                break;
			case IT_view:	((Seq_p*) data)[i] = IncRefCount(item.v); break;
			default:		Assert(0);
		}
	}

	if (type == IT_string || type == IT_bytes)
		FinishStrVec(seq);

	return out;
}

Column CoerceCmd (Object_p obj, const char *str) {
	return CoerceColumn(CharAsItemType(str[0]), obj);
}

int CastObjToItem (char type, Item_p item) {
	switch (type) {

		case 'M':
			item->o = NeedMutable(item->o);
			return (void*) item->o != NULL;
			
		case 'N':
			item->i = ColumnByName(V_Meta(item[-1].v), item->o);
			return item->i >= 0;
		
		case 'n': {
			int *data, r, rows;
			View_p meta;
			Column column;
			Seq_p seq;

			column = ObjAsColumn(item->o);
			if (column.seq == NULL)
				return 0;
				
			rows = column.seq->count;
			seq = NewIntVec(rows, &data);
			meta = V_Meta(item[-1].v);
			
			for (r = 0; r < rows; ++r) {
				/* FIXME: this only works if input is a list, not a column! */
				data[r] = ColumnByName(meta, GetColItem(r, column,
				                                            IT_object).o);
				if (data[r] < 0)
					return 0;
			}
			
			item->c = SeqAsCol(seq);
			break;
		}
		
		default:
			if (type < 'a' || type > 'z')
				return ObjToItem(CharAsItemType(type), item);

			item->c = CoerceColumn(CharAsItemType(type +'A'-'a'), item->o);
			break;
	}

	return 1; /* cast succeeded */
}
vqcore/src/emit.c0000644000076500007650000003573710611154237013667 0ustar  jcwjcw00000000000000/*
 * emit.c - Implementation of file output commands.
 */

#include 
#include 
#include 

#include "intern.h"
#include "wrap_gen.h"

typedef enum EmitTypes {
    ET_mem
} EmitTypes;

typedef struct EmitItem {
    EmitTypes type;
    Int_t size;
    const void *data;
} EmitItem, *EmitItem_p;

typedef struct EmitInfo {
    int64_t         position;   /* emit offset, track >2 Gb even on 32b arch */
    struct Buffer  *itembuf;    /* item buffer */
    struct Buffer  *colbuf;     /* column buffer */
    int             diff;       /* true if emitting differences */
} EmitInfo, *EmitInfo_p;

static void EmitView (EmitInfo_p eip, View_p view, int describe); /* forward */

static Int_t EmitBlock (EmitInfo_p eip, const void* data, int size) {
    EmitItem item;
    Int_t pos = eip->position;

    if (size > 0) {
        item.type = ET_mem;
        item.size = size;
        item.data = data;
        AddToBuffer(eip->itembuf, &item, sizeof item);

        eip->position += size;
    } else
        free((void*) data);
    
    return pos;
}

static void *EmitCopy (EmitInfo_p eip, const void* data, int size) {
    void *buf = NULL;
    if (size > 0) {
        buf = memcpy(malloc(size), data, size);
        EmitBlock(eip, buf, size);
    }
    return buf;
}

static Int_t EmitBuffer (EmitInfo_p eip, Buffer_p buf) {
    Int_t pos = EmitBlock(eip, BufferAsPtr(buf, 0), BufferFill(buf));
    ReleaseBuffer(buf, 1);
    return pos;
}

static void EmitAlign (EmitInfo_p eip) {
    if (eip->position >= 1024 * 1024)
        EmitCopy(eip, "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0", 15 & - eip->position);
}

void MetaAsDesc (View_p meta, Buffer_p buffer) {
    int r, rows = ViewSize(meta);
    Column names, types, subvs;
    char type;
    const char *name;
    View_p subv;

    names = ViewCol(meta, MC_name);
    types = ViewCol(meta, MC_type);
    subvs = ViewCol(meta, MC_subv);

    for (r = 0; r < rows; ++r) {
        if (r > 0)
            AddToBuffer(buffer, ",", 1);

        name = GetColItem(r, names, IT_string).s;
        type = *GetColItem(r, types, IT_string).s;
        subv = GetColItem(r, subvs, IT_view).v;

        AddToBuffer(buffer, name, strlen(name));
        if (type == 'V' && ViewSize(subv) > 0) {
            AddToBuffer(buffer, "[", 1);
            MetaAsDesc(subv, buffer);
            AddToBuffer(buffer, "]", 1);
        } else {
            AddToBuffer(buffer, ":", 1);
            AddToBuffer(buffer, &type, 1);
        }
    }
}

static void EmitVarInt (EmitInfo_p eip, Int_t value) {
    int n;

#if 0
    if (value < 0) {
        ADD_ONEC_TO_BUF(*eip->colbuf, 0);
        value = ~value;
    }
#endif

    Assert(value >= 0);
    for (n = 7; (value >> n) > 0; n += 7)
        ;
    while ((n -= 7) > 0)
        ADD_ONEC_TO_BUF(*eip->colbuf, (value >> n) & 0x7F);
    ADD_CHAR_TO_BUF(*eip->colbuf, (value & 0x7F) | 0x80);
}

static void EmitPair (EmitInfo_p eip, Int_t offset) {
    Int_t size;

    size = eip->position - offset;
    EmitVarInt(eip, size);
    if (size > 0)
        EmitVarInt(eip, offset);
}

static int MinWidth (int lo, int hi) {
    lo = lo > 0 ? 0 : "444444445555555566666666666666666"[TopBit(~lo)+1] & 7;
    hi = hi < 0 ? 0 : "012334445555555566666666666666666"[TopBit(hi)+1] & 7;
    return lo > hi ? lo : hi;
}

static int *PackedIntVec (const int *data, int rows, Int_t *outsize) {
    int r, width, lo = 0, hi = 0, bits, *result;
    const int *limit;
    Int_t bytes;

    for (r = 0; r < rows; ++r) {
        if (data[r] < lo) lo = data[r];
        if (data[r] > hi) hi = data[r];
    }

    width = MinWidth(lo, hi);

    if (width >= 6) {
        bytes = rows * (1 << (width-4));
        result = malloc(bytes);
        memcpy(result, data, bytes);
    } else if (rows > 0 && width > 0) {
        if (rows < 5 && width < 4) {
            static char fudges[3][4] = {    /* n:    1:  2:  3:  4: */
                {1,1,1,1},          /* 1-bit entries:    1b  2b  3b  4b */
                {1,1,1,1},          /* 2-bit entries:    2b  4b  6b  8b */
                {1,1,2,2},          /* 4-bit entries:    4b  8b 12b 16b */
            };
            static char widths[3][4] = {    /* n:    1:  2:  3:  4: */
                {3,3,2,2},          /* 1-bit entries:    4b  4b  2b  2b */
                {3,3,2,2},          /* 2-bit entries:    4b  4b  2b  2b */
                {3,3,3,3},          /* 4-bit entries:    4b  4b  4b  4b */
            };
            bytes = fudges[width-1][rows-1];
            width = widths[width-1][rows-1];
        } else
            bytes = (((Int_t) rows << width) + 14) >> 4; /* round up */
            
        result = malloc(bytes);
        if (width < 4)
            memset(result, 0, bytes);

        limit = data + rows;
        bits = 0;

        switch (width) {

            case 1: { /* 1 bit, 8 per byte */
                char* q = (char*) result;
                while (data < limit) {
                    *q |= (*data++ & 1) << bits; ++bits; q += bits >> 3; 
                    bits &= 7;
                }
                break;
            }

            case 2: { /* 2 bits, 4 per byte */
                char* q = (char*) result;
                while (data < limit) {
                    *q |= (*data++ & 3) << bits; bits += 2; q += bits >> 3; 
                    bits &= 7;
                }
                break;
            }

            case 3: { /* 4 bits, 2 per byte */
                char* q = (char*) result;
                while (data < limit) {
                    *q |= (*data++ & 15) << bits; bits += 4; q += bits >> 3;
                    bits &= 7;
                }
                break;
            }

            case 4: { /* 1-byte (char) */
                char* q = (char*) result;
                while (data < limit)
                    *q++ = (char) *data++;
                break;
            }

            case 5: { /* 2-byte (short) */
                short* q = (short*) result;
                while (data < limit)
                    *q++ = (short) *data++;
                break;
            }
        }
    } else {
        bytes = 0;
        result = NULL;
    }

    *outsize = bytes;
    return result;
}

static int EmitFixCol (EmitInfo_p eip, Column column, ItemTypes type) {
    int r, rows, *tempvec;
    void *buffer;
    Int_t bufsize;

    rows = column.seq->count;

    switch (type) {

        case IT_int:
            bufsize = rows * sizeof(int);
            tempvec = malloc(bufsize);
            for (r = 0; r < rows; ++r)
                tempvec[r] = GetColItem(r, column, type).i;
            buffer = PackedIntVec(tempvec, rows, &bufsize);
            free((char*) tempvec); /* TODO: avoid extra copy & malloc */
            
            /* try to compress the bitmap, but only in diff save mode */
            if (eip->diff && rows >= 128 && rows == bufsize * 8) {
                int ebits;

                tempvec = (void*) Bits2elias(buffer, rows, &ebits);

                /* only keep compressed form if under 80% of plain bitmap */
                if (ebits + ebits/4 < rows) {
                    free(buffer);
                    buffer = tempvec;
                    bufsize = (ebits + 7) / 8;
                } else
                    free((char*) tempvec);
            }
            
            break;

        case IT_wide:
            bufsize = rows * sizeof(int64_t);
            buffer = malloc(bufsize);
            for (r = 0; r < rows; ++r)
                ((int64_t*) buffer)[r] = GetColItem(r, column, type).w;
            break;

        case IT_float:
            bufsize = rows * sizeof(float);
            buffer = malloc(bufsize);
            for (r = 0; r < rows; ++r)
                ((float*) buffer)[r] = GetColItem(r, column, type).f;
            break;

        case IT_double:
            bufsize = rows * sizeof(double);
            buffer = malloc(bufsize);
            for (r = 0; r < rows; ++r)
                ((double*) buffer)[r] = GetColItem(r, column, type).d;
            break;

        default: Assert(0); return 0;
    }

    /* start using 16-byte alignment once the emitted data reaches 1 Mb */
    /* only do this for vectors >= 128 bytes, worst-case waste is under 10% */
    
    Assert(!(bufsize > 0 && rows == 0));
    if (bufsize >= 128 && bufsize / rows >= 2) 
        EmitAlign(eip);
        
    EmitPair(eip, EmitBlock(eip, buffer, bufsize));
    
    return bufsize != 0;
}

static void EmitVarCol (EmitInfo_p eip, Column column, int istext) {
    int r, rows, bytes, *sizevec;
    Int_t buflen;
    Item item;
    struct Buffer buffer;
    Seq_p sizes;

    InitBuffer(&buffer);
    rows = column.seq->count;
    sizes = NewIntVec(rows, &sizevec);

    if (istext)
        for (r = 0; r < rows; ++r) {
            item = GetColItem(r, column, IT_string);
            bytes = strlen(item.s);
            if (bytes > 0)
                AddToBuffer(&buffer, item.s, ++bytes);
            sizevec[r] = bytes;
        }
    else
        for (r = 0; r < rows; ++r) {
            item = GetColItem(r, column, IT_bytes);
            AddToBuffer(&buffer, item.u.ptr, item.u.len);
            sizevec[r] = item.u.len;
        }

    buflen = BufferFill(&buffer);
    EmitPair(eip, EmitBuffer(eip, &buffer));    
    if (buflen > 0)
        EmitFixCol(eip, SeqAsCol(sizes), 1);

    EmitVarInt(eip, 0); /* no memos */
}

static void EmitSubCol (EmitInfo_p eip, Column column, int describe) {
    int r, rows;
    View_p view;
    struct Buffer newcolbuf;
    Buffer_p origcolbuf;

    origcolbuf = eip->colbuf;
    eip->colbuf = &newcolbuf;
    InitBuffer(eip->colbuf);

    rows = column.seq->count;

    for (r = 0; r < rows; ++r) {
        view = GetColItem(r, column, IT_view).v;
        EmitView(eip, view, describe);
    }

    eip->colbuf = origcolbuf;

    EmitPair(eip, EmitBuffer(eip, &newcolbuf));  
}

static void EmitCols (EmitInfo_p eip, View_p view, View_p maps) {
    int rows = ViewSize(view);
    
    EmitVarInt(eip, rows);

    if (rows > 0) {
        int i, r, c, *rowptr = NULL;
        ItemTypes type;
        Column column;
        Seq_p rowmap;
        View_p v, subv, meta = V_Meta(view);

        rowmap = NULL;
        
        for (c = 0; c < ViewWidth(view); ++c) {          
            if (maps != NULL) {
                Column mapcol = ViewCol(maps, c);
                if (!EmitFixCol(eip, mapcol, IT_int))
                    continue;

                if (rowmap == NULL)
                    rowmap = NewIntVec(rows, &rowptr);

                i = 0;
                for (r = 0; r < rows; ++r)
                    if (GetColItem(r, mapcol, IT_int).i)
                        rowptr[i++] = r;
                        
                rowmap->count = i;
                        
                v = RemapSubview(view, SeqAsCol(rowmap), 0, -1);
            } else
                v = view;
                
            column = ViewCol(v,c);
            type = ViewColType(view, c);
            switch (type) {
                
                case IT_int:
                case IT_wide:
                case IT_float:
                case IT_double:
                    EmitFixCol(eip, column, type); 
                    break;
                    
                case IT_string:
                    EmitVarCol(eip, column, 1);
                    break;
                    
                case IT_bytes:
                    EmitVarCol(eip, column, 0);
                    break;
                    
                case IT_view:
                    subv = GetViewItem(meta, c, MC_subv, IT_view).v;
                    EmitSubCol(eip, column, ViewSize(subv) == 0);
                    break;
                    
                default: Assert(0);
            }
        }
    }
}

static void EmitView (EmitInfo_p eip, View_p view, int describe) {
    EmitVarInt(eip, 0);

    if (eip->diff) {
        Seq_p mods = MutPrepare(view), *seqs = (void*) (mods + 1);

        EmitVarInt(eip, 0);
        EmitFixCol(eip, SeqAsCol(seqs[MP_delmap]), IT_int);

        if (EmitFixCol(eip, SeqAsCol(seqs[MP_adjmap]), IT_int))
            EmitCols(eip, seqs[MP_adjdat], seqs[MP_usemap]);

        EmitCols(eip, seqs[MP_insdat], NULL);
        if (ViewSize(seqs[MP_insdat]) > 0)
            EmitFixCol(eip, SeqAsCol(seqs[MP_insmap]), IT_int);
    } else {
        if (describe) {
            int cnt;
            char *ptr = NULL;
            struct Buffer desc;

            InitBuffer(&desc);
            MetaAsDesc(V_Meta(view), &desc);

            EmitVarInt(eip, BufferFill(&desc));
            
            while (NextBuffer(&desc, &ptr, &cnt))
                AddToBuffer(eip->colbuf, ptr, cnt);
        }

        EmitCols(eip, view, NULL);
    }
}

static void SetBigEndian32 (char* dest, Int_t value) {
    dest[0] = (char) (value >> 24);
    dest[1] = (char) (value >> 16);
    dest[2] = (char) (value >> 8);
    dest[3] = (char) value;
}

static Int_t EmitComplete (EmitInfo_p eip, View_p view) {
    int overflow;
    Int_t rootpos, tailpos, endpos;
    char tail[16];
    struct Head { short a; char b; char c; char d[4]; } head, *fixup;
    struct Buffer newcolbuf;

    if (eip->diff && !IsMutable(view))
        return 0;
        
    eip->position = 0;

    head.a = 'J' + ('L' << 8);
    head.b = 0x1A;
    head.c = 0;
    fixup = EmitCopy(eip, &head, sizeof head);

    eip->colbuf = &newcolbuf;
    InitBuffer(eip->colbuf);

    EmitView(eip, view, 1);

    EmitAlign(eip);
    rootpos = EmitBuffer(eip, eip->colbuf);  
    eip->colbuf = NULL;

    EmitAlign(eip);
    
    if (eip->position != (Int_t) eip->position)
        return -1; /* fail if >= 2 Gb on machines with a 32-bit address space */
    
    /* large files will have bit 8 of head[3] and bit 8 of tail[12] set */
    tailpos = eip->position;
    endpos = tailpos + sizeof tail;
    overflow = endpos >> 31;

    /* for file sizes > 2 Gb, store bits 41..31 in tail[2..3] */
    SetBigEndian32(tail, 0x80000000 + overflow);
    SetBigEndian32(tail+4, tailpos);
    SetBigEndian32(tail+8, 
                    ((eip->diff ? 0x90 : 0x80) << 24) + tailpos - rootpos);
    SetBigEndian32(tail+12, rootpos);
    if (overflow)
        tail[12] |= 0x80;
    
    EmitCopy(eip, tail, sizeof tail);
    
    if (overflow) {
        /* store bits 41..36 in head[3], and bits 35..4 in head[4..7] */
        Assert((endpos & 15) == 0);
        fixup->c = 0x80 | ((endpos >> 16) >> 20);
        SetBigEndian32(fixup->d, endpos >> 4);
    } else
        SetBigEndian32(fixup->d, endpos);
        
    return endpos;
}

Int_t ViewSave (View_p view, void *aux, SaveInitFun initfun, SaveDataFun datafun, int diff) {
    int i, numitems;
    Int_t bytes;
    struct Buffer buffer;
    EmitItem_p items;
    EmitInfo einfo;
    
    InitBuffer(&buffer);
    
    einfo.itembuf = &buffer;
    einfo.diff = diff;

    bytes = EmitComplete(&einfo, view);

    numitems = BufferFill(&buffer) / sizeof(EmitItem);
    items = BufferAsPtr(&buffer, 1);

    if (initfun != NULL)
        aux = initfun(aux, bytes);

    for (i = 0; i < numitems; ++i) {
        if (aux != NULL)
            aux = datafun(aux, items[i].data, items[i].size);
        free((void*) items[i].data);
    }
    
    if (aux == NULL)
        bytes = 0;
    
    ReleaseBuffer(&buffer, 0);
    return bytes;
}
vqcore/src/file.c0000644000076500007650000003776410637226473013664 0ustar  jcwjcw00000000000000/*
 * file.c - Implementation of memory-mapped file access.
 */

#include 
#include 
#include 

#ifdef WIN32
#define WIN32_LEAN_AND_MEAN
#include 
#else
#include 
#include 
#include 
#endif

#include "intern.h"
#include "wrap_gen.h"

static View_p MapSubview (MappedFile_p, Int_t, View_p, View_p); /* forward */

#define MF_Data(map) ((const char*) ((map)->data[0].p))
#define MF_Length(map) ((Int_t) (map)->data[1].p)

static void MappedCleaner (MappedFile_p map) {
    Cleaner fun = *((Cleaner*) (map + 1));
    if (fun != NULL)
        fun(map);
}

static struct SeqType ST_Mapped = { "mapped", NULL, 0, MappedCleaner };

MappedFile_p InitMappedFile (const char *data, Int_t length, Cleaner fun) {
    MappedFile_p map;
    
    map = NewSequence(0, &ST_Mapped, sizeof(Cleaner));
    /* data[0] points to the current start of the mapped area */
    /* data[1] is the current length of the mapped area */
    /* data[2] points to the original mapped area */
    /* data[3] is available for storing an Object_p, see ext_tcl.c */
    map->data[0].p = (void*) data;
    map->data[1].p = (void*) length;
    map->data[2].p = (void*) data;
    
    *((Cleaner*) (map + 1)) = fun; /* TODO: get rid of this ugly hack */
    
    return map;
}

static void MappedFileCleaner (MappedFile_p map) {
#if WIN32+0
    UnmapViewOfFile(map->data[2].p);
#else
    int offset = MF_Data(map) - (const char*) map->data[2].p;
    munmap(map->data[2].p, MF_Length(map) + offset);
#endif
}

static MappedFile_p OpenMappedFile (const char *filename) {
    const char *data = NULL;
    Int_t length = -1;
        
#if WIN32+0
    {
        DWORD n;
        HANDLE h, f = CreateFile(filename, GENERIC_READ, FILE_SHARE_READ, 0,
                                    OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);
        if (f != INVALID_HANDLE_VALUE) {
            h = CreateFileMapping(f, 0, PAGE_READONLY, 0, 0, 0);
            if (h != INVALID_HANDLE_VALUE) {
                n = GetFileSize(f, 0);
                data = MapViewOfFile(h, FILE_MAP_READ, 0, 0, n);
                if (data != NULL)
                    length = n;
                CloseHandle(h);
            }
            CloseHandle(f);
        }
    }
#else
    {
        struct stat sb;
        int fd = open(filename, O_RDONLY);
        if (fd != -1) {
            if (fstat(fd, &sb) == 0) {
                data = mmap(0, sb.st_size, PROT_READ, MAP_SHARED, fd, 0);
                if (data != MAP_FAILED)
                    length = sb.st_size;
            }
            close(fd);
        }
    }
#endif

    if (length < 0)
        return NULL;
        
    return InitMappedFile(data, length, MappedFileCleaner);
}

static void AdjustMappedFile (MappedFile_p map, int offset) {
    map->data[0].p = (void*) (MF_Data(map) + offset);
    map->data[1].p = (void*) (MF_Length(map) - offset);
}

static int IsReversedEndian(MappedFile_p map) {
#if _BIG_ENDIAN+0
    return *MF_Data(map) == 'J';
#else
    return *MF_Data(map) == 'L';
#endif
}

static Int_t GetVarInt (const char **cp) {
    int8_t b;
    Int_t v = 0;
    do {
        b = *(*cp)++;
        v = (v << 7) + b;
    } while (b >= 0);
    return v + 128;
}

static Int_t GetVarPair(const char** cp) {
    Int_t n = GetVarInt(cp);
    if (n > 0 && GetVarInt(cp) == 0)
        *cp += n;
    return n;
}

#define MM_cache        data[0].p
#define MM_offvec       data[1].q
#define MM_mapf         data[2].q
#define MM_meta         data[3].q

#define MM_offsets  MM_offvec->data[0].p
#define MM_base         MM_offvec->data[1].q


static void MappedViewCleaner (Seq_p seq) {
    int i, count;
    const View_p *subviews = seq->MM_cache;
    
    count = seq->MM_offvec->count;
    for (i = 0; i < count; ++i)
        DecRefCount(subviews[i]);
    
    DecRefCount(seq->MM_base);
}

static ItemTypes MappedViewGetter (int row, Item_p item) {
    Seq_p seq = item->c.seq;
    View_p *subviews = seq->MM_cache;
    
    if (subviews[row] == NULL) {
        Seq_p base = seq->MM_base;
        const Int_t *offsets = seq->MM_offsets;
        
        if (base != NULL)
            base = GetViewItem(base, row, item->c.pos, IT_view).v;
        
        subviews[row] = IncRefCount(MapSubview(seq->MM_mapf, offsets[row],
                                                        seq->MM_meta, base));
    }
    
    item->v = subviews[row];
    return IT_view;
}

static struct SeqType ST_MappedView = {
    "mappedview", MappedViewGetter, 01110, MappedViewCleaner
};

static Seq_p MappedViewCol (MappedFile_p map, int rows, const char **nextp, View_p meta, View_p base) {
    int r, c, cols, subcols;
    Int_t colsize, colpos, *offsets;
    const char *next;
    Seq_p offseq, result;
    
    offseq = NewPtrVec(rows, &offsets);
    
    cols = ViewSize(meta);
    
    colsize = GetVarInt(nextp);
    colpos = colsize > 0 ? GetVarInt(nextp) : 0;
    next = MF_Data(map) + colpos;
    
    for (r = 0; r < rows; ++r) {
        offsets[r] = next - MF_Data(map);
        GetVarInt(&next);
        if (cols == 0) {
            Int_t desclen = GetVarInt(&next);
            const char *desc = next;
            next += desclen;
            meta = DescAsMeta(&desc, next);
        }
        if (GetVarInt(&next) > 0) {
            subcols = ViewSize(meta);
            for (c = 0; c < subcols; ++c)
                switch (GetColType(meta, c)) {
                    case 'B': case 'S': if (GetVarPair(&next))
                                            GetVarPair(&next);
                                        /* fall through */
                    default:            GetVarPair(&next);
                }
        }
    }
    
    result = NewSequence(rows, &ST_MappedView, rows * sizeof(View_p));
    /* data[0] points to a subview cache */
    /* data[1] points to a sequence owning the offest vector */
    /* data[2] points to the mapped file */
    /* data[3] points to the meta view */
    result->MM_offvec = IncRefCount(offseq);
    result->MM_mapf = IncRefCount(map);
    result->MM_meta = IncRefCount(cols > 0 ? meta : EmptyMetaView());
    /* offseq->data[1] points to the base view if there is one */
    result->MM_base = IncRefCount(base);
    
    /* TODO: could combine subview cache and offsets vector */
    
    return result;
}

static struct SeqType ST_MappedFix = { "mappedfix", NULL, 010 };

static Seq_p MappedFixedCol (MappedFile_p map, int rows, const char **nextp, int isreal) {
    Int_t colsize, colpos;
    const char *data;
    Seq_p result;

    colsize = GetVarInt(nextp);
    colpos = colsize > 0 ? GetVarInt(nextp) : 0;
    data = MF_Data(map) + colpos;
    
    /* if bit count is too low-for single-bit vectors then it's compressed */
    if (rows >= 128 && 0 < colsize && colsize < rows/8) {
        int from, pos = 0;
        
        result = NewBitVec(rows);
        from = *data & 0x80 ? 0 : NextElias(data, colsize, &pos);
            
        for (;;) {
            int count = NextElias(data, colsize, &pos);
            if (count == 0)
                break;
            SetBitRange(result, from, count);
            from += count + NextElias(data, colsize, &pos);
        }
    } else {    
        int rev = IsReversedEndian(map);
    
        result = NewSequence(rows, &ST_MappedFix, 0);
        result->getter = FixedGetter(colsize, rows, isreal, rev)->getfun;
        /* data[0] points to the mapped data */
        /* data[1] points to the mapped file */
        result->data[0].p = (void*) data;
        result->data[1].p = IncRefCount(map);
    }
    
    return result;
}

#define MS_offvec       data[0].q
#define MS_offptr       data[1].p
#define MS_mapf         data[2].q
#define MS_sizes        data[3].q

static ItemTypes MappedStringGetter (int row, Item_p item) {
    const Int_t *offsets = item->c.seq->MS_offptr;
    const char *data = MF_Data(item->c.seq->MS_mapf);

    if (offsets[row] == 0)
        item->s = "";
    else if (offsets[row] > 0)
        item->s = data + offsets[row];
    else {
        const char *next = data - offsets[row];
        if (GetVarInt(&next) > 0)
            item->s = data + GetVarInt(&next);
        else
            item->s = "";
    }

    return IT_string;
}

static struct SeqType ST_MappedString = {
    "mappedstring", MappedStringGetter, 01101
};

static ItemTypes MappedBytesGetter (int row, Item_p item) {
    Seq_p seq = item->c.seq;
    const Int_t *offsets = seq->MS_offptr;
    const char *data = MF_Data(seq->MS_mapf);
    
    item->u.len = GetSeqItem(row, seq->MS_sizes, IT_int).i;
    
    if (offsets[row] >= 0)
        item->u.ptr = (const Byte_t*) data + offsets[row];
    else {
        const char *next = data - offsets[row];
        item->u.len = GetVarInt(&next);
        item->u.ptr = (const Byte_t*) data + GetVarInt(&next);
    }

    return IT_bytes;
}

static struct SeqType ST_MappedBytes = {
    "mappedstring", MappedBytesGetter, 01101
};

static Seq_p MappedStringCol (MappedFile_p map, int rows, const char **nextp, int istext) {
    int r, len, memopos;
    Int_t colsize, colpos, *offsets;
    const char *next, *limit;
    Seq_p offseq, result, sizes;

    offseq = NewPtrVec(rows, &offsets);

    colsize = GetVarInt(nextp);
    colpos = colsize > 0 ? GetVarInt(nextp) : 0;

    if (colsize > 0) {
        sizes = MappedFixedCol(map, rows, nextp, 0);
        for (r = 0; r < rows; ++r) {
            len = GetSeqItem(r, sizes, IT_int).i;
            if (len > 0) {
                offsets[r] = colpos;
                colpos += len;
            }
        }
    } else
        sizes = NewSequence(rows, FixedGetter(0, rows, 0, 0), 0);

    colsize = GetVarInt(nextp);
    memopos = colsize > 0 ? GetVarInt(nextp) : 0;
    next = MF_Data(map) + memopos;
    limit = next + colsize;
    
    /* negated offsets point to the size/pos pair in the map */
    for (r = 0; next < limit; ++r) {
        r += (int) GetVarInt(&next);
        offsets[r] = MF_Data(map) - next; /* always < 0 */
        GetVarPair(&next);
    }

    result = NewSequence(rows, istext ? &ST_MappedString : &ST_MappedBytes, 0);
    /* data[0] points to a sequence owning the offset vector */
    /* data[1] points to that vector of subview offsets */
    /* data[2] points to the mapped file */
    /* data[3] points to sizes seq if binary or is null if zero-terminated */
    result->MS_offvec = IncRefCount(offseq);
    result->MS_offptr = offsets;
    result->MS_mapf = IncRefCount(map);
    result->MS_sizes = istext ? NULL : IncRefCount(sizes);

    return result;
}

static Seq_p MappedBits (MappedFile_p map, int rows, const char **nextp) {
    Seq_p seq;
    
    if ((**nextp & 0xFF) == 0x80) {
        ++*nextp;
        return NULL; /* zero-sized column */
    }
        
    seq = MappedFixedCol(map, rows, nextp, 0);

    /* if this does not use 1-bit encoding, then we need to convert back */
    if (rows < 8 && seq->getter != PickIntGetter(1)->getfun) {
        int i;
        Seq_p result = NULL;

        for (i = 0; i < rows; ++i)
            if (GetSeqItem(i, seq, IT_int).i)
                SetBit(&result, i);
                
        return result;
    }
    
    return seq;
}

static View_p MapCols (MappedFile_p map, const char **nextp, View_p meta, View_p base, Seq_p adjseq) {
    int i, c, r, rows, *rowptr = NULL;
    View_p result, subview;
    Seq_p seq, usedmap = NULL, rowmap;
    Item item;
    
    rows = (int) GetVarInt(nextp);
    
    if (ViewSize(meta) == 0)
        return NoColumnView(rows);
    
    if (base != NULL) {
        int pos = 0, from = 0, count = 0;
        
        rowmap = NewIntVec(rows, &rowptr);
        while (NextBits(adjseq, &from, &count))
            for (i = 0; i < count; ++i)
                rowptr[pos++] = from + i;
                
        result = base;
    } else
        result = NewView(meta);
    
    if (rows > 0)
        for (c = 0; c < ViewWidth(result); ++c) {
            if (base != NULL) {
                usedmap = MappedBits(map, rows, nextp);
                r = CountBits(usedmap);
            } else
                r = rows;
                
            switch (ViewColType(result, c)) {
                
                case IT_int:
                case IT_wide:
                    seq = MappedFixedCol(map, r, nextp, 0); 
                    break;

                case IT_float:
                case IT_double:
                    seq = MappedFixedCol(map, r, nextp, 1);
                    break;
                    
                case IT_string:
                    seq = MappedStringCol(map, r, nextp, 1); 
                    break;
                    
                case IT_bytes:
                    seq = MappedStringCol(map, r, nextp, 0);
                    break;
                    
                case IT_view:
                    subview = GetViewItem(meta, c, MC_subv, IT_view).v;
                    seq = MappedViewCol(map, r, nextp, subview, base); 
                    break;
                    
                default:
                    Assert(0);
                    return result;
            }
            
            if (base != NULL) {
                i = 0;
                for (r = 0; r < usedmap->count; ++r)
                    if (TestBit(usedmap, r)) {
                        item.c.seq = seq;
                        item.c.pos = -1;
                        GetItem(i++, &item);
                        result = ViewSet(result, rowptr[r], c, &item);
                    }
                Assert(i == seq->count);
            } else
                SetViewSeqs(result, c, 1, seq);
        }

    return result;
}

static View_p MapSubview (MappedFile_p map, Int_t offset, View_p meta, View_p base) {
    const char *next;
    
    next = MF_Data(map) + offset;
    GetVarInt(&next);
    
    if (base != NULL) {
        int inscnt;
        View_p insview;
        Seq_p delseq, insseq, adjseq;
        
        meta = V_Meta(base);
        
        GetVarInt(&next); /* structure changes and defaults, NOTYET */

        delseq = MappedBits(map, ViewSize(base), &next);
        if (delseq != NULL) {
            int delcnt = 0, from = 0, count = 0;
            while (NextBits(delseq, &from, &count)) {
                base = ViewReplace(base, from - delcnt, count, NULL);
                delcnt += count;
            }
        }
            
        adjseq = MappedBits(map, ViewSize(base), &next);
        if (adjseq != NULL)
            base = MapCols(map, &next, meta, base, adjseq);

        insview = MapCols(map, &next, meta, NULL, NULL);
        inscnt = ViewSize(insview);
        if (inscnt > 0) {
            int shift = 0, from = 0, count = 0;
            insseq = MappedBits(map, ViewSize(base) + inscnt, &next);
            while (NextBits(insseq, &from, &count)) {
                View_p newdata = StepView(insview, count, shift, 1, 1);
                base = ViewReplace(base, from, 0, newdata);
                shift += count;
            }
        }
    
        return base;
    }
    
    if (ViewSize(meta) == 0) {
        Int_t desclen = GetVarInt(&next);
        const char *desc = next;
        next += desclen;
        meta = DescAsMeta(&desc, next);
    }

    return MapCols(map, &next, meta, NULL, NULL);
}

static int BigEndianInt32 (const char *p) {
    const Byte_t *up = (const Byte_t*) p;
    return (p[0] << 24) | (up[1] << 16) | (up[2] << 8) | up[3];
}

View_p MappedToView (MappedFile_p map, View_p base) {
    int i, t[4];
    Int_t datalen, rootoff;
    
    if (MF_Length(map) <= 24 || *(MF_Data(map) + MF_Length(map) - 16) != '\x80')
        return NULL;
        
    for (i = 0; i < 4; ++i)
        t[i] = BigEndianInt32(MF_Data(map) + MF_Length(map) - 16 + i * 4);
        
    datalen = t[1] + 16;
    rootoff = t[3];

    if (rootoff < 0) {
        const Int_t mask = 0x7FFFFFFF; 
        datalen = (datalen & mask) + ((Int_t) ((t[0] & 0x7FF) << 16) << 15);
        rootoff = (rootoff & mask) + (datalen & ~mask);
        /* FIXME: rollover at 2 Gb, prob needs: if (rootoff > datalen) ... */
    }
    
    AdjustMappedFile(map, MF_Length(map) - datalen);
    return MapSubview(map, rootoff, EmptyMetaView(), base);
}

View_p OpenDataFile (const char *filename) {
    MappedFile_p map;
    
    map = OpenMappedFile(filename);
    if (map == NULL)
        return NULL;
        
    return MappedToView(map, NULL);
}
vqcore/src/getters.c0000644000076500007650000001325510637226473014407 0ustar  jcwjcw00000000000000/*
 * getters.c - Implementation of several simple getter functions.
 */

#include 

#include "intern.h"

static ItemTypes Getter_i0 (int row, Item_p item) {
    item->i = 0;
    return IT_int;
}

static ItemTypes Getter_i1 (int row, Item_p item) {
    const char *ptr = item->c.seq->data[0].p;
    item->i = (ptr[row>>3] >> (row&7)) & 1;
    return IT_int;
}

static ItemTypes Getter_i2 (int row, Item_p item) {
    const char *ptr = item->c.seq->data[0].p;
    item->i = (ptr[row>>2] >> 2*(row&3)) & 3;
    return IT_int;
}

static ItemTypes Getter_i4 (int row, Item_p item) {
    const char *ptr = item->c.seq->data[0].p;
    item->i = (ptr[row>>1] >> 4*(row&1)) & 15;
    return IT_int;
}

static ItemTypes Getter_i8 (int row, Item_p item) {
    const char *ptr = item->c.seq->data[0].p;
    item->i = (int8_t) ptr[row];
    return IT_int;
}

#if VALUES_MUST_BE_ALIGNED+0

static ItemTypes Getter_i16 (int row, Item_p item) {
    const Byte_t *ptr = (const Byte_t*) item->c.seq->data[0].p + row * 2;
#if _BIG_ENDIAN+0
    item->i = (((int8_t) ptr[0]) << 8) | ptr[1];
#else
    item->i = (((int8_t) ptr[1]) << 8) | ptr[0];
#endif
    return IT_int;
}

static ItemTypes Getter_i32 (int row, Item_p item) {
    const char *ptr = (const char*) item->c.seq->data[0].p + row * 4;
    int i;
    for (i = 0; i < 4; ++i)
        item->b[i] = ptr[i];
    return IT_int;
}

static ItemTypes Getter_i64 (int row, Item_p item) {
    const char *ptr = (const char*) item->c.seq->data[0].p + row * 8;
    int i;
    for (i = 0; i < 8; ++i)
        item->b[i] = ptr[i];
    return IT_wide;
}

static ItemTypes Getter_f32 (int row, Item_p item) {
    Getter_i32(row, item);
    return IT_float;
}

static ItemTypes Getter_f64 (int row, Item_p item) {
    Getter_i64(row, item);
    return IT_double;
}

#else

static ItemTypes Getter_i16 (int row, Item_p item) {
    const char *ptr = item->c.seq->data[0].p;
    item->i = ((short*) ptr)[row];
    return IT_int;
}

static ItemTypes Getter_i32 (int row, Item_p item) {
    const char *ptr = item->c.seq->data[0].p;
    item->i = ((const int*) ptr)[row];
    return IT_int;
}

static ItemTypes Getter_i64 (int row, Item_p item) {
    const char *ptr = item->c.seq->data[0].p;
    item->w = ((const int64_t*) ptr)[row];
    return IT_wide;
}

static ItemTypes Getter_f32 (int row, Item_p item) {
    const char *ptr = item->c.seq->data[0].p;
    item->f = ((const float*) ptr)[row];
    return IT_float;
}

static ItemTypes Getter_f64 (int row, Item_p item) {
    const char *ptr = item->c.seq->data[0].p;
    item->d = ((const double*) ptr)[row];
    return IT_double;
}

#endif

static ItemTypes Getter_i16r (int row, Item_p item) {
    const Byte_t *ptr = (const Byte_t*) item->c.seq->data[0].p + row * 2;
#if _BIG_ENDIAN+0
    item->i = (((int8_t) ptr[1]) << 8) | ptr[0];
#else
    item->i = (((int8_t) ptr[0]) << 8) | ptr[1];
#endif
    return IT_int;
}

static ItemTypes Getter_i32r (int row, Item_p item) {
    const char *ptr = (const char*) item->c.seq->data[0].p + row * 4;
    int i;
    for (i = 0; i < 4; ++i)
        item->b[i] = ptr[3-i];
    return IT_int;
}

static ItemTypes Getter_i64r (int row, Item_p item) {
    const char *ptr = (const char*) item->c.seq->data[0].p + row * 8;
    int i;
    for (i = 0; i < 8; ++i)
        item->b[i] = ptr[7-i];
    return IT_wide;
}

static ItemTypes Getter_f32r (int row, Item_p item) {
    Getter_i32r(row, item);
    return IT_float;
}

static ItemTypes Getter_f64r (int row, Item_p item) {
    Getter_i64r(row, item);
    return IT_double;
}

static struct SeqType ST_Get_i0   = { "get_i0"  , Getter_i0   };
static struct SeqType ST_Get_i1   = { "get_i1"  , Getter_i1   };
static struct SeqType ST_Get_i2   = { "get_i2"  , Getter_i2   };
static struct SeqType ST_Get_i4   = { "get_i4"  , Getter_i4   };
static struct SeqType ST_Get_i8   = { "get_i8"  , Getter_i8   };
static struct SeqType ST_Get_i16  = { "get_i16" , Getter_i16  };
static struct SeqType ST_Get_i32  = { "get_i32" , Getter_i32  };
static struct SeqType ST_Get_i64  = { "get_i64" , Getter_i64  };
static struct SeqType ST_Get_i16r = { "get_i16r", Getter_i16r };
static struct SeqType ST_Get_i32r = { "get_i32r", Getter_i32r };
static struct SeqType ST_Get_i64r = { "get_i64r", Getter_i64r };
static struct SeqType ST_Get_f32  = { "get_f32" , Getter_f32  };
static struct SeqType ST_Get_f64  = { "get_f64" , Getter_f64  };
static struct SeqType ST_Get_f32r = { "get_f32r", Getter_f32r };
static struct SeqType ST_Get_f64r = { "get_f64r", Getter_f64r };

SeqType_p PickIntGetter (int bits) {
    switch (bits) {
        default:    Assert(0); /* fall through */
        case 0:     return &ST_Get_i0;
        case 1:     return &ST_Get_i1;
        case 2:     return &ST_Get_i2;
        case 4:     return &ST_Get_i4;
        case 8:     return &ST_Get_i8;
        case 16:    return &ST_Get_i16;
        case 32:    return &ST_Get_i32;
        case 64:    return &ST_Get_i64;
    }
}

SeqType_p FixedGetter (int bytes, int rows, int real, int flip) {
    int bits;

    static char widths[8][7] = {
        {0,-1,-1,-1,-1,-1,-1},
        {0, 8,16, 1,32, 2, 4},
        {0, 4, 8, 1,16, 2,-1},
        {0, 2, 4, 8, 1,-1,16},
        {0, 2, 4,-1, 8, 1,-1},
        {0, 1, 2, 4,-1, 8,-1},
        {0, 1, 2, 4,-1,-1, 8},
        {0, 1, 2,-1, 4,-1,-1},
    };

    bits = rows < 8 && bytes < 7 ? widths[rows][bytes] : (bytes << 3) / rows;

    switch (bits) {
        case 16:    return flip ? &ST_Get_i16r : &ST_Get_i16;
        case 32:    return real ? flip ? &ST_Get_f32r : &ST_Get_f32
                                : flip ? &ST_Get_i32r : &ST_Get_i32;
        case 64:    return real ? flip ? &ST_Get_f64r : &ST_Get_f64
                                : flip ? &ST_Get_i64r : &ST_Get_i64;
    }

    return PickIntGetter(bits);
}
vqcore/src/hash.c0000644000076500007650000004276410611155607013654 0ustar  jcwjcw00000000000000/*
 * hash.c - Implementation of hashing functions.
 */

#include 
#include 

#include "intern.h"
#include "wrap_gen.h"

typedef struct HashInfo *HashInfo_p;

typedef struct HashInfo {
    View_p  view;       /* input view */
    int     prime;      /* prime used for hashing */
    int     fill;       /* used to fill map */
    int    *map;        /* map of unique rows */
    Column  mapcol;     /* owner of map */
    int    *hvec;       /* hash probe vector */
    Column  veccol;     /* owner of hvec */
    int    *hashes;     /* hash values, one per view row */
    Column  hashcol;    /* owner of hashes */
} HashInfo;

static int StringHash (const char *s, int n) {
    /* similar to Python's stringobject.c */
    int i, h = (*s * 0xFF) << 7;
    if (n < 0)
        n = strlen(s);
    for (i = 0; i < n; ++i)
        h = (1000003 * h) ^ s[i];
    return h ^ i;
}

static Column HashCol (ItemTypes type, Column column) {
    int i, count, *data;
    Seq_p seq;
    Item item;

/* the following is not possible: the result may be xor-ed into!
    if (type == IT_int && column.seq->getter == PickIntGetter(32))
        return column;
*/

    count = column.seq->count;
    seq = NewIntVec(count, &data);

    switch (type) {
        
        case IT_int:
            for (i = 0; i < count; ++i)
                data[i] = GetColItem(i, column, IT_int).i;
            break;
                
        case IT_wide:
            for (i = 0; i < count; ++i) {
                item = GetColItem(i, column, IT_wide);
                data[i] = item.q[0] ^ item.q[1];
            }
            break;
                
        case IT_float:
            for (i = 0; i < count; ++i)
                data[i] = GetColItem(i, column, IT_float).i;
            break;
                
        case IT_double:
            for (i = 0; i < count; ++i) {
                item = GetColItem(i, column, IT_double);
                data[i] = item.q[0] ^ item.q[1];
            }
            break;
                
        case IT_string:
            for (i = 0; i < count; ++i) {
                item = GetColItem(i, column, IT_string);
                data[i] = StringHash(item.s, -1);
            }
            break;
                
        case IT_bytes:
            for (i = 0; i < count; ++i) {
                item = GetColItem(i, column, IT_bytes);
                data[i] = StringHash((const char*) item.u.ptr, item.u.len);
            }
            break;
                
        case IT_view:
            for (i = 0; i < count; ++i) {
                int j, hcount, hval = 0;
                const int *hvec;
                Column hashes;
                
                item = GetColItem(i, column, IT_view);
                hashes = HashValues(item.v);
                hvec = (const int*) hashes.seq->data[0].p;
                hcount = hashes.seq->count;
                
                for (j = 0; j < hcount; ++j)
                    hval ^= hvec[j];
                /* TODO: release hashes right now */
            
                data[i] = hval ^ hcount;
            }
            break;
                
        default: Assert(0);
    }

    return SeqAsCol(seq);
}

ItemTypes HashColCmd_SO (Item args[]) {
    ItemTypes type;
    Column column;
    
    type = CharAsItemType(args[0].s[0]);
    column = CoerceColumn(type, args[1].o);
    if (column.seq == NULL)
        return IT_unknown;
        
    args->c = HashCol(type, column);
    return IT_column;
}

int RowHash (View_p view, int row) {
    int c, hash = 0;
    Item item;

    for (c = 0; c < ViewWidth(view); ++c) {
        item.c = ViewCol(view, c);
        switch (GetItem(row, &item)) {

            case IT_int:
                hash ^= item.i;
                break;

            case IT_string:
                hash ^= StringHash(item.s, -1);
                break;

            case IT_bytes:
                hash ^= StringHash((const char*) item.u.ptr, item.u.len);
                break;

            default: {
                View_p rview = StepView(view, 1, row, 1, 1);
                Column rcol = HashValues(rview);
                hash = *(const int*) rcol.seq->data[0].p;
                break;
            }
        }
    }

    return hash;
}

static void XorWithIntCol (Column src, Column_p dest) {
    const int *srcdata = (const int*) src.seq->data[0].p;
    int i, count = src.seq->count, *destdata = (int*) dest->seq->data[0].p;

    for (i = 0; i < count; ++i)
        destdata[i] ^= srcdata[i];
}

Column HashValues (View_p view) {
    int c;
    Column result;

    if (ViewWidth(view) == 0 || ViewSize(view) == 0)
        return SeqAsCol(NewIntVec(ViewSize(view), NULL));
        
    result = HashCol(ViewColType(view, 0), ViewCol(view, 0));
    for (c = 1; c < ViewWidth(view); ++c) {
        Column auxcol = HashCol(ViewColType(view, c), ViewCol(view, c));
        /* TODO: get rid of the separate xor step by xoring in HashCol */
        XorWithIntCol(auxcol, &result);
    }
    return result;
}

static int HashFind (View_p keyview, int keyrow, int keyhash, HashInfo_p data) {
    int probe, datarow, mask, step;

    mask = data->veccol.seq->count - 1;
    probe = ~keyhash & mask;

    step = (keyhash ^ (keyhash >> 3)) & mask;
    if (step == 0)
        step = mask;

    for (;;) {
        probe = (probe + step) & mask;
        if (data->hvec[probe] == 0)
            break;

        datarow = data->map[data->hvec[probe]-1];
        if (keyhash == data->hashes[datarow] &&
                RowEqual(keyview, keyrow, data->view, datarow))
            return data->hvec[probe] - 1;

        step <<= 1;
        if (step > mask)
            step ^= data->prime;
    }

    if (keyview == data->view) {
        data->hvec[probe] = data->fill + 1;
        data->map[data->fill++] = keyrow;
    }

    return -1;
}

static int StringHashFind (const char *key, Seq_p hseq, Column values) {
    int probe, datarow, mask, step, keyhash;
    const int *hvec = (const int*) hseq->data[0].p;
    int prime = hseq->data[2].i;
    
    keyhash = StringHash(key, -1);
    mask = hseq->count - 1;
    probe = ~keyhash & mask;

    step = (keyhash ^ (keyhash >> 3)) & mask;
    if (step == 0)
        step = mask;

    for (;;) {
        probe = (probe + step) & mask;
        datarow = hvec[probe] - 1;
        if (datarow < 0)
            break;

        /* These string hashes are much simpler than the standard HashFind:
             no hashes vector, no indirect map, compute all hashes on-the-fly */
                
        if (strcmp(key, GetColItem(datarow, values, IT_string).s) == 0)
            return datarow;

        step <<= 1;
        if (step > mask)
            step ^= prime;
    }

    return ~probe;
}

static int Log2bits (int n) {
    int bits = 0;
    while ((1 << bits) < n)
        ++bits;
    return bits;
}

static Column HashVector (int rows) {
    int bits = Log2bits((4 * rows) / 3);
    if (bits < 2)
        bits = 2;
    return SeqAsCol(NewIntVec(1 << bits, NULL));
}

static void InitHashInfo (HashInfo_p info, View_p view, Column hmap, Column hvec, Column hashes) {
    int size = hvec.seq->count;

    static char slack [] = {
        0, 0, 3, 3, 3, 5, 3, 3, 29, 17, 9, 5, 83, 27, 43, 3,
        45, 9, 39, 39, 9, 5, 3, 33, 27, 9, 71, 39, 9, 5, 83, 0
    };

    info->view = view;
    info->prime = size + slack[Log2bits(size-1)];
    info->fill = 0;
    
    info->mapcol = hmap;
    info->map = (int*) hmap.seq->data[0].p;

    info->veccol = hvec;
    info->hvec = (int*) hvec.seq->data[0].p;

    info->hashcol = hashes;
    info->hashes = (int*) hashes.seq->data[0].p;
}

int StringLookup (const char *key, Column values) {
    int h, r, rows, *hptr;
    const char *string;
    Column hvec;
    HashInfo info;
    
    /* adjust data[2], this assumes values is a string column */
    
    if (values.seq->data[2].p == NULL) {
        rows = values.seq->count;
        hvec = HashVector(rows);
        hptr = (int*) hvec.seq->data[0].p;
        
        /* use InitHashInfo to get at the prime number, bit of a hack */
        InitHashInfo(&info, NULL, hvec, hvec, hvec);
        hvec.seq->data[2].i = info.prime;
        
        for (r = 0; r < rows; ++r) {
            string = GetColItem(r, values, IT_string).s;
            h = StringHashFind(string, hvec.seq, values);
            if (h < 0) /* silently ignore duplicates */
                hptr[~h] = r + 1;
        }
        
        values.seq->data[2].p = IncRefCount(hvec.seq);
    }
    
    h = StringHashFind(key, (Seq_p) values.seq->data[2].p, values);
    return h >= 0 ? h : -1;
}

static void FillHashInfo (HashInfo_p info, View_p view) {
    int r, rows;
    Column mapcol;
    
    rows = ViewSize(view);
    mapcol = SeqAsCol(NewIntVec(rows, NULL)); /* worst-case, dunno #groups */

    InitHashInfo(info, view, mapcol, HashVector(rows), HashValues(view));

    for (r = 0; r < rows; ++r)
        HashFind(view, r, info->hashes[r], info);

    /* TODO: reclaim unused entries at end of map */
    mapcol.seq->count = info->fill;
}

static void ChaseLinks (HashInfo_p info, int count, const int *hmap, const int *lmap) {
    int groups = info->fill, *smap = info->hvec, *gmap = info->hashes;
    
    while (--groups >= 0) {
        int head = hmap[groups] - 1;
        smap[groups] = count;
        while (head >= 0) {
            gmap[--count] = head;
            head = lmap[head];
        }
    }
    /* assert(count == 0); */
}

void FillGroupInfo (HashInfo_p info, View_p view) {
    int g, r, rows, *hmap, *lmap;
    Column mapcol, headmap, linkmap;
    
    rows = ViewSize(view);
    mapcol = SeqAsCol(NewIntVec(rows, NULL)); /* worst-case, dunno #groups */
    headmap = SeqAsCol(NewIntVec(rows, &hmap)); /* same: don't know #groups */
    linkmap = SeqAsCol(NewIntVec(rows, &lmap));

    InitHashInfo(info, view, mapcol, HashVector(rows), HashValues(view));

    for (r = 0; r < rows; ++r) {
        g = HashFind(view, r, info->hashes[r], info);
        if (g < 0)
            g = info->fill - 1;
        lmap[r] = hmap[g] - 1;
        hmap[g] = r + 1;
    }
    
    /* TODO: reclaim unused entries at end of map and hvec */
    info->mapcol.seq->count = info->veccol.seq->count = info->fill;
    
    ChaseLinks(info, rows, hmap, lmap);

    /* TODO: could release headmap and linkmap but that's a no-op here */
    
    /*  There's probably an opportunity to reduce space usage further,
        since the grouping map points to the starting row of each group:
            map[i] == gmap[smap[i]]
        Perhaps "map" (which starts out with #rows entries) can be re-used
        to append the gmap entries (if we can reduce it by #groups items).
        Or just release map[x] for grouping views, and use gmap[smap[x]].
    */
}

View_p GroupCol (View_p view, Column cols, const char *name) {
    View_p vkey, vres, gview;
    HashInfo info;
    
    vkey = ColMapView(view, cols);
    vres = ColMapView(view, OmitColumn(cols, ViewWidth(view)));

    FillGroupInfo(&info, vkey);
    gview = GroupedView(vres, info.veccol, info.hashcol, name);
    return PairView(RemapSubview(vkey, info.mapcol, 0, -1), gview);
}

static void FillJoinInfo (HashInfo_p info, View_p left, View_p right) {
    int g, r, gleft, nleft, nright, nused = 0, *hmap, *lmap, *jmap;
    Column mapcol, headmap, linkmap, joincol;
    
    nleft = ViewSize(left);
    mapcol = SeqAsCol(NewIntVec(nleft, NULL)); /* worst-case dunno #groups */
    joincol = SeqAsCol(NewIntVec(nleft, &jmap));
    
    InitHashInfo(info, left, mapcol, HashVector(nleft), HashValues(left));

    for (r = 0; r < nleft; ++r) {
        g = HashFind(left, r, info->hashes[r], info);
        if (g < 0)
            g = info->fill - 1;
        jmap[r] = g;
    }

    /* TODO: reclaim unused entries at end of map */
    mapcol.seq->count = info->fill;

    gleft = info->mapcol.seq->count;
    nleft = info->hashcol.seq->count;
    nright = ViewSize(right);
    
    headmap = SeqAsCol(NewIntVec(gleft, &hmap)); /* don't know #groups */
    linkmap = SeqAsCol(NewIntVec(nright, &lmap));

    for (r = 0; r < nright; ++r) {
        g = HashFind(right, r, RowHash(right, r), info);
        if (g >= 0) {
            lmap[r] = hmap[g] - 1;
            hmap[g] = r + 1;
            ++nused;
        }
    }

    /* we're reusing veccol, but it might not be large enough to start with */
    /* TODO: reclaim unused entries at end of hvec */
    if (info->veccol.seq->count < nused)
        info->veccol = SeqAsCol(NewIntVec(nused, &info->hvec));
    else 
        info->veccol.seq->count = nused;

    /* reorder output to match results from FillHashInfo and FillGroupInfo */
    info->hashcol = info->veccol;
    info->hashes = info->hvec;
    info->veccol = info->mapcol;
    info->hvec = info->map;
    info->mapcol = joincol;
    info->map = jmap;
    
    ChaseLinks(info, nused, hmap, lmap);
    
    /*  As with FillGroupInfo, this is most likely not quite optimal yet.
        All zero-length groups in smap (info->map, now info->hvec) could be 
        coalesced into one, and joinmap indices into it adjusted down a bit.
        Would reduce the size of smap when there are lots of failed matches.
        Also: FillJoinInfo needs quite a lot of temp vector space right now.
     */
}

Column IntersectMap (View_p keys, View_p view) {
    int r, rows;
    HashInfo info;
    struct Buffer buffer;
    
    if (!ViewCompat(keys, view)) 
        return SeqAsCol(NULL);
        
    FillHashInfo(&info, view);
    InitBuffer(&buffer);
    rows = ViewSize(keys);
    
    /* these ints are added in increasing order, could have used a bitmap */
    for (r = 0; r < rows; ++r)
        if (HashFind(keys, r, RowHash(keys, r), &info) >= 0)
            ADD_INT_TO_BUF(buffer, r);

    return SeqAsCol(BufferAsIntVec(&buffer));
}

/* ReverseIntersectMap returns RHS indices, instead of IntersectMap's LHS */
static Column ReverseIntersectMap (View_p keys, View_p view) {
    int r, rows;
    HashInfo info;
    struct Buffer buffer;
    
    FillHashInfo(&info, view);
    InitBuffer(&buffer);
    rows = ViewSize(keys);
    
    for (r = 0; r < rows; ++r) {
        int f = HashFind(keys, r, RowHash(keys, r), &info);
        if (f >= 0)
            ADD_INT_TO_BUF(buffer, f);
    }
    
    return SeqAsCol(BufferAsIntVec(&buffer));
}

View_p JoinView (View_p left, View_p right, const char *name) {
    View_p lmeta, rmeta, lkey, rkey, rres, gview;
    Column lmap, rmap;
    HashInfo info;
    
    lmeta = V_Meta(left);
    rmeta = V_Meta(right);
    
    lmap = IntersectMap(lmeta, rmeta);
    /* TODO: optimize, don't create the hash info twice */
    rmap = ReverseIntersectMap(lmeta, rmeta);

    lkey = ColMapView(left, lmap);
    rkey = ColMapView(right, rmap);
    rres = ColMapView(right, OmitColumn(rmap, ViewWidth(right)));

    FillJoinInfo(&info, lkey, rkey);
    gview = GroupedView(rres, info.veccol, info.hashcol, name);
    return PairView(left, RemapSubview(gview, info.mapcol, 0, -1));
}

Column UniqMap (View_p view) {
    HashInfo info;
    FillHashInfo(&info, view);
    return info.mapcol;
}

int HashDoFind (View_p view, int row, View_p w, Column a, Column b, Column c) {
    HashInfo info;
    /* TODO: avoid Log2bits call in InitHashInfo, since done on each find */
    InitHashInfo(&info, w, a, b, c);
    return HashFind(view, row, RowHash(view, row), &info);
}

Column GetHashInfo (View_p left, View_p right, int type) {
    HashInfo info;
    Seq_p seqvec[3];

    switch (type) {
        case 0:     FillHashInfo(&info, left); break;
        case 1:     FillGroupInfo(&info, left); break;
        default:    FillJoinInfo(&info, left, right); break;
    }
        
    seqvec[0] = info.mapcol.seq;
    seqvec[1] = info.veccol.seq;
    seqvec[2] = info.hashcol.seq;

    return SeqAsCol(NewSeqVec(IT_column, seqvec, 3));
}

View_p IjoinView (View_p left, View_p right) {
    View_p view = JoinView(left, right, "?");
    return UngroupView(view, ViewWidth(view)-1);
}

static struct SeqType ST_HashMap = { "hashmap", NULL, 02 };

Seq_p HashMapNew (void) {
    Seq_p result;
    
    result = NewSequence(0, &ST_HashMap, 0);
    /* data[0] is the key + value + hash vector */
    /* data[1] is the allocated count */
    result->data[0].p = NULL;
    result->data[1].i = 0;
    
    return result;
}

/* FIXME: dumb linear scan instead of hashing for now, for small tests only */

static int HashMapLocate(Seq_p hmap, int key, int *pos) {
    const int *data = hmap->data[0].p;
    
    for (*pos = 0; *pos < hmap->count; ++*pos)
        if (key == data[*pos])
            return 1;
        
    return 0;
}

int HashMapAdd (Seq_p hmap, int key, int value) {
    int pos, *data = hmap->data[0].p;
    int allocnt = hmap->data[1].i;

    if (HashMapLocate(hmap, key, &pos)) {
        data[pos+allocnt] = value;
        return 0;
    }

    Assert(pos == hmap->count);
    if (pos >= allocnt) {
        int newlen = (allocnt / 2) * 3 + 10;
        hmap->data[0].p = data = realloc(data, newlen * 2 * sizeof(int));
        memmove(data+newlen, data+allocnt, allocnt * sizeof(int));
        allocnt = hmap->data[1].i = newlen;
    }
    
    data[pos] = key;
    data[pos+allocnt] = value;
    ++hmap->count;
    return allocnt;
}

int HashMapLookup (Seq_p hmap, int key, int defval) {
    int pos;

    if (HashMapLocate(hmap, key, &pos)) {
        int allocnt = hmap->data[1].i;
        const int *data = hmap->data[0].p;
        return data[pos+allocnt];
    }
    
    return defval;
}

#if 0 /* not yet */
int HashMapRemove (Seq_p hmap, int key) {
    int pos;

    if (HashMapLocate(hmap, key, &pos)) {
        int last = --hmap->count;
        if (pos < last) {
            int allocnt = hmap->data[1].i, *data = hmap->data[0].p;
            data[pos] = data[last];
            data[pos+allocnt] = data[last+allocnt];
            return pos;
        }
    }
    
    return -1;
}
#endif
vqcore/src/indirect.c0000644000076500007650000002206710611154237014522 0ustar  jcwjcw00000000000000/*
 * indirect.c - Implementation of some virtual views.
 */

#include 
#include 

#include "intern.h"
#include "wrap_gen.h"

#define RV_parent   data[0].q
#define RV_map      data[1].q
#define RV_start    data[2].i

static ItemTypes RemapGetter (int row, Item_p item) {
    const int* data;
    Seq_p seq;

    Assert(item->c.pos >= 0);
    seq = item->c.seq;
    data = seq->RV_map->data[0].p;

    item->c = ViewCol(seq->RV_parent, item->c.pos);
    row += seq->RV_start;
    if (data[row] < 0)
        row += data[row];
    return GetItem(data[row], item);
}

static struct SeqType ST_Remap = { "remap", RemapGetter, 011 };

View_p RemapSubview (View_p view, Column mapcol, int start, int count) {
    Seq_p seq;

    if (mapcol.seq == NULL)
        return NULL;
        
    if (count < 0)
        count = mapcol.seq->count;
    
    if (ViewWidth(view) == 0)
        return NoColumnView(count);
        
    seq = NewSequence(count, &ST_Remap, 0);
    /* data[0] is the parent view to which the map applies */
    /* data[1] is the map, as a sequence */
    /* data[2] is the index offset */
    seq->RV_parent = IncRefCount(view);
    seq->RV_map = IncRefCount(mapcol.seq);
    seq->RV_start = start;

    return IndirectView(V_Meta(view), seq);
}

static View_p MakeMetaSubview (const char *name, View_p view) {
    View_p meta, result;
    Seq_p names, types, subvs;
    
    names = NewStrVec(1);
    AppendToStrVec(name, -1, names);

    types = NewStrVec(1);
    AppendToStrVec("V", -1, types);
    
    meta = V_Meta(view);
    subvs = NewSeqVec(IT_view, &meta, 1);
    
    result = NewView(V_Meta(meta));
    SetViewSeqs(result, MC_name, 1, FinishStrVec(names));
    SetViewSeqs(result, MC_type, 1, FinishStrVec(types));
    SetViewSeqs(result, MC_subv, 1, subvs);
    return result;
}

#define GV_parent       data[0].q
#define GV_start        data[1].q
#define GV_group        data[2].q
#define GV_cache        data[3].q

static ItemTypes GroupedGetter (int row, Item_p item) {
    Seq_p seq = item->c.seq;
    View_p *subviews = seq->GV_cache->data[0].p;
    
    if (subviews[row] == NULL) {
        const int *sptr = seq->GV_start->data[0].p;
        Seq_p gmap = seq->GV_group;
        int start = row > 0 ? sptr[row-1] : 0;
        
        item->c.seq = gmap;
        subviews[row] = IncRefCount(RemapSubview(seq->GV_parent, item->c,
                                                    start, sptr[row] - start));
    }
    
    item->v = subviews[row];
    return IT_view;
}

static struct SeqType ST_Grouped = { "grouped", GroupedGetter, 01111 };

View_p GroupedView (View_p view, Column startcol, Column groupcol, const char *name) {
    int groups;
    Seq_p seq, subviews;
    
    groups = startcol.seq->count;
    subviews = NewSeqVec(IT_view, NULL, groups);

    seq = NewSequence(groups, &ST_Grouped, 0);
    /* data[0] is the parent view to which the grouping applies */
    /* data[1] is the start map, as a sequence */
    /* data[2] is the group map, as a sequence */
    /* data[3] is a cache of subviews, as a pointer vector in a sequence */
    seq->GV_parent = IncRefCount(view);
    seq->GV_start = IncRefCount(startcol.seq);
    seq->GV_group = IncRefCount(groupcol.seq);
    seq->GV_cache = IncRefCount(subviews);

    return IndirectView(MakeMetaSubview(name, view), seq);
}

#define PV_parent   data[0].q
#define PV_start    data[1].i
#define PV_rate     data[2].i
#define PV_step     data[3].i

static ItemTypes StepGetter (int row, Item_p item) {
    Seq_p seq = item->c.seq;
    int rows = ViewSize(seq->PV_parent);

    item->c = ViewCol(seq->PV_parent, item->c.pos);
    row = (seq->PV_start + (row / seq->PV_rate) * seq->PV_step) % rows;
    if (row < 0)
        row += rows;
    return GetItem(row, item);
}

static struct SeqType ST_Step = { "step", StepGetter, 01 };

View_p StepView (View_p view, int count, int offset, int rate, int step) {
    Seq_p seq;

    /* prevent division by zero if input view is empty */
    if (ViewSize(view) == 0)
        return view;

    seq = NewSequence(count * rate, &ST_Step, 0);
    /* data[0] is the parent view to which the changes apply */
    /* data[1] is the starting offset */
    /* data[2] is the rate to repeat an item */
    /* data[3] is the step to the next item */
    seq->PV_parent = IncRefCount(view);
    seq->PV_start = offset;
    seq->PV_rate = rate;
    seq->PV_step = step;

    return IndirectView(V_Meta(view), seq);
}

#define CV_left     data[0].q
#define CV_right    data[1].q

static ItemTypes ConcatGetter (int row, Item_p item) {
    View_p view = item->c.seq->CV_left;
    int rows = ViewSize(view);
    
    if (row >= rows) {
        row -= rows;
        view = item->c.seq->CV_right;
    }

    item->c = ViewCol(view, item->c.pos);
    return GetItem(row, item);
}

static struct SeqType ST_Concat = { "concat", ConcatGetter, 011 };

View_p ConcatView (View_p view1, View_p view2) {
    int rows1, rows2;
    Seq_p seq;

    if (view1 == NULL || view2 == NULL || !ViewCompat(view1, view2))
        return NULL;
                    
    rows1 = ViewSize(view1);
    if (rows1 == 0)
        return view2;

    rows2 = ViewSize(view2);
    if (rows2 == 0)
        return view1;

    seq = NewSequence(rows1 + rows2, &ST_Concat, 0);
    /* data[0] is the left-hand view */
    /* data[1] is the right-hand view */
    seq->CV_left = IncRefCount(view1);
    seq->CV_right = IncRefCount(view2);

    return IndirectView(V_Meta(view1), seq);
}

#define UV_parent       data[0].q
#define UV_unmap        data[1].q
#define UV_subcol       data[2].i
#define UV_swidth       data[3].i

static ItemTypes UngroupGetter (int row, Item_p item) {
    int col, subcol, parentrow;
    const int *data;
    View_p view;
    Seq_p seq;

    col = item->c.pos;
    seq = item->c.seq;

    view = seq->UV_parent;
    data = seq->UV_unmap->data[0].p;
    subcol = seq->UV_subcol;

    parentrow = data[row];
    if (parentrow < 0) {
        parentrow = data[row+parentrow];
        row = -data[row];
    } else
        row = 0;
    
    if (subcol <= col && col < subcol + seq->UV_swidth) {
        view = GetViewItem(view, parentrow, subcol, IT_view).v;
        col -= subcol;
    } else {
        if (col >= subcol)
            col -= seq->UV_swidth - 1;
        row = parentrow;
    }
    
    item->c = ViewCol(view, col);
    return GetItem(row, item);
}

static struct SeqType ST_Ungroup = { "ungroup", UngroupGetter, 011 };

View_p UngroupView (View_p view, int col) {
    int i, n, r, rows;
    struct Buffer buffer;
    View_p subview, meta, submeta, newmeta;
    Seq_p seq, map;
    Column column;
    
    InitBuffer(&buffer);

    column = ViewCol(view, col);
    rows = column.seq->count;
    
    for (r = 0; r < rows; ++r) {
        subview = GetColItem(r, column, IT_view).v;
        n = ViewSize(subview);
        if (n > 0) {
            ADD_INT_TO_BUF(buffer, r);
            for (i = 1; i < n; ++i)
                ADD_INT_TO_BUF(buffer, -i);
        }
    }

    map = BufferAsIntVec(&buffer);
    
    /* result meta view replaces subview column with its actual meta view */
    meta = V_Meta(view);
    submeta = GetViewItem(meta, col, MC_subv, IT_view).v;
    newmeta = ConcatView(FirstView(meta, col), submeta);
    newmeta = ConcatView(newmeta, LastView(meta, ViewSize(meta) - (col + 1)));
    
    seq = NewSequence(map->count, &ST_Ungroup, 0);
    /* data[0] is the parent view */
    /* data[1] is ungroup map as a sequence */
    /* data[2] is the subview column */
    /* data[3] is the subview width */
    seq->UV_parent = IncRefCount(view);
    seq->UV_unmap = IncRefCount(map);
    seq->UV_subcol = col;
    seq->UV_swidth = ViewSize(submeta);
    
    return IndirectView(newmeta, seq);
}

#define BV_parent       data[0].q
#define BV_cumcnt       data[1].q

static ItemTypes BlockedGetter (int row, Item_p item) {
    int block;
    const int* data;
    View_p subv;
    Seq_p seq;

    seq = item->c.seq;
    data = seq->BV_cumcnt->data[0].p;

    for (block = 0; block + data[block] < row; ++block)
        ;

    if (row == block + data[block]) {
        row = block;
        block = ViewSize(seq->BV_parent) - 1;
    } else if (block > 0)
        row -= block + data[block-1];

    subv = GetViewItem(seq->BV_parent, block, 0, IT_view).v;
    item->c = ViewCol(subv, item->c.pos);    
    return GetItem(row, item);
}

static struct SeqType ST_Blocked = { "blocked", BlockedGetter, 011 };

View_p BlockedView (View_p view) {
    int r, rows, *limits, tally = 0;
    View_p submeta;
    Seq_p seq, offsets;
    Column blocks;

    /* view must have exactly one subview column */
    if (ViewWidth(view) != 1)
        return NULL;
    
    blocks = ViewCol(view, 0);
    rows = ViewSize(view);
    
    offsets = NewIntVec(rows, &limits);
    for (r = 0; r < rows; ++r) {
        tally += ViewSize(GetColItem(r, blocks, IT_view).v);
        limits[r] = tally;
    }
    
    seq = NewSequence(tally, &ST_Blocked, 0);
    /* data[0] is the parent view */
    /* data[1] is a cumulative row count, as a sequence */
    seq->BV_parent = IncRefCount(view);
    seq->BV_cumcnt = IncRefCount(offsets);
    
    submeta = GetViewItem(V_Meta(view), 0, MC_subv, IT_view).v;
    return IndirectView(submeta, seq);
}
vqcore/src/intern.h0000644000076500007650000002176410637226473014242 0ustar  jcwjcw00000000000000/*
 * intern.h - Internal definitions.
 */

#include 
#include 

typedef ptrdiff_t Int_t; /* large enough to hold a pointer */

typedef unsigned char Byte_t;

#ifdef OBJECT_TYPE
typedef OBJECT_TYPE Object_p;
#else
#include "defs.h"
#endif

#if !defined(VALUES_MUST_BE_ALIGNED) && (defined(__sparc__) || defined(__sgi__))
#define VALUES_MUST_BE_ALIGNED 1
#endif

#if !defined(_BIG_ENDIAN) && defined(WORDS_BIGENDIAN)
#define _BIG_ENDIAN 1
#endif

#if DEBUG+0
#define Assert(x) do if (!(x)) FailedAssert(#x, __FILE__, __LINE__); while (0)
#define DbgIf(x)  if (GetShared()->debug && (x))
#else
#define Assert(x)
#define DbgIf(x)  if (0)
#endif

#define DBG_trace   (1<<0)
#define DBG_deps    (1<<1)

#define PUSH_KEEP_REFS                            \
  { Shared_p _shared = GetShared();               \
    struct Buffer _keep, *_prev = _shared->keeps; \
    InitBuffer(_shared->keeps = &_keep);
    
#define POP_KEEP_REFS         \
    ReleaseSequences(&_keep); \
    _shared->keeps = _prev;   \
  }

/* keep in sync with CharAsItemType() in column.c */
typedef enum ItemTypes {
    IT_unknown,
    IT_int,
    IT_wide,
    IT_float,
    IT_double,
    IT_string,
    IT_bytes,
    IT_object,
    IT_column,
    IT_view,
    IT_error
} ItemTypes;

typedef enum ErrorCodes {
    EC_cioor,
    EC_rioor,
    EC_cizwv,
    EC_nmcw,
    EC_rambe,
    EC_nalor,
    EC_wnoa
} ErrorCodes;

struct Shared {
    struct SharedInfo *info;   /* ext_tcl.c */
    int                refs;   /* ext_tcl.c */
    int                debug;  /* debug flags */
    struct Buffer     *keeps;  /* column.c */
    struct Sequence   *empty;  /* view.c */
};

typedef struct Shared   *Shared_p;
typedef struct SeqType  *SeqType_p;
typedef struct Sequence *Seq_p;
typedef struct Column   *Column_p;
typedef union Item      *Item_p;
typedef Seq_p            View_p;

typedef ItemTypes  (*Getter) (int row, Item_p item);
typedef void       (*Cleaner) (Seq_p seq);

struct SeqType {
  const char *name;      /* for introspection only */
  Getter      getfun;    /* item accessor, copied to Sequence during setup */
  short       cleanups;  /* octal for data[0..3].p: 0=none, 1=decref, 2=free */
  Cleaner     cleaner;   /* called before performing the above cleanups */
};

struct Sequence {
  int        count;   /* number of entries */
  int        refs;    /* reference count */
  SeqType_p  type;    /* type dispatch table */
  Getter     getter;  /* item accessor function */
  union { int i; void *p; Seq_p q; Object_p o; } data[4]; /* getter-specific */
};

#define IncRefCount(seq) AdjustSeqRefs(seq, 1)
#define DecRefCount(seq) AdjustSeqRefs(seq, -1)
#define KeepRef(seq) IncRefCount(LoseRef(seq))

typedef struct Column {
    Seq_p        seq;    /* the sequence which will handle accesses */
    int          pos;    /* position of this column in the view */
} Column;              
                       
typedef union Item {
    char         b [8];  /* used for raw access and byte-swapping */
    int          q [2];  /* used for hash calculation of wides and doubles */
    int          i;      /* IT_int */
    int64_t      w;      /* IT_wide */
    float        f;      /* IT_float */
    double       d;      /* IT_double */
    const void  *p;      /* used to convert pointers */
    const char  *s;      /* IT_string */
    struct { const Byte_t *ptr; int len; } u; /* IT_bytes */
    Object_p     o;      /* IT_object */
    Column       c;      /* IT_column */
    View_p       v;      /* IT_view */
    ErrorCodes   e;      /* IT_error */
} Item;

/* column.c */

void      *(AdjustSeqRefs) (void *refs, int count);
void       (AppendToStrVec) (const void *s, int bytes, Seq_p seq);
int        (CastObjToItem) (char type, Item_p item);
ItemTypes  (CharAsItemType) (char type);
Column     (CoerceColumn) (ItemTypes type, Object_p obj);
void       (FailedAssert) (const char *msg, const char *file, int line);
Column     (ForceStringColumn) (Column column);
Item       (GetColItem) (int row, Column column, ItemTypes type);
ItemTypes  (GetItem) (int row, Item_p item);
Item       (GetSeqItem) (int row, Seq_p seq, ItemTypes type);
Item       (GetViewItem) (View_p view, int row, int col, ItemTypes type);
Seq_p      (LoseRef) (Seq_p seq);
Seq_p      (NewBitVec) (int count);
Seq_p      (NewIntVec) (int count, int **dataptr);
Seq_p      (NewPtrVec) (int count, Int_t **dataptr);
Seq_p      (NewSequence) (int count, SeqType_p type, int auxbytes);
Seq_p      (NewSequenceNoRef) (int count, SeqType_p type, int auxbytes);
Seq_p      (NewSeqVec) (ItemTypes type, const Seq_p *p, int n);
Seq_p      (NewStrVec) (int istext);
Seq_p      (FinishStrVec) (Seq_p seq);
void       (ReleaseSequences) (struct Buffer *keep);
Seq_p      (ResizeSeq) (Seq_p seq, int pos, int diff, int elemsize);
Column     (SeqAsCol) (Seq_p seq);

/* buffer.c */

typedef struct Buffer *Buffer_p;
typedef struct Overflow *Overflow_p;

struct Buffer {
    union { char *c; int *i; const void **p; } fill;
    char       *limit;
    Overflow_p  head;
    Int_t       saved;
    Int_t       used;
    char       *ofill;
    char       *result;
    char        buf [128];
    char        slack [8];
};

#define ADD_ONEC_TO_BUF(b,x) (*(b).fill.c++ = (x))

#define ADD_CHAR_TO_BUF(b,x) \
          { char _c = (x); \
            if ((b).fill.c < (b).limit) *(b).fill.c++ = _c; \
              else AddToBuffer(&(b), &_c, sizeof _c); }

#define ADD_INT_TO_BUF(b,x) \
          { int _i = (x); \
            if ((b).fill.c < (b).limit) *(b).fill.i++ = _i; \
              else AddToBuffer(&(b), &_i, sizeof _i); }

#define ADD_PTR_TO_BUF(b,x) \
          { const void *_p = (x); \
            if ((b).fill.c < (b).limit) *(b).fill.p++ = _p; \
              else AddToBuffer(&(b), &_p, sizeof _p); }

#define BufferFill(b) ((b)->saved + ((b)->fill.c - (b)->buf))

void   (InitBuffer) (Buffer_p bp);
void   (ReleaseBuffer) (Buffer_p bp, int keep);
void   (AddToBuffer) (Buffer_p bp, const void *data, Int_t len);
void  *(BufferAsPtr) (Buffer_p bp, int fast);
Seq_p  (BufferAsIntVec) (Buffer_p bp);
int    (NextBuffer) (Buffer_p bp, char **firstp, int *countp);

/* view.c */

typedef enum MetaCols {
  MC_name, MC_type, MC_subv, MC_limit
} MetaCols;

#define V_Cols(view) ((Column_p) ((Seq_p) (view) + 1))
#define V_Types(view) (*(char**) ((view)->data))
#define V_Meta(view) (*(View_p*) ((view)->data+1))

#define ViewAsCol(v) SeqAsCol(v)
#define ViewWidth(view) ((view)->count)
#define ViewCol(view,col) (V_Cols(view)[col])
#define ViewColType(view,col) ((ItemTypes) V_Types(view)[col])
#define ViewCompat(view1,view2) MetaIsCompatible(V_Meta(view1), V_Meta(view2))

View_p  (DescAsMeta) (const char** desc, const char* end);
View_p  (EmptyMetaView) (void);
char    (GetColType) (View_p meta, int col);
View_p  (IndirectView) (View_p meta, Seq_p seq);
View_p  (NewView) (View_p meta);
View_p  (MakeIntColMeta) (const char *name);
int     (MetaIsCompatible) (View_p meta1, View_p meta2);
void    (ReleaseUnusedViews) (void);
void    (SetViewCols) (View_p view, int first, int count, Column src);
void    (SetViewSeqs) (View_p view, int first, int count, Seq_p src);

/* hash.c */

int    (HashMapAdd) (Seq_p hmap, int key, int value);
int    (HashMapLookup) (Seq_p hmap, int key, int defval);
Seq_p  (HashMapNew) (void);
int    (HashMapRemove) (Seq_p hmap, int key);

/* file.c */

typedef Seq_p MappedFile_p;

MappedFile_p  (InitMappedFile) (const char *data, Int_t length, Cleaner fun);
View_p        (MappedToView) (MappedFile_p map, View_p base);
View_p        (OpenDataFile) (const char *filename);

/* emit.c */

typedef void *(*SaveInitFun)(void*,Int_t);
typedef void *(*SaveDataFun)(void*,const void*,Int_t);

void   (MetaAsDesc) (View_p meta, Buffer_p buffer);
Int_t  (ViewSave) (View_p view, void *aux, SaveInitFun, SaveDataFun, int);

/* getters.c */

SeqType_p (PickIntGetter) (int bits);
SeqType_p (FixedGetter) (int bytes, int rows, int real, int flip);

/* bits.c */
      
char  *(Bits2elias) (const char *bytes, int count, int *outsize);
void   (ClearBit) (Seq_p bitmap, int row);
int    (CountBits) (Seq_p seq);
Seq_p  (MinBitCount) (Seq_p *pbitmap, int count);
int    (NextBits) (Seq_p bits, int *fromp, int *countp);
int    (NextElias) (const char *bytes, int count, int *inbits);
int    (SetBit) (Seq_p *pbitmap, int row);
void   (SetBitRange) (Seq_p bits, int from, int count);
int    (TestBit) (Seq_p bitmap, int row);
int    (TopBit) (int v);

/* mutable.c */

enum MutPrepares {
    MP_insdat, MP_adjdat, MP_usemap, MP_delmap, MP_adjmap,
    MP_insmap, MP_revmap, MP_limit
};

int     (IsMutable) (View_p view);
View_p  (MutableView) (View_p view);
Seq_p   (MutPrepare) (View_p view);
View_p  (ViewSet) (View_p view, int row, int col, Item_p item);

/* the following must be supplied in the language binding */

int            (ColumnByName) (View_p meta, Object_p obj);
struct Shared *(GetShared) (void);
void           (InvalidateView) (Object_p obj);
Object_p       (ItemAsObj) (ItemTypes type, Item_p item);
Object_p       (NeedMutable) (Object_p obj);
Column         (ObjAsColumn) (Object_p obj);
View_p         (ObjAsView) (Object_p obj);
int            (ObjToItem) (ItemTypes type, Item_p item);
vqcore/src/mutable.c0000644000076500007650000004154210611154237014351 0ustar  jcwjcw00000000000000/*
 * mutable.c - Implementation of mutable views.
 */

#include 
#include 

#include "intern.h"
#include "wrap_gen.h"

#define MUT_DEBUG 0

#define S_aux(seq,typ) ((typ) ((Seq_p) (seq) + 1))

#define SV_data(seq)    S_aux(seq, Seq_p*)
#define SV_bits         data[0].q
#define SV_hash         data[1].q
#define SV_view         data[2].q

static void SettableCleaner (Seq_p seq) {
    int c, r;
    View_p view = seq->SV_view;
    
    for (c = 0; c < ViewWidth(view); ++c) {
        Seq_p dseq = SV_data(seq)[c];

        if (dseq != NULL)
            switch (ViewColType(view, c)) {

                case IT_string: {
                    char **p = S_aux(dseq, char**);
                    for (r = 0; r < dseq->count; ++r)
                        if (p[r] != NULL)
                            free(p[r]);
                    break;
                }

                case IT_bytes: {
                    const Item *p = S_aux(dseq, const Item*);
                    for (r = 0; r < dseq->count; ++r)
                        if (p[r].u.ptr != NULL)
                            free((char*) p[r].u.ptr);
                    break;
                }

                case IT_view: {
                    const View_p *p = S_aux(dseq, const View_p*);
                    for (r = 0; r < dseq->count; ++r)
                        if (p[r] != NULL)
                            DecRefCount(p[r]);
                    break;
                }
            
                default: break;
            }

        DecRefCount(dseq);
        DecRefCount(SV_data(seq)[ViewWidth(view)+c]);
    }
}

static ItemTypes SettableGetter (int row, Item_p item) {
    int col = item->c.pos;
    Seq_p seq = item->c.seq;
    View_p view = seq->SV_view;
    
    item->c = ViewCol(view, col);
    
    if (TestBit(seq->SV_bits, row)) {
        int index = HashMapLookup(seq->SV_hash, row, -1);
        Assert(index >= 0);
    
        if (TestBit(SV_data(seq)[ViewWidth(view)+col], index)) {
            row = index;
            item->c.seq = SV_data(seq)[col];
        }
    }
    
    return GetItem(row, item);
}
 
static int SettableWidth (ItemTypes type) {
    switch (type) {
        case IT_int:  case IT_float:    return 4;
        case IT_wide: case IT_double:   return 8;
        case IT_view: case IT_string:   return sizeof(void*);
        case IT_bytes:                  return sizeof(Item);
        default:                        Assert(0); return 0;
    }
}

static ItemTypes StringSetGetter (int row, Item_p item) {
    item->s = S_aux(item->c.seq, const char**)[row];
    return IT_string;
}

static ItemTypes BytesSetGetter (int row, Item_p item) {
    item->u = S_aux(item->c.seq, const Item*)[row].u;
    return IT_bytes;
}

static ItemTypes ViewSetGetter (int row, Item_p item) {
    item->v = S_aux(item->c.seq, const View_p*)[row];
    return IT_view;
}

static struct SeqType ST_StringSet = { "stringset", StringSetGetter };
static struct SeqType ST_BytesSet = { "bytesset", BytesSetGetter };
static struct SeqType ST_ViewSet = { "viewset", ViewSetGetter };

static SeqType_p PickSetGetter (ItemTypes type) {
    int w = 8;
    switch (type) {
        case IT_int:    w = 4; /* fall through */
        case IT_wide:   return FixedGetter(w, 1, 0, 0);
        case IT_float:  w = 4; /* fall through */
        case IT_double: return FixedGetter(w, 1, 1, 0);
        case IT_string: return &ST_StringSet;
        case IT_bytes:  return &ST_BytesSet;
        case IT_view:   return &ST_ViewSet;
        default:        Assert(0); return NULL;
    }
}

static struct SeqType ST_Settable = {
    "settable", SettableGetter, 0111, SettableCleaner
};

static int IsSettable(View_p view) {
    Seq_p seq = ViewCol(view, 0).seq;
    return seq != NULL && seq->type == &ST_Settable;
}

static void SettableSetter (View_p view, int row, int col, Item_p item) {
    int index, count, limit;
    ItemTypes type;
    Seq_p seq, dseq, hash;
    
    Assert(IsSettable(view));
    
    seq = ViewCol(view, col).seq;
    type = ViewColType(view, col);
    dseq = SV_data(seq)[col];
    hash = seq->SV_hash;

    if (SetBit(&seq->SV_bits, row)) {
        index = hash->count;
        HashMapAdd(hash, row, index);
    } else {
        index = HashMapLookup(hash, row, -1);
        Assert(index >= 0);
    }
    
    limit = SetBit(&SV_data(seq)[ViewWidth(view)+col], index);
    count = dseq != NULL ? dseq->count : 0;
    
    /* clumsy: resize a settable column so it can store more items if needed */
    if (limit > count) {
        int w = SettableWidth(type);
        Seq_p nseq;
        nseq = IncRefCount(NewSequence(limit, PickSetGetter(type), limit * w));
        memcpy(nseq + 1, LoseRef(dseq) + 1, count * w);
        SV_data(seq)[col] = dseq = nseq;
    }
    
    switch (type) {
        
        case IT_int:    S_aux(dseq, int*    )[index] = item->i; break;
        case IT_wide:   S_aux(dseq, int64_t*)[index] = item->w; break;
        case IT_float:  S_aux(dseq, float*  )[index] = item->f; break;                                  
        case IT_double: S_aux(dseq, double* )[index] = item->d; break;

        case IT_string: {
            char **p = S_aux(dseq, char**) + index;
            free(*p);
            *p = strdup(item->s);
            break;
        }
        
        case IT_bytes: {
            Item *p = S_aux(dseq, Item*) + index;
            free((char*) p->u.ptr);
            p->u.len = item->u.len;
            p->u.ptr = memcpy(malloc(p->u.len), item->u.ptr, p->u.len);
            break;
        }
        
        case IT_view: {
            View_p *p = S_aux(dseq, View_p*) + index;
            LoseRef(*p);
            *p = IncRefCount(item->v);
            break;
        }
        
        default: Assert(0); break;
    }
}

static View_p SettableView (View_p view) {
    Int_t bytes = 2 * ViewWidth(view) * sizeof(Seq_p*);
    Seq_p seq;
    
    /* room for a set of new data columns, then a set of "used" bitmaps */
    seq = NewSequence(ViewSize(view), &ST_Settable, bytes);
    /* data[0] is the adjusted bitmap */
    /* data[1] points to hash row map */
    /* data[2] points to the original view */
    seq->SV_bits = NULL;
    seq->SV_hash = IncRefCount(HashMapNew());
    seq->SV_view = IncRefCount(view);

    return IndirectView(V_Meta(view), seq);
}    

#define MV_parent       data[0].q
#define MV_mutmap       data[1].q

    typedef struct MutRange {
        int start;
        int shift;
        View_p added;
    } *MutRange_p;

static void MutableCleaner (Seq_p seq) {
    int i;
    Seq_p map;
    MutRange_p range;
    
    map = seq->MV_mutmap;
    range = S_aux(map, MutRange_p);

    for (i = 0; i < map->count; ++i)
        DecRefCount(range[i].added);
}

#if MUT_DEBUG
#include 
static void DumpRanges (const char *msg, View_p view) {
    int i;
    Seq_p seq, map;
    MutRange_p range;

    seq = ViewCol(view, 0).seq;
    map = seq->MV_mutmap;
    range = S_aux(map, MutRange_p);

    printf("%s: view %p rc %d, has %d rows %d ranges\n",
                 msg, (void*) view, view->refs, ViewSize(view), map->count);
    for (i = 0; i < map->count; ++i) {
        View_p v = range[i].added;
        printf("    %2d: st %3d sh %3d", i, range[i].start, range[i].shift);
        if (v != NULL)
            printf(" - %p: sz %3d rc %3d\n", (void*) v, ViewSize(v), v->refs);
        printf("\n");
    }
}
#else
#define DumpRanges(a,b)
#endif

static int MutSlot (MutRange_p range, int pos) {
    int i = -1;
    /* TODO: use binary i.s.o. linear search */
    while (pos > range[++i].start)
        ;
    return pos < range[i].start ? i-1 : i;
}

static int ChooseMutView (Seq_p seq, int *prow) {
    int slot, row = *prow;
    MutRange_p range;
    
    range = S_aux(seq->MV_mutmap, MutRange_p);
    
    slot = MutSlot(range, row);
    row -= range[slot].start;
    Assert(row >= 0);

    *prow = range[slot].added != NULL ? slot : -1;
    return row + range[slot].shift;
}

static ItemTypes MutableGetter (int row, Item_p item) {
    Seq_p seq = item->c.seq;
    View_p view = seq->MV_parent;
    int index = ChooseMutView(seq, &row);

    if (row >= 0) {
        MutRange_p range = S_aux(seq->MV_mutmap, MutRange_p);
        view = range[row].added;
    }

    item->c = ViewCol(view, item->c.pos);
    return GetItem(index, item);
}

static MutRange_p MutResize (Seq_p *seqp, int pos, int diff) {
    int i, limit = 0, count = 0;
    MutRange_p range = NULL;
    Seq_p map;
    
    map = *seqp;
    if (map != NULL) {
        count = map->count;
        limit = map->data[1].i / sizeof(struct MutRange);
        range = S_aux(map, MutRange_p);
    }
    
    /* TODO: this only grows the ranges, should also shrink when possible */
    if (diff > 0 && count + diff > limit) {
        int newlimit;
        MutRange_p newrange;
        
        newlimit = (count / 2) * 3 + 5;
        Assert(pos + diff <= newlimit);
            
        *seqp = NewSequence(count, PickIntGetter(0),
                                newlimit * sizeof(struct MutRange));

        newrange = S_aux(*seqp, MutRange_p);
        memcpy(newrange, range, count * sizeof(struct MutRange));
        range = newrange;

        LoseRef(map);
        map = IncRefCount(*seqp);
    }
    
    map->count += diff;
    
    if (diff > 0) {
        for (i = count; --i >= pos; )
            range[i+diff] = range[i];
    } else if (diff < 0) {
        for (i = pos; i < pos - diff; ++i)
            LoseRef(range[i].added);
        for (i = pos - diff; i < count; ++i)
            range[i+diff] = range[i];
    }
    
    return range;
}

static struct SeqType ST_Mutable = {
    "mutable", MutableGetter, 011, MutableCleaner 
};

View_p MutableView (View_p view) {
    int rows;
    Seq_p seq;

    rows = ViewSize(view);
    seq = NewSequence(rows, &ST_Mutable, 0);            
    /* data[0] is the parent view (may be changed to a settable one later) */
    /* data[1] holds the mutable range map, as a sequence */
    seq->MV_parent = IncRefCount(view);
    seq->MV_mutmap = NULL;
    
    if (rows == 0)
        MutResize(&seq->MV_mutmap, 0, 1);
    else {
        MutRange_p range = MutResize(&seq->MV_mutmap, 0, 2);
        range[1].start = rows;
    }
    
    return IndirectView(V_Meta(view), seq);
}

int IsMutable (View_p view) {
    Seq_p seq = ViewCol(view, 0).seq;
    return seq != NULL && seq->type == &ST_Mutable;
}

View_p ViewSet (View_p view, int row, int col, Item_p item) {
    int index;
    View_p *modview;
    Seq_p mutseq;

    if (!IsMutable(view))
        view = MutableView(view);
    
    mutseq = ViewCol(view, 0).seq;
    index = ChooseMutView(mutseq, &row);

    if (row >= 0) {
        MutRange_p range = S_aux(mutseq->MV_mutmap, MutRange_p);
        modview = &range[row].added;
    } else
        modview = (View_p*) &mutseq->data[0].p;
    
    if (!IsSettable(*modview))
        *modview = IncRefCount(SettableView(LoseRef(*modview)));
        
    SettableSetter(*modview, index, col, item);

    return view;
}

View_p ViewReplace (View_p view, int offset, int count, View_p data) {
    int drows, fend, fpos, fslot, tend, tpos, tslot, grow, diff;
    Seq_p seq, map;
    MutRange_p range;
    View_p tailv;
    
    drows = data != NULL ? ViewSize(data) : 0;
    fend = offset + count;
    tend = offset + drows;

    if (drows > 0 && !ViewCompat(view, data))
        return NULL;

    if (drows == 0 && count == 0)
        return view;
        
    if (!IsMutable(view))
        view = MutableView(view);

    DumpRanges("before", view);

    seq = ViewCol(view, 0).seq;
    map = seq->MV_mutmap;
    range = S_aux(map, MutRange_p);
    
    fslot = MutSlot(range, offset);
    fpos = offset - range[fslot].start;
    
    tslot = MutSlot(range, fend);
    tpos = fend - range[tslot].start;
    
    tailv = range[tslot].added;

#if MUT_DEBUG
printf("fslot %d fpos %d tslot %d tpos %d drows %d offset %d count %d fend %d tend %d\n", fslot,fpos,tslot,tpos,drows,offset,count,fend,tend);
#endif

    /* keep head of first range, if rows remain before offset */
    if (fpos > 0)
        ++fslot;
    
    grow = fslot - tslot;
    if (drows > 0)
        ++grow;

    range = MutResize(&seq->MV_mutmap, fslot, grow);
    tslot += grow;
    
    if (fpos > 0 && grow > 0)
        range[tslot].shift = range[fslot-1].shift;
    
    if (drows > 0) {
        range[fslot].start = offset;
        range[fslot].shift = 0;
        range[fslot].added = IncRefCount(data);
    }
        
    /* keep tail of last range, if rows remain after offset */
    if (tpos > 0) {
        range[tslot].start = tend;
        range[tslot].shift += tpos;
        LoseRef(range[tslot].added);
        range[tslot].added = IncRefCount(tailv);
        ++tslot;
    }
    
    diff = drows - count;
    seq->count += diff;
    
    map = seq->MV_mutmap;
    while (tslot < map->count)
        range[tslot++].start += diff;

    DumpRanges("after", view);
    return view;
}

ItemTypes SetCmd_MIX (Item args[]) {
    int i, col, row, objc;
    const Object_p *objv;
    View_p view;
    Item item;
    
    view = ObjAsView(args[0].o);
    row = args[1].i;
    if (row < 0)
        row += ViewSize(view);
    
    objv = (const void*) args[2].u.ptr;
    objc = args[2].u.len;

    if (objc % 2 != 0) {
        args->e = EC_wnoa;
        return IT_error;
    }

    for (i = 0; i < objc; i += 2) {
        col = ColumnByName(V_Meta(view), objv[i]);
        if (col < 0)
            return IT_unknown;

        item.o = objv[i+1];
        if (!ObjToItem(ViewColType(view, col), &item))
            return IT_unknown;

        view = ViewSet(view, row, col, &item);
    }

    args->v = view;
    return IT_view;
}

Seq_p MutPrepare (View_p view) {
    int i, j, k, cols, ranges, parows, delcnt, delpos, count, adjpos;
    Seq_p result, *seqs, mutseq, mutmap;
    MutRange_p range, rp;
    View_p parent, insview;
    Column column;
    
    Assert(IsMutable(view));
    
    mutseq = ViewCol(view, 0).seq;
    parent = mutseq->MV_parent;
    parows = ViewSize(parent);
    mutmap = mutseq->MV_mutmap;
    range = S_aux(mutmap, MutRange_p);
    ranges = mutmap->count - 1;
    
    cols = ViewWidth(view);
    result = NewSeqVec(IT_unknown, NULL, MP_limit);
    
    seqs = S_aux(result, Seq_p*);
        
    seqs[MP_delmap] = NewBitVec(parows);
    seqs[MP_insmap] = NewBitVec(ViewSize(view));

    delcnt = delpos = 0;
    insview = CloneView(view);
    
    for (i = 0; i < ranges; ++i) {
        rp = range + i;
        count = (rp+1)->start - rp->start;
        if (rp->added == NULL) {
            delcnt += rp->shift - delpos;
            SetBitRange(seqs[MP_delmap], delpos, rp->shift - delpos);
            delpos = rp->shift + count;
        } else {
            View_p newdata = StepView(rp->added, count, rp->shift, 1, 1);
            insview = ViewReplace(insview, ViewSize(insview), 0, newdata);
            SetBitRange(seqs[MP_insmap], rp->start, count);
        }
    }
    
    delcnt += parows - delpos;
    SetBitRange(seqs[MP_delmap], delpos, parows - delpos);
    seqs[MP_insdat] = insview;

    seqs[MP_adjmap] = NewBitVec(parows - delcnt);

    if (IsSettable(parent)) {
        Seq_p setseq, adjseq;
        
        setseq = ViewCol(parent, 0).seq;
        adjseq = setseq->SV_bits;
                
        if (adjseq != NULL && adjseq->count > 0) {
            int *revptr, *rowptr;
            Seq_p revmap, rowmap, hash = setseq->SV_hash;
            View_p bitmeta, bitview;
        
            revmap = NewIntVec(hash->count, &revptr);
            rowmap = NewIntVec(hash->count, &rowptr);

            k = adjpos = 0;
            
            for (i = 0; i < ranges; ++i) {
                rp = range + i;
                if (rp->added == NULL) {
                    count = (rp+1)->start - rp->start;
                    for (j = 0; j < count; ++j)
                        if (TestBit(adjseq, rp->start + j)) {
                            int index = HashMapLookup(hash, rp->start + j, -1);
                            Assert(index >= 0);
                            revptr[k] = index;
                            rowptr[k++] = rp->start + j;
                            SetBit(seqs+MP_adjmap, adjpos + j);
                        }
                    adjpos += count;
                }
            }
            
            Assert(adjpos == parows - delcnt);
            
            seqs[MP_adjdat] = RemapSubview(parent, SeqAsCol(rowmap), 0, -1);

            bitmeta = StepView(MakeIntColMeta("_"), 1, 0, ViewWidth(parent), 1);
            bitview = NewView(bitmeta); /* will become an N-intcol view */
            
            for (i = 0; i < cols; ++i) {
                column.seq = SV_data(setseq)[cols+i];
                column.pos = -1;
                MinBitCount(&column.seq, hash->count);
                SetViewCols(bitview, i, 1, column);
            }

            seqs[MP_revmap] = revmap;
            seqs[MP_usemap] = RemapSubview(bitview, SeqAsCol(revmap), 0, -1);
        }
    } else {
        seqs[MP_adjdat] = seqs[MP_usemap] = NoColumnView(0);
        seqs[MP_revmap] = ViewCol(seqs[MP_usemap], 0).seq;
    }
    
    for (i = 0; i < MP_limit; ++i)
        IncRefCount(seqs[i]);       
         
    return result;
}
vqcore/src/sorted.c0000644000076500007650000001604110611154237014214 0ustar  jcwjcw00000000000000/*
 * sorted.c - Implementation of sorting functions.
 */

#include 
#include 

#include "intern.h"
#include "wrap_gen.h"

static int ItemsEqual (ItemTypes type, Item a, Item b) {
    switch (type) {

        case IT_int:
            return a.i == b.i;

        case IT_wide:
            return a.w == b.w;

        case IT_float:
            return a.f == b.f;

        case IT_double:
            return a.d == b.d;

        case IT_string:
            return strcmp(a.s, b.s) == 0;

        case IT_bytes:
            return a.u.len == b.u.len && memcmp(a.u.ptr, b.u.ptr, a.u.len) == 0;

        case IT_view:
            return ViewCompare(a.v, b.v) == 0;
            
        default: Assert(0); return -1;
    }
}

int RowEqual (View_p v1, int r1, View_p v2, int r2) {
    int c;
    ItemTypes type;
    Item item1, item2;

    for (c = 0; c < ViewWidth(v1); ++c) {
        type = ViewColType(v1, c);
        item1 = GetViewItem(v1, r1, c, type);
        item2 = GetViewItem(v2, r2, c, type);

        if (!ItemsEqual(type, item1, item2))
            return 0;
    }

    return 1;
}

/* TODO: UTF-8 comparisons, also case-sensitive & insensitive */

static int ItemsCompare (ItemTypes type, Item a, Item b, int lower) {
    switch (type) {

        case IT_int:
            return (a.i > b.i) - (a.i < b.i);

        case IT_wide:
            return (a.w > b.w) - (a.w < b.w);

        case IT_float:
            return (a.f > b.f) - (a.f < b.f);

        case IT_double:
            return (a.d > b.d) - (a.d < b.d);

        case IT_string:
            return (lower ? strcasecmp : strcmp)(a.s, b.s);

        case IT_bytes: {
            int f;

            if (a.u.len == b.u.len)
                return memcmp(a.u.ptr, b.u.ptr, a.u.len);

            f = memcmp(a.u.ptr, b.u.ptr, a.u.len < b.u.len ? a.u.len : b.u.len);
            return f != 0 ? f : a.u.len - b.u.len;
        }
        
        case IT_view:
            return ViewCompare(a.v, b.v);
            
        default: Assert(0); return -1;
    }
}

int RowCompare (View_p v1, int r1, View_p v2, int r2) {
    int c, f;
    ItemTypes type;
    Item item1, item2;

    for (c = 0; c < ViewWidth(v1); ++c) {
        type = ViewColType(v1, c);
        item1 = GetViewItem(v1, r1, c, type);
        item2 = GetViewItem(v2, r2, c, type);

        f = ItemsCompare(type, item1, item2, 0);
        if (f != 0)
            return f < 0 ? -1 : 1;
    }

    return 0;
}

static int RowIsLess (View_p v, int a, int b) {
    int c, f;
    ItemTypes type;
    Item va, vb;

    if (a != b)
        for (c = 0; c < ViewWidth(v); ++c) {
            type = ViewColType(v, c);
            va = GetViewItem(v, a, c, type);
            vb = GetViewItem(v, b, c, type);

            f = ItemsCompare(type, va, vb, 0);
            if (f != 0)
                return f < 0;
        }

    return a < b;
}

static int TestAndSwap (View_p v, int *a, int *b) {
    if (RowIsLess(v, *b, *a)) {
        int t = *a;
        *a = *b;
        *b = t;
        return 1;
    }
    return 0;
}

static void MergeSort (View_p v, int *ar, int nr, int *scr) {
    switch (nr) {
        case 2:
            TestAndSwap(v, ar, ar+1);
            break;
        case 3:
            TestAndSwap(v, ar, ar+1);
            if (TestAndSwap(v, ar+1, ar+2))
                TestAndSwap(v, ar, ar+1);
            break;
        case 4: /* TODO: optimize with if's */
            TestAndSwap(v, ar, ar+1);
            TestAndSwap(v, ar+2, ar+3);
            TestAndSwap(v, ar, ar+2);
            TestAndSwap(v, ar+1, ar+3);
            TestAndSwap(v, ar+1, ar+2);
            break;
            /* TODO: also special-case 5-item sort? */
        default: {
            int s1 = nr / 2, s2 = nr - s1;
            int *f1 = scr, *f2 = scr + s1, *t1 = f1 + s1, *t2 = f2 + s2;
            MergeSort(v, f1, s1, ar);
            MergeSort(v, f2, s2, ar+s1);
            for (;;)
                if (RowIsLess(v, *f1, *f2)) {
                    *ar++ = *f1++;
                    if (f1 >= t1) {
                        while (f2 < t2)
                            *ar++ = *f2++;
                        break;
                    }
                } else {
                    *ar++ = *f2++;
                    if (f2 >= t2) {
                        while (f1 < t1)
                            *ar++ = *f1++;
                        break;
                    }
                }
        }
    }
}

Column SortMap (View_p view) {
    int r, rows, *imap, *itmp;
    Seq_p seq;

    rows = ViewSize(view);

    if (rows <= 1 || ViewWidth(view) == 0)
        return NewIotaColumn(rows);

    seq = NewIntVec(rows, &imap);
    NewIntVec(rows, &itmp);
    
    for (r = 0; r < rows; ++r)
        imap[r] = itmp[r] = r;

    MergeSort(view, imap, rows, itmp);

    return SeqAsCol(seq);
}

static ItemTypes AggregateMax (ItemTypes type, Column column, Item_p item) {
    int r, rows;
    Item temp;
    
    rows = column.seq->count;
    if (rows == 0) {
        item->e = EC_nalor;
        return IT_error;
    }
    
    *item = GetColItem(0, column, type);
    for (r = 1; r < rows; ++r) {
        temp = GetColItem(r, column, type);
        if (ItemsCompare (type, temp, *item, 0) > 0)
            *item = temp;
    }
    
    return type;
}

ItemTypes MaxCmd_VN (Item args[]) {
    Column column = ViewCol(args[0].v, args[1].i);
    return AggregateMax(ViewColType(args[0].v, args[1].i), column, args);
}

static ItemTypes AggregateMin (ItemTypes type, Column column, Item_p item) {
    int r, rows;
    Item temp;
    
    rows = column.seq->count;
    if (rows == 0) {
        item->e = EC_nalor;
        return IT_error;
    }
    
    *item = GetColItem(0, column, type);
    for (r = 1; r < rows; ++r) {
        temp = GetColItem(r, column, type);
        if (ItemsCompare (type, temp, *item, 0) < 0)
            *item = temp;
    }
    
    return type;
}

ItemTypes MinCmd_VN (Item args[]) {
    Column column = ViewCol(args[0].v, args[1].i);
    return AggregateMin(ViewColType(args[0].v, args[1].i), column, args);
}

static ItemTypes AggregateSum (ItemTypes type, Column column, Item_p item) {
    int r, rows = column.seq->count;
    
    switch (type) {
        
        case IT_int:
            item->w = 0; 
            for (r = 0; r < rows; ++r)
                item->w += GetColItem(r, column, IT_int).i;
            return IT_wide;
            
        case IT_wide:
            item->w = 0;
            for (r = 0; r < rows; ++r)
                item->w += GetColItem(r, column, IT_wide).w;
            return IT_wide;
            
        case IT_float:
            item->d = 0; 
            for (r = 0; r < rows; ++r)
                item->d += GetColItem(r, column, IT_float).f;
            return IT_double;

        case IT_double:     
            item->d = 0; 
            for (r = 0; r < rows; ++r)
                item->d += GetColItem(r, column, IT_double).d;
            return IT_double;
            
        default:
            return IT_unknown;
    }
}

ItemTypes SumCmd_VN (Item args[]) {
    Column column = ViewCol(args[0].v, args[1].i);
    return AggregateSum(ViewColType(args[0].v, args[1].i), column, &args[0]);
}
vqcore/src/view.c0000644000076500007650000003112310634015431013661 0ustar  jcwjcw00000000000000/*
 * view.c - Implementation of views.
 */

#include 
#include 

#include "intern.h"
#include "wrap_gen.h"

int ViewSize (View_p view) {
    Seq_p seq = ViewCol(view, 0).seq;
    return seq != NULL ? seq->count : 0;
}

char GetColType (View_p meta, int col) {
    /* TODO: could be a #define */
    return *GetViewItem(meta, col, MC_type, IT_string).s;
}

static void ViewCleaner (View_p view) {
    int c;
    for (c = 0; c <= ViewWidth(view); ++c)
        DecRefCount(ViewCol(view, c).seq);
}

static ItemTypes ViewGetter (int row, Item_p item) {
    item->c = ViewCol(item->c.seq, row);
    return IT_column;
}

static struct SeqType ST_View = { "view", ViewGetter, 010, ViewCleaner };

static View_p ForceMetaView(View_p meta) {
    View_p newmeta;
    Column orignames, names;
    
    /* this code is needed so we can always do a hash lookup on name column */
    
    orignames = ViewCol(meta, MC_name);
    names = ForceStringColumn(orignames);
    
    if (names.seq == orignames.seq)
        return meta;
        
    /* need to construct a new meta view with the adjusted names column */
    newmeta = NewView(V_Meta(meta));

    SetViewCols(newmeta, MC_name, 1, names);
    SetViewCols(newmeta, MC_type, 1, ViewCol(meta, MC_type));
    SetViewCols(newmeta, MC_subv, 1, ViewCol(meta, MC_subv));

    return newmeta;
}

View_p NewView (View_p meta) {
    int c, cols, bytes;
    View_p view;

    /* a view must always be able to store at least one column */
    cols = ViewSize(meta);
    bytes = (cols + 1) * (sizeof(Column) + 1);

    view = NewSequence(cols, &ST_View, bytes);
    /* data[0] points to types string (allocated inline after the columns) */
    /* data[1] is the meta view */
    V_Types(view) = (char*) (V_Cols(view) + cols + 1);
    V_Meta(view) = IncRefCount(ForceMetaView(meta));

    /* TODO: could optimize by storing the types with the meta view instead */
    for (c = 0; c < cols; ++c)
        V_Types(view)[c] = CharAsItemType(GetColType(meta, c));

    return view;
}

void SetViewCols (View_p view, int first, int count, Column src) {
    int c;

    AdjustSeqRefs(src.seq, count);
    for (c = first; c < first + count; ++c) {
        DecRefCount(ViewCol(view, c).seq);
        ViewCol(view, c) = src;
    }
}

void SetViewSeqs (View_p view, int first, int count, Seq_p src) {
    SetViewCols(view, first, count, SeqAsCol(src));
}

View_p IndirectView (View_p meta, Seq_p seq) {
    int c, cols;
    View_p result;

    cols = ViewSize(meta);
    if (cols == 0)
        ++cols;
        
    result = NewView(meta);
    SetViewSeqs(result, 0, cols, seq);

    for (c = 0; c < cols; ++c)
        ViewCol(result, c).pos = c;

    return result;
}

View_p EmptyMetaView (void) {
    Shared_p sh = GetShared();
    
    if (sh->empty == NULL) {
        int bytes;
        View_p meta, subs [MC_limit];
        Seq_p tempseq;

        /* meta is recursively defined, so we can't use NewView here */
        bytes = (MC_limit + 1) * (sizeof(Column) + 1);
        meta = NewSequence(MC_limit, &ST_View, bytes);
        V_Meta(meta) = IncRefCount(meta); /* circular */
    
        V_Types(meta) = (char*) (V_Cols(meta) + MC_limit + 1);
        V_Types(meta)[0] = V_Types(meta)[1] = IT_string;
        V_Types(meta)[2] = IT_view;

        /* initialize all but last columns of meta with static ptr contents */
        tempseq = NewStrVec(1);
        AppendToStrVec("name", -1, tempseq);
        AppendToStrVec("type", -1, tempseq);
        AppendToStrVec("subv", -1, tempseq);
        SetViewSeqs(meta, MC_name, 1, FinishStrVec(tempseq));

        tempseq = NewStrVec(1);
        AppendToStrVec("S", -1, tempseq);
        AppendToStrVec("S", -1, tempseq);
        AppendToStrVec("V", -1, tempseq);
        SetViewSeqs(meta, MC_type, 1, FinishStrVec(tempseq));

        /* same structure as meta but no rows */
        sh->empty = NewView(meta);

        /* initialize last column of meta, now that empty exists */
        subs[MC_name] = subs[MC_type] = subs[MC_subv] = sh->empty;
        SetViewSeqs(meta, MC_subv, 1, NewSeqVec(IT_view, subs, MC_limit));
    }
    
    return sh->empty;
}

View_p NoColumnView (int rows) {
    View_p result = NewView(EmptyMetaView());
    SetViewSeqs(result, 0, 1, NewSequence(rows, PickIntGetter(0), 0));
    return result;
}

View_p ColMapView (View_p view, Column mapcol) {
    int c, cols;
    const int *map;
    View_p result;

    map = (const int*) mapcol.seq->data[0].p;
    cols = mapcol.seq->count;

    if (cols == 0)
        return NoColumnView(ViewSize(view));

    result = NewView(RemapSubview(V_Meta(view), mapcol, 0, cols));

    for (c = 0; c < cols; ++c)
        SetViewCols(result, c, 1, ViewCol(view, map[c]));

    return result;
}

View_p ColOmitView (View_p view, Column omitcol) {
    int c, d, *map;
    Seq_p mapcol;
    
    mapcol = NewIntVec(ViewWidth(view), &map);

    /* TODO: make this robust, may have to add bounds check */
    for (c = 0; c < omitcol.seq->count; ++c)
        map[GetColItem(c, omitcol, IT_int).i] = 1;
    
    for (c = d = 0; c < mapcol->count; ++c)
        if (!map[c])
            map[d++] = c;
            
    mapcol->count = d; /* TODO: truncate unused area */
    return ColMapView(view, SeqAsCol(mapcol));
}

View_p OneColView (View_p view, int col) {
    View_p result;

    result = NewView(StepView(V_Meta(view), 1, col, 1, 1));
    SetViewCols(result, 0, 1, ViewCol(view, col));

    return result;
}

View_p FirstView (View_p view, int count) {
    if (count >= ViewSize(view))
        return view;
    return StepView(view, count, 0, 1, 1);
}

View_p LastView (View_p view, int count) {
    int rows = ViewSize(view);
    if (count >= rows)
        return view;
    return StepView(view, count, rows - count, 1, 1);
}

View_p TakeView (View_p view, int count) {
    if (count >= 0)
        return StepView(view, count, 0, 1, 1);
    else
        return StepView(view, -count, -1, 1, -1);
}

View_p CloneView (View_p view) {
    return NewView(V_Meta(view));
}

View_p PairView (View_p view1, View_p view2) {
    int c, rows1 = ViewSize(view1), rows2 = ViewSize(view2);
    View_p meta, result;

    if (rows2 < rows1)
        view1 = FirstView(view1, rows2);
    else if (rows1 < rows2)
        view2 = FirstView(view2, rows1);
    else if (ViewWidth(view2) == 0)
        return view1;
    else if (ViewWidth(view1) == 0)
        return view2;

    meta = ConcatView(V_Meta(view1), V_Meta(view2));
    result = NewView(meta);
    
    for (c = 0; c < ViewWidth(view1); ++c)
        SetViewCols(result, c, 1, ViewCol(view1, c));
    for (c = 0; c < ViewWidth(view2); ++c)
        SetViewCols(result, ViewWidth(view1) + c, 1, ViewCol(view2, c));
        
    return result;
}

static void ViewStructure (View_p meta, Buffer_p buffer) {
    int c, cols = ViewSize(meta);
    
    for (c = 0; c < cols; ++c) {
        char type = GetColType(meta, c);
        
        if (type == 'V') {
            View_p submeta = GetViewItem(meta, c, MC_subv, IT_view).v;
            
            if (ViewSize(submeta) > 0) {
                AddToBuffer(buffer, "(", 1);
                ViewStructure(submeta, buffer);
                AddToBuffer(buffer, ")", 1);
                continue;
            }
        }
        AddToBuffer(buffer, &type, 1);
    }
}

int MetaIsCompatible (View_p meta1, View_p meta2) {
    if (meta1 != meta2) {
        int c, cols = ViewSize(meta1);

        if (cols != ViewSize(meta2))
            return 0;
        
        for (c = 0; c < cols; ++c) {
            char type = GetColType(meta1, c);
        
            if (type != GetColType(meta2, c))
                return 0;
            
            if (type == 'V') {
                View_p v1 = GetViewItem(meta1, c, MC_subv, IT_view).v;
                View_p v2 = GetViewItem(meta2, c, MC_subv, IT_view).v;

                if (!MetaIsCompatible(v1, v2))
                    return 0;
            }
        }
    }
    
    return 1;
}

int ViewCompare (View_p view1, View_p view2) {
    int f, r, rows1, rows2;
    
    if (view1 == view2)
        return 0;
    
    f = ViewCompare(V_Meta(view1), V_Meta(view2));
    if (f != 0)
        return f;
        
    rows1 = ViewSize(view1);
    rows2 = ViewSize(view2);
    
    for (r = 0; r < rows1; ++r) {
        if (r >= rows2)
            return 1;
    
        f = RowCompare(view1, r, view2, r);
        if (f != 0)
            return f < 0 ? -1 : 1;
    }
        
    return rows1 < rows2 ? -1 : 0;
}

View_p MakeIntColMeta (const char *name) {
    View_p result, subv;
    Seq_p names, types, subvs;
    
    names = NewStrVec(1);
    AppendToStrVec(name, -1, names);

    types = NewStrVec(1);
    AppendToStrVec("I", -1, types);

    subv = EmptyMetaView();
    subvs = NewSeqVec(IT_view, &subv, 1);
    
    result = NewView(V_Meta(EmptyMetaView()));
    SetViewSeqs(result, MC_name, 1, FinishStrVec(names));
    SetViewSeqs(result, MC_type, 1, FinishStrVec(types));
    SetViewSeqs(result, MC_subv, 1, subvs);
    return result;
}

View_p TagView (View_p view, const char* name) {
    View_p tagview;
    
    tagview = NewView(MakeIntColMeta(name));
    SetViewCols(tagview, 0, 1, NewIotaColumn(ViewSize(view)));
    
    return PairView(view, tagview);
}

View_p DescAsMeta (const char** desc, const char* end) {
    int c, len, cols = 0, namebytes = 0;
    char sep, *buf, *ptr, **strings;
    Seq_p *views, tempseq;
    struct Buffer names, types, subvs;
    View_p result, empty;

    InitBuffer(&names);
    InitBuffer(&types);
    InitBuffer(&subvs);
    
    len = end - *desc;
    buf = memcpy(malloc(len+1), *desc, len);
    buf[len] = ',';
    
    empty = EmptyMetaView();
    result = NewView(V_Meta(empty));
    
    for (ptr = buf; ptr < buf + len; ++ptr) {
        const char *s = ptr;
        while (strchr(":,[]", *ptr) == 0)
            ++ptr;
        sep = *ptr;
        *ptr = 0;

        ADD_PTR_TO_BUF(names, s);
        namebytes += ptr - s + 1;
         
        switch (sep) {

            case '[':
                ADD_PTR_TO_BUF(types, "V");
                ++ptr;
                ADD_PTR_TO_BUF(subvs, DescAsMeta((const char**) &ptr, buf + len));
                sep = *++ptr;
                break;

            case ':':
                ptr += 2;
                sep = *ptr;
                *ptr = 0;
                ADD_PTR_TO_BUF(types, ptr - 1);
                ADD_PTR_TO_BUF(subvs, empty);
                break;

            default:
                ADD_PTR_TO_BUF(types, "S");
                ADD_PTR_TO_BUF(subvs, empty);
                break;
        }
        
        ++cols;
        if (sep != ',')
            break;
    }

    strings = BufferAsPtr(&names, 1);
    tempseq = NewStrVec(1);
    for (c = 0; c < cols; ++c)
        AppendToStrVec(strings[c], -1, tempseq);
    SetViewSeqs(result, MC_name, 1, FinishStrVec(tempseq));
    ReleaseBuffer(&names, 0);
    
    strings = BufferAsPtr(&types, 1);
    tempseq = NewStrVec(1);
    for (c = 0; c < cols; ++c)
        AppendToStrVec(strings[c], -1, tempseq);
    SetViewSeqs(result, MC_type, 1, FinishStrVec(tempseq));
    ReleaseBuffer(&types, 0);
    
    views = BufferAsPtr(&subvs, 1);
    tempseq = NewSeqVec(IT_view, views, cols);
    SetViewSeqs(result, MC_subv, 1, tempseq);
    ReleaseBuffer(&subvs, 0);
    
    free(buf);
    *desc += ptr - buf;
    return result;
}

View_p DescToMeta (const char *desc) {
    int len;
    const char *end;
    View_p meta;

    len = strlen(desc);
    end = desc + len;
    
    meta = DescAsMeta(&desc, end);
    if (desc < end)
        return NULL;

    return meta;
}

ItemTypes DataCmd_VX (Item args[]) {
    View_p meta, view;
    int c, cols, objc;
    const Object_p *objv;
    Column column;

    meta = args[0].v;
    cols = ViewSize(meta);
    
    objv = (const void*) args[1].u.ptr;
    objc = args[1].u.len;

    if (objc != cols) {
        args->e = EC_wnoa;
        return IT_error;
    }

    view = NewView(meta);
    for (c = 0; c < cols; ++c) {
        column = CoerceColumn(ViewColType(view, c), objv[c]);
        if (column.seq == NULL)
            return IT_unknown;
            
        SetViewCols(view, c, 1, column);
    }

    args->v = view;
    return IT_view;
}

ItemTypes StructDescCmd_V (Item args[]) {
    struct Buffer buffer;
    Item item;
    
    InitBuffer(&buffer);
    MetaAsDesc(V_Meta(args[0].v), &buffer);
    AddToBuffer(&buffer, "", 1);
    item.s = BufferAsPtr(&buffer, 1);
    args->o = ItemAsObj(IT_string, &item);
    ReleaseBuffer(&buffer, 0);
    return IT_object;
}

ItemTypes StructureCmd_V (Item args[]) {
    struct Buffer buffer;
    Item item;
    
    InitBuffer(&buffer);
    ViewStructure(V_Meta(args[0].v), &buffer);
    AddToBuffer(&buffer, "", 1);
    item.s = BufferAsPtr(&buffer, 1);
    args->o = ItemAsObj(IT_string, &item);
    ReleaseBuffer(&buffer, 0);
    return IT_object;
}
vqcore/src/wrap_gen.c0000644000076500007650000002165210574360066014531 0ustar  jcwjcw00000000000000/* wrap_gen.c - generated code, do not edit */

#include 

#include "intern.h"
#include "wrap_gen.h"
  
ItemTypes BlockedCmd_V (Item_p a) {
  a[0].v = BlockedView(a[0].v);
  return IT_view;
}

ItemTypes CloneCmd_V (Item_p a) {
  a[0].v = CloneView(a[0].v);
  return IT_view;
}

ItemTypes CoerceCmd_OS (Item_p a) {
  a[0].c = CoerceCmd(a[0].o, a[1].s);
  return IT_column;
}

ItemTypes ColMapCmd_Vn (Item_p a) {
  a[0].v = ColMapView(a[0].v, a[1].c);
  return IT_view;
}

ItemTypes ColOmitCmd_Vn (Item_p a) {
  a[0].v = ColOmitView(a[0].v, a[1].c);
  return IT_view;
}

ItemTypes CompareCmd_VV (Item_p a) {
  a[0].i = ViewCompare(a[0].v, a[1].v);
  return IT_int;
}

ItemTypes CompatCmd_VV (Item_p a) {
  a[0].i = ViewCompat(a[0].v, a[1].v);
  return IT_int;
}

ItemTypes ConcatCmd_VV (Item_p a) {
  a[0].v = ConcatView(a[0].v, a[1].v);
  return IT_view;
}

ItemTypes CountsColCmd_C (Item_p a) {
  a[0].c = NewCountsColumn(a[0].c);
  return IT_column;
}

ItemTypes CountViewCmd_I (Item_p a) {
  a[0].v = NoColumnView(a[0].i);
  return IT_view;
}

ItemTypes FirstCmd_VI (Item_p a) {
  a[0].v = FirstView(a[0].v, a[1].i);
  return IT_view;
}

ItemTypes GetColCmd_VN (Item_p a) {
  a[0].c = ViewCol(a[0].v, a[1].i);
  return IT_column;
}

ItemTypes GetInfoCmd_VVI (Item_p a) {
  a[0].c = GetHashInfo(a[0].v, a[1].v, a[2].i);
  return IT_column;
}

ItemTypes GroupCmd_VnS (Item_p a) {
  a[0].v = GroupCol(a[0].v, a[1].c, a[2].s);
  return IT_view;
}

ItemTypes GroupedCmd_ViiS (Item_p a) {
  a[0].v = GroupedView(a[0].v, a[1].c, a[2].c, a[3].s);
  return IT_view;
}

ItemTypes HashFindCmd_VIViii (Item_p a) {
  a[0].i = HashDoFind(a[0].v, a[1].i, a[2].v, a[3].c, a[4].c, a[5].c);
  return IT_int;
}

ItemTypes HashViewCmd_V (Item_p a) {
  a[0].c = HashValues(a[0].v);
  return IT_column;
}

ItemTypes IjoinCmd_VV (Item_p a) {
  a[0].v = IjoinView(a[0].v, a[1].v);
  return IT_view;
}

ItemTypes IotaCmd_I (Item_p a) {
  a[0].c = NewIotaColumn(a[0].i);
  return IT_column;
}

ItemTypes IsectMapCmd_VV (Item_p a) {
  a[0].c = IntersectMap(a[0].v, a[1].v);
  return IT_column;
}

ItemTypes JoinCmd_VVS (Item_p a) {
  a[0].v = JoinView(a[0].v, a[1].v, a[2].s);
  return IT_view;
}

ItemTypes LastCmd_VI (Item_p a) {
  a[0].v = LastView(a[0].v, a[1].i);
  return IT_view;
}

ItemTypes MdefCmd_O (Item_p a) {
  a[0].v = ObjAsMetaView(a[0].o);
  return IT_view;
}

ItemTypes MdescCmd_S (Item_p a) {
  a[0].v = DescToMeta(a[0].s);
  return IT_view;
}

ItemTypes MetaCmd_V (Item_p a) {
  a[0].v = V_Meta(a[0].v);
  return IT_view;
}

ItemTypes OmitMapCmd_iI (Item_p a) {
  a[0].c = OmitColumn(a[0].c, a[1].i);
  return IT_column;
}

ItemTypes OneColCmd_VN (Item_p a) {
  a[0].v = OneColView(a[0].v, a[1].i);
  return IT_view;
}

ItemTypes PairCmd_VV (Item_p a) {
  a[0].v = PairView(a[0].v, a[1].v);
  return IT_view;
}

ItemTypes RemapSubCmd_ViII (Item_p a) {
  a[0].v = RemapSubview(a[0].v, a[1].c, a[2].i, a[3].i);
  return IT_view;
}

ItemTypes ReplaceCmd_VIIV (Item_p a) {
  a[0].v = ViewReplace(a[0].v, a[1].i, a[2].i, a[3].v);
  return IT_view;
}

ItemTypes RowCmpCmd_VIVI (Item_p a) {
  a[0].i = RowCompare(a[0].v, a[1].i, a[2].v, a[3].i);
  return IT_int;
}

ItemTypes RowEqCmd_VIVI (Item_p a) {
  a[0].i = RowEqual(a[0].v, a[1].i, a[2].v, a[3].i);
  return IT_int;
}

ItemTypes RowHashCmd_VI (Item_p a) {
  a[0].i = RowHash(a[0].v, a[1].i);
  return IT_int;
}

ItemTypes SizeCmd_V (Item_p a) {
  a[0].i = ViewSize(a[0].v);
  return IT_int;
}

ItemTypes SortMapCmd_V (Item_p a) {
  a[0].c = SortMap(a[0].v);
  return IT_column;
}

ItemTypes StepCmd_VIIII (Item_p a) {
  a[0].v = StepView(a[0].v, a[1].i, a[2].i, a[3].i, a[4].i);
  return IT_view;
}

ItemTypes StrLookupCmd_Ss (Item_p a) {
  a[0].i = StringLookup(a[0].s, a[1].c);
  return IT_int;
}

ItemTypes TagCmd_VS (Item_p a) {
  a[0].v = TagView(a[0].v, a[1].s);
  return IT_view;
}

ItemTypes TakeCmd_VI (Item_p a) {
  a[0].v = TakeView(a[0].v, a[1].i);
  return IT_view;
}

ItemTypes UngroupCmd_VN (Item_p a) {
  a[0].v = UngroupView(a[0].v, a[1].i);
  return IT_view;
}

ItemTypes UniqueMapCmd_V (Item_p a) {
  a[0].c = UniqMap(a[0].v);
  return IT_column;
}

ItemTypes ViewAsColCmd_V (Item_p a) {
  a[0].c = ViewAsCol(a[0].v);
  return IT_column;
}

ItemTypes WidthCmd_V (Item_p a) {
  a[0].i = ViewWidth(a[0].v);
  return IT_int;
}

/* : append ( VV-V ) over size swap insert ; */
ItemTypes AppendCmd_VV (Item_p a) {
  ItemTypes t;
  /* over 0 */ a[2] = a[0];
  t = SizeCmd_V(a+2);
  /* swap 1 */ a[3] = a[1]; a[1] = a[2]; a[2] = a[3];
  t = InsertCmd_VIV(a);
  return IT_view;
}

/* : colconv ( C-C )   ; */
ItemTypes ColConvCmd_C (Item_p a) {
  return IT_column;
}

/* : counts ( VN-C ) getcol countscol ; */
ItemTypes CountsCmd_VN (Item_p a) {
  ItemTypes t;
  t = GetColCmd_VN(a);
  t = CountsColCmd_C(a);
  return IT_column;
}

/* : delete ( VII-V ) 0 countview replace ; */
ItemTypes DeleteCmd_VII (Item_p a) {
  ItemTypes t;
  a[3].i = 0;
  t = CountViewCmd_I(a+3);
  t = ReplaceCmd_VIIV(a);
  return IT_view;
}

/* : except ( VV-V ) over swap exceptmap remap ; */
ItemTypes ExceptCmd_VV (Item_p a) {
  ItemTypes t;
  /* over 0 */ a[2] = a[0];
  /* swap 1 */ a[3] = a[1]; a[1] = a[2]; a[2] = a[3];
  t = ExceptMapCmd_VV(a+1);
  t = RemapCmd_Vi(a);
  return IT_view;
}

/* : exceptmap ( VV-C ) over swap isectmap swap size omitmap ; */
ItemTypes ExceptMapCmd_VV (Item_p a) {
  ItemTypes t;
  /* over 0 */ a[2] = a[0];
  /* swap 1 */ a[3] = a[1]; a[1] = a[2]; a[2] = a[3];
  t = IsectMapCmd_VV(a+1);
  /* swap 0 */ a[2] = a[0]; a[0] = a[1]; a[1] = a[2];
  t = SizeCmd_V(a+1);
  t = OmitMapCmd_iI(a);
  return IT_column;
}

/* : insert ( VIV-V ) 0 swap replace ; */
ItemTypes InsertCmd_VIV (Item_p a) {
  ItemTypes t;
  a[3].i = 0;
  /* swap 2 */ a[4] = a[2]; a[2] = a[3]; a[3] = a[4];
  t = ReplaceCmd_VIIV(a);
  return IT_view;
}

/* : intersect ( VV-V ) over swap isectmap remap ; */
ItemTypes IntersectCmd_VV (Item_p a) {
  ItemTypes t;
  /* over 0 */ a[2] = a[0];
  /* swap 1 */ a[3] = a[1]; a[1] = a[2]; a[2] = a[3];
  t = IsectMapCmd_VV(a+1);
  t = RemapCmd_Vi(a);
  return IT_view;
}

/* : namecol ( V-V ) meta 0 onecol ; */
ItemTypes NameColCmd_V (Item_p a) {
  ItemTypes t;
  t = MetaCmd_V(a);
  a[1].i = 0;
  t = OneColCmd_VN(a);
  return IT_view;
}

/* : names ( V-C ) meta 0 getcol ; */
ItemTypes NamesCmd_V (Item_p a) {
  ItemTypes t;
  t = MetaCmd_V(a);
  a[1].i = 0;
  t = GetColCmd_VN(a);
  return IT_column;
}

/* : product ( VV-V ) over over size spread rrot swap size repeat pair ; */
ItemTypes ProductCmd_VV (Item_p a) {
  ItemTypes t;
  /* over 0 */ a[2] = a[0];
  /* over 1 */ a[3] = a[1];
  t = SizeCmd_V(a+3);
  t = SpreadCmd_VI(a+2);
  /* rrot 0 */ a[3] = a[2]; a[2] = a[1]; a[1] = a[0]; a[0] = a[3];
  /* swap 1 */ a[3] = a[1]; a[1] = a[2]; a[2] = a[3];
  t = SizeCmd_V(a+2);
  t = RepeatCmd_VI(a+1);
  t = PairCmd_VV(a);
  return IT_view;
}

/* : remap ( Vi-V ) 0 -1 remapsub ; */
ItemTypes RemapCmd_Vi (Item_p a) {
  ItemTypes t;
  a[2].i = 0;
  a[3].i = -1;
  t = RemapSubCmd_ViII(a);
  return IT_view;
}

/* : repeat ( VI-V ) over size imul 0 1 1 step ; */
ItemTypes RepeatCmd_VI (Item_p a) {
  ItemTypes t;
  /* over 0 */ a[2] = a[0];
  t = SizeCmd_V(a+2);
  /* imul 1 */ a[1].i *=  a[2].i;
  a[2].i = 0;
  a[3].i = 1;
  a[4].i = 1;
  t = StepCmd_VIIII(a);
  return IT_view;
}

/* : reverse ( V-V ) dup size -1 1 -1 step ; */
ItemTypes ReverseCmd_V (Item_p a) {
  ItemTypes t;
  /* dup 0 */ a[1] = a[0];
  t = SizeCmd_V(a+1);
  a[2].i = -1;
  a[3].i = 1;
  a[4].i = -1;
  t = StepCmd_VIIII(a);
  return IT_view;
}

/* : slice ( VIII-V ) rrot 1 swap step ; */
ItemTypes SliceCmd_VIII (Item_p a) {
  ItemTypes t;
  /* rrot 1 */ a[4] = a[3]; a[3] = a[2]; a[2] = a[1]; a[1] = a[4];
  a[4].i = 1;
  /* swap 3 */ a[5] = a[3]; a[3] = a[4]; a[4] = a[5];
  t = StepCmd_VIIII(a);
  return IT_view;
}

/* : sort ( V-V ) dup sortmap remap ; */
ItemTypes SortCmd_V (Item_p a) {
  ItemTypes t;
  /* dup 0 */ a[1] = a[0];
  t = SortMapCmd_V(a+1);
  t = RemapCmd_Vi(a);
  return IT_view;
}

/* : spread ( VI-V ) over size 0 rot 1 step ; */
ItemTypes SpreadCmd_VI (Item_p a) {
  ItemTypes t;
  /* over 0 */ a[2] = a[0];
  t = SizeCmd_V(a+2);
  a[3].i = 0;
  /* rot 1 */ a[4] = a[1]; a[1] = a[2]; a[2] = a[3]; a[3] = a[4];
  a[4].i = 1;
  t = StepCmd_VIIII(a);
  return IT_view;
}

/* : types ( V-C ) meta 1 getcol ; */
ItemTypes TypesCmd_V (Item_p a) {
  ItemTypes t;
  t = MetaCmd_V(a);
  a[1].i = 1;
  t = GetColCmd_VN(a);
  return IT_column;
}

/* : union ( VV-V ) over except concat ; */
ItemTypes UnionCmd_VV (Item_p a) {
  ItemTypes t;
  /* over 0 */ a[2] = a[0];
  t = ExceptCmd_VV(a+1);
  t = ConcatCmd_VV(a);
  return IT_view;
}

/* : unionmap ( VV-C ) swap exceptmap ; */
ItemTypes UnionMapCmd_VV (Item_p a) {
  ItemTypes t;
  /* swap 0 */ a[2] = a[0]; a[0] = a[1]; a[1] = a[2];
  t = ExceptMapCmd_VV(a);
  return IT_column;
}

/* : unique ( V-V ) dup uniquemap remap ; */
ItemTypes UniqueCmd_V (Item_p a) {
  ItemTypes t;
  /* dup 0 */ a[1] = a[0];
  t = UniqueMapCmd_V(a+1);
  t = RemapCmd_Vi(a);
  return IT_view;
}

/* : viewconv ( V-V )   ; */
ItemTypes ViewConvCmd_V (Item_p a) {
  return IT_view;
}

/* end of generated code */
vqcore/src/wrap_gen.h0000644000076500007650000001216010574360066014530 0ustar  jcwjcw00000000000000/* wrap_gen.h - generated code, do not edit */

View_p (BlockedView) (View_p);
View_p (CloneView) (View_p);
Column (CoerceCmd) (Object_p, const char*);
View_p (ColMapView) (View_p, Column);
View_p (ColOmitView) (View_p, Column);
View_p (ConcatView) (View_p, View_p);
View_p (DescToMeta) (const char*);
View_p (FirstView) (View_p, int);
Column (GetHashInfo) (View_p, View_p, int);
View_p (GroupCol) (View_p, Column, const char*);
View_p (GroupedView) (View_p, Column, Column, const char*);
int    (HashDoFind) (View_p, int, View_p, Column, Column, Column);
Column (HashValues) (View_p);
View_p (IjoinView) (View_p, View_p);
Column (IntersectMap) (View_p, View_p);
View_p (JoinView) (View_p, View_p, const char*);
View_p (LastView) (View_p, int);
Column (NewCountsColumn) (Column);
Column (NewIotaColumn) (int);
View_p (NoColumnView) (int);
View_p (ObjAsMetaView) (Object_p);
Column (OmitColumn) (Column, int);
View_p (OneColView) (View_p, int);
View_p (PairView) (View_p, View_p);
View_p (RemapSubview) (View_p, Column, int, int);
int    (RowCompare) (View_p, int, View_p, int);
int    (RowEqual) (View_p, int, View_p, int);
int    (RowHash) (View_p, int);
Column (SortMap) (View_p);
View_p (StepView) (View_p, int, int, int, int);
int    (StringLookup) (const char*, Column);
View_p (TagView) (View_p, const char*);
View_p (TakeView) (View_p, int);
View_p (UngroupView) (View_p, int);
Column (UniqMap) (View_p);
View_p (V_Meta) (View_p);
Column (ViewAsCol) (View_p);
Column (ViewCol) (View_p, int);
int    (ViewCompare) (View_p, View_p);
int    (ViewCompat) (View_p, View_p);
View_p (ViewReplace) (View_p, int, int, View_p);
int    (ViewSize) (View_p);
int    (ViewWidth) (View_p);

ItemTypes (AppendCmd_VV) (Item_p a);
ItemTypes (AtCmd_VIO) (Item_p a);
ItemTypes (AtRowCmd_OI) (Item_p a);
ItemTypes (BitRunsCmd_i) (Item_p a);
ItemTypes (BlockedCmd_V) (Item_p a);
ItemTypes (CloneCmd_V) (Item_p a);
ItemTypes (CoerceCmd_OS) (Item_p a);
ItemTypes (ColConvCmd_C) (Item_p a);
ItemTypes (ColMapCmd_Vn) (Item_p a);
ItemTypes (ColOmitCmd_Vn) (Item_p a);
ItemTypes (CompareCmd_VV) (Item_p a);
ItemTypes (CompatCmd_VV) (Item_p a);
ItemTypes (ConcatCmd_VV) (Item_p a);
ItemTypes (CountsCmd_VN) (Item_p a);
ItemTypes (CountsColCmd_C) (Item_p a);
ItemTypes (CountViewCmd_I) (Item_p a);
ItemTypes (DataCmd_VX) (Item_p a);
ItemTypes (DebugCmd_I) (Item_p a);
ItemTypes (DefCmd_OO) (Item_p a);
ItemTypes (DeleteCmd_VII) (Item_p a);
ItemTypes (DepsCmd_O) (Item_p a);
ItemTypes (EmitCmd_V) (Item_p a);
ItemTypes (EmitModsCmd_V) (Item_p a);
ItemTypes (ExceptCmd_VV) (Item_p a);
ItemTypes (ExceptMapCmd_VV) (Item_p a);
ItemTypes (FirstCmd_VI) (Item_p a);
ItemTypes (GetCmd_VX) (Item_p a);
ItemTypes (GetColCmd_VN) (Item_p a);
ItemTypes (GetInfoCmd_VVI) (Item_p a);
ItemTypes (GroupCmd_VnS) (Item_p a);
ItemTypes (GroupedCmd_ViiS) (Item_p a);
ItemTypes (HashColCmd_SO) (Item_p a);
ItemTypes (HashFindCmd_VIViii) (Item_p a);
ItemTypes (HashViewCmd_V) (Item_p a);
ItemTypes (IjoinCmd_VV) (Item_p a);
ItemTypes (InsertCmd_VIV) (Item_p a);
ItemTypes (IntersectCmd_VV) (Item_p a);
ItemTypes (IotaCmd_I) (Item_p a);
ItemTypes (IsectMapCmd_VV) (Item_p a);
ItemTypes (JoinCmd_VVS) (Item_p a);
ItemTypes (LastCmd_VI) (Item_p a);
ItemTypes (LoadCmd_O) (Item_p a);
ItemTypes (LoadModsCmd_OV) (Item_p a);
ItemTypes (LoopCmd_X) (Item_p a);
ItemTypes (MaxCmd_VN) (Item_p a);
ItemTypes (MdefCmd_O) (Item_p a);
ItemTypes (MdescCmd_S) (Item_p a);
ItemTypes (MetaCmd_V) (Item_p a);
ItemTypes (MinCmd_VN) (Item_p a);
ItemTypes (MutInfoCmd_V) (Item_p a);
ItemTypes (NameColCmd_V) (Item_p a);
ItemTypes (NamesCmd_V) (Item_p a);
ItemTypes (OmitMapCmd_iI) (Item_p a);
ItemTypes (OneColCmd_VN) (Item_p a);
ItemTypes (OpenCmd_S) (Item_p a);
ItemTypes (PairCmd_VV) (Item_p a);
ItemTypes (ProductCmd_VV) (Item_p a);
ItemTypes (RefCmd_OX) (Item_p a);
ItemTypes (RefsCmd_O) (Item_p a);
ItemTypes (RemapCmd_Vi) (Item_p a);
ItemTypes (RemapSubCmd_ViII) (Item_p a);
ItemTypes (RenameCmd_VO) (Item_p a);
ItemTypes (RepeatCmd_VI) (Item_p a);
ItemTypes (ReplaceCmd_VIIV) (Item_p a);
ItemTypes (ResizeColCmd_iII) (Item_p a);
ItemTypes (ReverseCmd_V) (Item_p a);
ItemTypes (RowCmpCmd_VIVI) (Item_p a);
ItemTypes (RowEqCmd_VIVI) (Item_p a);
ItemTypes (RowHashCmd_VI) (Item_p a);
ItemTypes (SaveCmd_VS) (Item_p a);
ItemTypes (SetCmd_MIX) (Item_p a);
ItemTypes (SizeCmd_V) (Item_p a);
ItemTypes (SliceCmd_VIII) (Item_p a);
ItemTypes (SortCmd_V) (Item_p a);
ItemTypes (SortMapCmd_V) (Item_p a);
ItemTypes (SpreadCmd_VI) (Item_p a);
ItemTypes (StepCmd_VIIII) (Item_p a);
ItemTypes (StrLookupCmd_Ss) (Item_p a);
ItemTypes (StructDescCmd_V) (Item_p a);
ItemTypes (StructureCmd_V) (Item_p a);
ItemTypes (SumCmd_VN) (Item_p a);
ItemTypes (TagCmd_VS) (Item_p a);
ItemTypes (TakeCmd_VI) (Item_p a);
ItemTypes (ToCmd_OO) (Item_p a);
ItemTypes (TypeCmd_O) (Item_p a);
ItemTypes (TypesCmd_V) (Item_p a);
ItemTypes (UngroupCmd_VN) (Item_p a);
ItemTypes (UnionCmd_VV) (Item_p a);
ItemTypes (UnionMapCmd_VV) (Item_p a);
ItemTypes (UniqueCmd_V) (Item_p a);
ItemTypes (UniqueMapCmd_V) (Item_p a);
ItemTypes (ViewCmd_X) (Item_p a);
ItemTypes (ViewAsColCmd_V) (Item_p a);
ItemTypes (ViewConvCmd_V) (Item_p a);
ItemTypes (WidthCmd_V) (Item_p a);
ItemTypes (WriteCmd_VO) (Item_p a);

/* end of generated code */
vqcore/src_lua/0000755000076500007650000000000010575021060013403 5ustar  jcwjcw00000000000000vqcore/src_lua/defs.h0000644000076500007650000000014310575021060014473 0ustar  jcwjcw00000000000000/*
 * defs.h - Binding-specific definitions needed by the general code.
 */

typedef int Object_p;
vqcore/src_lua/vlerq_ext.h0000644000076500007650000002047210575021060015572 0ustar  jcwjcw00000000000000/* vlerq_ext.h - generated code, do not edit */

/* 78 definitions generated for Lua:

  # name       in     out    inline-code
  : drop       U      {}     {}
  : dup        U      UU     {$1 = $0;}
  : imul       II     I      {$0.i *=  $1.i;}
  : nip        UU     U      {$0 = $1;}
  : over       UU     UUU    {$2 = $0;}
  : rot        UUU    UUU    {$3 = $0; $0 = $1; $1 = $2; $2 = $3;}
  : rrot       UUU    UUU    {$3 = $2; $2 = $1; $1 = $0; $0 = $3;}
  : swap       UU     UU     {$2 = $0; $0 = $1; $1 = $2;}
  : tuck       UU     UUU    {$1 = $2; $0 = $1; $2 = $0;}
  
  tcl {
    # name       in    out
    : Def        OO     V
    : Deps       O      O
    : Emit       V      O
    : EmitMods   V      O
    : Get        VX     U
    : Load       O      V
    : LoadMods   OV     V
    : Loop       X      O
    : MutInfo    V      O
    : Ref        OX     O
    : Refs       O      I
    : Rename     VO     V
    : Save       VS     I
    : To         OO     O
    : Type       O      O
    : View       X      O
  }
  
  python {
    # name       in    out
  }
  
  ruby {
    # name       in    out
    : AtRow      OI     O
  }
  
  lua {
    # name       in    out
  }
  
  objc {
    # name       in    out
    : At         VIO    O
  }
  
  # name       in    out
  : BitRuns    i      C
  : Data       VX     V
  : Debug      I      I
  : HashCol    SO     C
  : Max        VN     O
  : Min        VN     O
  : Open       S      V
  : ResizeCol  iII    C
  : Set        MIX    V
  : StructDesc V      S
  : Structure  V      S
  : Sum        VN     O
  : Write      VO     I

  # name       in    out  internal-name
  : Blocked    V      V   BlockedView
  : Clone      V      V   CloneView
  : ColMap     Vn     V   ColMapView
  : ColOmit    Vn     V   ColOmitView
  : Coerce     OS     C   CoerceCmd
  : Compare    VV     I   ViewCompare
  : Compat     VV     I   ViewCompat
  : Concat     VV     V   ConcatView
  : CountsCol  C      C   NewCountsColumn
  : CountView  I      V   NoColumnView
  : First      VI     V   FirstView
  : GetCol     VN     C   ViewCol
  : Group      VnS    V   GroupCol
  : HashFind   VIViii I   HashDoFind
  : Ijoin      VV     V   IjoinView
  : GetInfo    VVI    C   GetHashInfo
  : Grouped    ViiS   V   GroupedView
  : HashView   V      C   HashValues
  : IsectMap   VV     C   IntersectMap
  : Iota       I      C   NewIotaColumn
  : Join       VVS    V   JoinView
  : Last       VI     V   LastView
  : Mdef       O      V   ObjAsMetaView
  : Mdesc      S      V   DescToMeta
  : Meta       V      V   V_Meta
  : OmitMap    iI     C   OmitColumn
  : OneCol     VN     V   OneColView
  : Pair       VV     V   PairView
  : RemapSub   ViII   V   RemapSubview
  : Replace    VIIV   V   ViewReplace
  : RowCmp     VIVI   I   RowCompare
  : RowEq      VIVI   I   RowEqual
  : RowHash    VI     I   RowHash
  : Size       V      I   ViewSize
  : SortMap    V      C   SortMap
  : Step       VIIII  V   StepView
  : StrLookup  Ss     I   StringLookup
  : Tag        VS     V   TagView
  : Take       VI     V   TakeView
  : Ungroup    VN     V   UngroupView
  : UniqueMap  V      C   UniqMap
  : ViewAsCol  V      C   ViewAsCol
  : Width      V      I   ViewWidth
               
  # name       in    out  compound-definition
  : Append     VV     V   {over size swap insert}
  : ColConv    C      C   { }
  : Counts     VN     C   {getcol countscol}
  : Delete     VII    V   {0 countview replace}
  : Except     VV     V   {over swap exceptmap remap}
  : ExceptMap  VV     C   {over swap isectmap swap size omitmap}
  : Insert     VIV    V   {0 swap replace}
  : Intersect  VV     V   {over swap isectmap remap}
  : NameCol    V      V   {meta 0 onecol}
  : Names      V      C   {meta 0 getcol}
  : Product    VV     V   {over over size spread rrot swap size repeat pair}
  : Repeat     VI     V   {over size imul 0 1 1 step}
  : Remap      Vi     V   {0 -1 remapsub}
  : Reverse    V      V   {dup size -1 1 -1 step}
  : Slice      VIII   V   {rrot 1 swap step}
  : Sort       V      V   {dup sortmap remap}
  : Spread     VI     V   {over size 0 rot 1 step}
  : Types      V      C   {meta 1 getcol}
  : Unique     V      V   {dup uniquemap remap}
  : Union      VV     V   {over except concat}
  : UnionMap   VV     C   {swap exceptmap}
  : ViewConv   V      V   { }
  
  # some operators are omitted from restricted execution environments
  unsafe Open Save
*/

  { "append",     "V:VV",     AppendCmd_VV       },
  { "bitruns",    "C:i",      BitRunsCmd_i       },
  { "blocked",    "V:V",      BlockedCmd_V       },
  { "clone",      "V:V",      CloneCmd_V         },
  { "coerce",     "C:OS",     CoerceCmd_OS       },
  { "colconv",    "C:C",      ColConvCmd_C       },
  { "colmap",     "V:Vn",     ColMapCmd_Vn       },
  { "colomit",    "V:Vn",     ColOmitCmd_Vn      },
  { "compare",    "I:VV",     CompareCmd_VV      },
  { "compat",     "I:VV",     CompatCmd_VV       },
  { "concat",     "V:VV",     ConcatCmd_VV       },
  { "counts",     "C:VN",     CountsCmd_VN       },
  { "countscol",  "C:C",      CountsColCmd_C     },
  { "countview",  "V:I",      CountViewCmd_I     },
  { "data",       "V:VX",     DataCmd_VX         },
  { "debug",      "I:I",      DebugCmd_I         },
  { "delete",     "V:VII",    DeleteCmd_VII      },
  { "except",     "V:VV",     ExceptCmd_VV       },
  { "exceptmap",  "C:VV",     ExceptMapCmd_VV    },
  { "first",      "V:VI",     FirstCmd_VI        },
  { "getcol",     "C:VN",     GetColCmd_VN       },
  { "getinfo",    "C:VVI",    GetInfoCmd_VVI     },
  { "group",      "V:VnS",    GroupCmd_VnS       },
  { "grouped",    "V:ViiS",   GroupedCmd_ViiS    },
  { "hashcol",    "C:SO",     HashColCmd_SO      },
  { "hashfind",   "I:VIViii", HashFindCmd_VIViii },
  { "hashview",   "C:V",      HashViewCmd_V      },
  { "ijoin",      "V:VV",     IjoinCmd_VV        },
  { "insert",     "V:VIV",    InsertCmd_VIV      },
  { "intersect",  "V:VV",     IntersectCmd_VV    },
  { "iota",       "C:I",      IotaCmd_I          },
  { "isectmap",   "C:VV",     IsectMapCmd_VV     },
  { "join",       "V:VVS",    JoinCmd_VVS        },
  { "last",       "V:VI",     LastCmd_VI         },
  { "max",        "O:VN",     MaxCmd_VN          },
  { "mdef",       "V:O",      MdefCmd_O          },
  { "mdesc",      "V:S",      MdescCmd_S         },
  { "meta",       "V:V",      MetaCmd_V          },
  { "min",        "O:VN",     MinCmd_VN          },
  { "namecol",    "V:V",      NameColCmd_V       },
  { "names",      "C:V",      NamesCmd_V         },
  { "omitmap",    "C:iI",     OmitMapCmd_iI      },
  { "onecol",     "V:VN",     OneColCmd_VN       },
  { "open",       "V:S",      OpenCmd_S          },
  { "pair",       "V:VV",     PairCmd_VV         },
  { "product",    "V:VV",     ProductCmd_VV      },
  { "remap",      "V:Vi",     RemapCmd_Vi        },
  { "remapsub",   "V:ViII",   RemapSubCmd_ViII   },
  { "repeat",     "V:VI",     RepeatCmd_VI       },
  { "replace",    "V:VIIV",   ReplaceCmd_VIIV    },
  { "resizecol",  "C:iII",    ResizeColCmd_iII   },
  { "reverse",    "V:V",      ReverseCmd_V       },
  { "rowcmp",     "I:VIVI",   RowCmpCmd_VIVI     },
  { "roweq",      "I:VIVI",   RowEqCmd_VIVI      },
  { "rowhash",    "I:VI",     RowHashCmd_VI      },
  { "set",        "V:MIX",    SetCmd_MIX         },
  { "size",       "I:V",      SizeCmd_V          },
  { "slice",      "V:VIII",   SliceCmd_VIII      },
  { "sort",       "V:V",      SortCmd_V          },
  { "sortmap",    "C:V",      SortMapCmd_V       },
  { "spread",     "V:VI",     SpreadCmd_VI       },
  { "step",       "V:VIIII",  StepCmd_VIIII      },
  { "strlookup",  "I:Ss",     StrLookupCmd_Ss    },
  { "structdesc", "S:V",      StructDescCmd_V    },
  { "structure",  "S:V",      StructureCmd_V     },
  { "sum",        "O:VN",     SumCmd_VN          },
  { "tag",        "V:VS",     TagCmd_VS          },
  { "take",       "V:VI",     TakeCmd_VI         },
  { "types",      "C:V",      TypesCmd_V         },
  { "ungroup",    "V:VN",     UngroupCmd_VN      },
  { "union",      "V:VV",     UnionCmd_VV        },
  { "unionmap",   "C:VV",     UnionMapCmd_VV     },
  { "unique",     "V:V",      UniqueCmd_V        },
  { "uniquemap",  "C:V",      UniqueMapCmd_V     },
  { "viewascol",  "C:V",      ViewAsColCmd_V     },
  { "viewconv",   "V:V",      ViewConvCmd_V      },
  { "width",      "I:V",      WidthCmd_V         },
  { "write",      "I:VO",     WriteCmd_VO        },

/* end of generated code */
vqcore/src_objc/0000755000076500007650000000000010575021060013537 5ustar  jcwjcw00000000000000vqcore/src_objc/defs.h0000644000076500007650000000016310575021060014631 0ustar  jcwjcw00000000000000/*
 * defs.h - Binding-specific definitions needed by the general code.
 */

typedef struct objc_object *Object_p;
vqcore/src_objc/vlerq_ext.h0000644000076500007650000002056610575021060015732 0ustar  jcwjcw00000000000000/* vlerq_ext.h - generated code, do not edit */

/* 79 definitions generated for Objective-C:

  # name       in     out    inline-code
  : drop       U      {}     {}
  : dup        U      UU     {$1 = $0;}
  : imul       II     I      {$0.i *=  $1.i;}
  : nip        UU     U      {$0 = $1;}
  : over       UU     UUU    {$2 = $0;}
  : rot        UUU    UUU    {$3 = $0; $0 = $1; $1 = $2; $2 = $3;}
  : rrot       UUU    UUU    {$3 = $2; $2 = $1; $1 = $0; $0 = $3;}
  : swap       UU     UU     {$2 = $0; $0 = $1; $1 = $2;}
  : tuck       UU     UUU    {$1 = $2; $0 = $1; $2 = $0;}
  
  tcl {
    # name       in    out
    : Def        OO     V
    : Deps       O      O
    : Emit       V      O
    : EmitMods   V      O
    : Get        VX     U
    : Load       O      V
    : LoadMods   OV     V
    : Loop       X      O
    : MutInfo    V      O
    : Ref        OX     O
    : Refs       O      I
    : Rename     VO     V
    : Save       VS     I
    : To         OO     O
    : Type       O      O
    : View       X      O
  }
  
  python {
    # name       in    out
  }
  
  ruby {
    # name       in    out
    : AtRow      OI     O
  }
  
  lua {
    # name       in    out
  }
  
  objc {
    # name       in    out
    : At         VIO    O
  }
  
  # name       in    out
  : BitRuns    i      C
  : Data       VX     V
  : Debug      I      I
  : HashCol    SO     C
  : Max        VN     O
  : Min        VN     O
  : Open       S      V
  : ResizeCol  iII    C
  : Set        MIX    V
  : StructDesc V      S
  : Structure  V      S
  : Sum        VN     O
  : Write      VO     I

  # name       in    out  internal-name
  : Blocked    V      V   BlockedView
  : Clone      V      V   CloneView
  : ColMap     Vn     V   ColMapView
  : ColOmit    Vn     V   ColOmitView
  : Coerce     OS     C   CoerceCmd
  : Compare    VV     I   ViewCompare
  : Compat     VV     I   ViewCompat
  : Concat     VV     V   ConcatView
  : CountsCol  C      C   NewCountsColumn
  : CountView  I      V   NoColumnView
  : First      VI     V   FirstView
  : GetCol     VN     C   ViewCol
  : Group      VnS    V   GroupCol
  : HashFind   VIViii I   HashDoFind
  : Ijoin      VV     V   IjoinView
  : GetInfo    VVI    C   GetHashInfo
  : Grouped    ViiS   V   GroupedView
  : HashView   V      C   HashValues
  : IsectMap   VV     C   IntersectMap
  : Iota       I      C   NewIotaColumn
  : Join       VVS    V   JoinView
  : Last       VI     V   LastView
  : Mdef       O      V   ObjAsMetaView
  : Mdesc      S      V   DescToMeta
  : Meta       V      V   V_Meta
  : OmitMap    iI     C   OmitColumn
  : OneCol     VN     V   OneColView
  : Pair       VV     V   PairView
  : RemapSub   ViII   V   RemapSubview
  : Replace    VIIV   V   ViewReplace
  : RowCmp     VIVI   I   RowCompare
  : RowEq      VIVI   I   RowEqual
  : RowHash    VI     I   RowHash
  : Size       V      I   ViewSize
  : SortMap    V      C   SortMap
  : Step       VIIII  V   StepView
  : StrLookup  Ss     I   StringLookup
  : Tag        VS     V   TagView
  : Take       VI     V   TakeView
  : Ungroup    VN     V   UngroupView
  : UniqueMap  V      C   UniqMap
  : ViewAsCol  V      C   ViewAsCol
  : Width      V      I   ViewWidth
               
  # name       in    out  compound-definition
  : Append     VV     V   {over size swap insert}
  : ColConv    C      C   { }
  : Counts     VN     C   {getcol countscol}
  : Delete     VII    V   {0 countview replace}
  : Except     VV     V   {over swap exceptmap remap}
  : ExceptMap  VV     C   {over swap isectmap swap size omitmap}
  : Insert     VIV    V   {0 swap replace}
  : Intersect  VV     V   {over swap isectmap remap}
  : NameCol    V      V   {meta 0 onecol}
  : Names      V      C   {meta 0 getcol}
  : Product    VV     V   {over over size spread rrot swap size repeat pair}
  : Repeat     VI     V   {over size imul 0 1 1 step}
  : Remap      Vi     V   {0 -1 remapsub}
  : Reverse    V      V   {dup size -1 1 -1 step}
  : Slice      VIII   V   {rrot 1 swap step}
  : Sort       V      V   {dup sortmap remap}
  : Spread     VI     V   {over size 0 rot 1 step}
  : Types      V      C   {meta 1 getcol}
  : Unique     V      V   {dup uniquemap remap}
  : Union      VV     V   {over except concat}
  : UnionMap   VV     C   {swap exceptmap}
  : ViewConv   V      V   { }
  
  # some operators are omitted from restricted execution environments
  unsafe Open Save
*/

  { "append",     "V:VV",     AppendCmd_VV       },
  { "at",         "O:VIO",    AtCmd_VIO          },
  { "bitruns",    "C:i",      BitRunsCmd_i       },
  { "blocked",    "V:V",      BlockedCmd_V       },
  { "clone",      "V:V",      CloneCmd_V         },
  { "coerce",     "C:OS",     CoerceCmd_OS       },
  { "colconv",    "C:C",      ColConvCmd_C       },
  { "colmap",     "V:Vn",     ColMapCmd_Vn       },
  { "colomit",    "V:Vn",     ColOmitCmd_Vn      },
  { "compare",    "I:VV",     CompareCmd_VV      },
  { "compat",     "I:VV",     CompatCmd_VV       },
  { "concat",     "V:VV",     ConcatCmd_VV       },
  { "counts",     "C:VN",     CountsCmd_VN       },
  { "countscol",  "C:C",      CountsColCmd_C     },
  { "countview",  "V:I",      CountViewCmd_I     },
  { "data",       "V:VX",     DataCmd_VX         },
  { "debug",      "I:I",      DebugCmd_I         },
  { "delete",     "V:VII",    DeleteCmd_VII      },
  { "except",     "V:VV",     ExceptCmd_VV       },
  { "exceptmap",  "C:VV",     ExceptMapCmd_VV    },
  { "first",      "V:VI",     FirstCmd_VI        },
  { "getcol",     "C:VN",     GetColCmd_VN       },
  { "getinfo",    "C:VVI",    GetInfoCmd_VVI     },
  { "group",      "V:VnS",    GroupCmd_VnS       },
  { "grouped",    "V:ViiS",   GroupedCmd_ViiS    },
  { "hashcol",    "C:SO",     HashColCmd_SO      },
  { "hashfind",   "I:VIViii", HashFindCmd_VIViii },
  { "hashview",   "C:V",      HashViewCmd_V      },
  { "ijoin",      "V:VV",     IjoinCmd_VV        },
  { "insert",     "V:VIV",    InsertCmd_VIV      },
  { "intersect",  "V:VV",     IntersectCmd_VV    },
  { "iota",       "C:I",      IotaCmd_I          },
  { "isectmap",   "C:VV",     IsectMapCmd_VV     },
  { "join",       "V:VVS",    JoinCmd_VVS        },
  { "last",       "V:VI",     LastCmd_VI         },
  { "max",        "O:VN",     MaxCmd_VN          },
  { "mdef",       "V:O",      MdefCmd_O          },
  { "mdesc",      "V:S",      MdescCmd_S         },
  { "meta",       "V:V",      MetaCmd_V          },
  { "min",        "O:VN",     MinCmd_VN          },
  { "namecol",    "V:V",      NameColCmd_V       },
  { "names",      "C:V",      NamesCmd_V         },
  { "omitmap",    "C:iI",     OmitMapCmd_iI      },
  { "onecol",     "V:VN",     OneColCmd_VN       },
  { "open",       "V:S",      OpenCmd_S          },
  { "pair",       "V:VV",     PairCmd_VV         },
  { "product",    "V:VV",     ProductCmd_VV      },
  { "remap",      "V:Vi",     RemapCmd_Vi        },
  { "remapsub",   "V:ViII",   RemapSubCmd_ViII   },
  { "repeat",     "V:VI",     RepeatCmd_VI       },
  { "replace",    "V:VIIV",   ReplaceCmd_VIIV    },
  { "resizecol",  "C:iII",    ResizeColCmd_iII   },
  { "reverse",    "V:V",      ReverseCmd_V       },
  { "rowcmp",     "I:VIVI",   RowCmpCmd_VIVI     },
  { "roweq",      "I:VIVI",   RowEqCmd_VIVI      },
  { "rowhash",    "I:VI",     RowHashCmd_VI      },
  { "set",        "V:MIX",    SetCmd_MIX         },
  { "size",       "I:V",      SizeCmd_V          },
  { "slice",      "V:VIII",   SliceCmd_VIII      },
  { "sort",       "V:V",      SortCmd_V          },
  { "sortmap",    "C:V",      SortMapCmd_V       },
  { "spread",     "V:VI",     SpreadCmd_VI       },
  { "step",       "V:VIIII",  StepCmd_VIIII      },
  { "strlookup",  "I:Ss",     StrLookupCmd_Ss    },
  { "structdesc", "S:V",      StructDescCmd_V    },
  { "structure",  "S:V",      StructureCmd_V     },
  { "sum",        "O:VN",     SumCmd_VN          },
  { "tag",        "V:VS",     TagCmd_VS          },
  { "take",       "V:VI",     TakeCmd_VI         },
  { "types",      "C:V",      TypesCmd_V         },
  { "ungroup",    "V:VN",     UngroupCmd_VN      },
  { "union",      "V:VV",     UnionCmd_VV        },
  { "unionmap",   "C:VV",     UnionMapCmd_VV     },
  { "unique",     "V:V",      UniqueCmd_V        },
  { "uniquemap",  "C:V",      UniqueMapCmd_V     },
  { "viewascol",  "C:V",      ViewAsColCmd_V     },
  { "viewconv",   "V:V",      ViewConvCmd_V      },
  { "width",      "I:V",      WidthCmd_V         },
  { "write",      "I:VO",     WriteCmd_VO        },

/* end of generated code */
vqcore/src_python/0000755000076500007650000000000010575021060014143 5ustar  jcwjcw00000000000000vqcore/src_python/defs.h0000644000076500007650000000015710575021060015240 0ustar  jcwjcw00000000000000/*
 * defs.h - Binding-specific definitions needed by the general code.
 */

typedef struct _object *Object_p;
vqcore/src_python/vlerq_ext.h0000644000076500007650000002047510575021060016335 0ustar  jcwjcw00000000000000/* vlerq_ext.h - generated code, do not edit */

/* 78 definitions generated for Python:

  # name       in     out    inline-code
  : drop       U      {}     {}
  : dup        U      UU     {$1 = $0;}
  : imul       II     I      {$0.i *=  $1.i;}
  : nip        UU     U      {$0 = $1;}
  : over       UU     UUU    {$2 = $0;}
  : rot        UUU    UUU    {$3 = $0; $0 = $1; $1 = $2; $2 = $3;}
  : rrot       UUU    UUU    {$3 = $2; $2 = $1; $1 = $0; $0 = $3;}
  : swap       UU     UU     {$2 = $0; $0 = $1; $1 = $2;}
  : tuck       UU     UUU    {$1 = $2; $0 = $1; $2 = $0;}
  
  tcl {
    # name       in    out
    : Def        OO     V
    : Deps       O      O
    : Emit       V      O
    : EmitMods   V      O
    : Get        VX     U
    : Load       O      V
    : LoadMods   OV     V
    : Loop       X      O
    : MutInfo    V      O
    : Ref        OX     O
    : Refs       O      I
    : Rename     VO     V
    : Save       VS     I
    : To         OO     O
    : Type       O      O
    : View       X      O
  }
  
  python {
    # name       in    out
  }
  
  ruby {
    # name       in    out
    : AtRow      OI     O
  }
  
  lua {
    # name       in    out
  }
  
  objc {
    # name       in    out
    : At         VIO    O
  }
  
  # name       in    out
  : BitRuns    i      C
  : Data       VX     V
  : Debug      I      I
  : HashCol    SO     C
  : Max        VN     O
  : Min        VN     O
  : Open       S      V
  : ResizeCol  iII    C
  : Set        MIX    V
  : StructDesc V      S
  : Structure  V      S
  : Sum        VN     O
  : Write      VO     I

  # name       in    out  internal-name
  : Blocked    V      V   BlockedView
  : Clone      V      V   CloneView
  : ColMap     Vn     V   ColMapView
  : ColOmit    Vn     V   ColOmitView
  : Coerce     OS     C   CoerceCmd
  : Compare    VV     I   ViewCompare
  : Compat     VV     I   ViewCompat
  : Concat     VV     V   ConcatView
  : CountsCol  C      C   NewCountsColumn
  : CountView  I      V   NoColumnView
  : First      VI     V   FirstView
  : GetCol     VN     C   ViewCol
  : Group      VnS    V   GroupCol
  : HashFind   VIViii I   HashDoFind
  : Ijoin      VV     V   IjoinView
  : GetInfo    VVI    C   GetHashInfo
  : Grouped    ViiS   V   GroupedView
  : HashView   V      C   HashValues
  : IsectMap   VV     C   IntersectMap
  : Iota       I      C   NewIotaColumn
  : Join       VVS    V   JoinView
  : Last       VI     V   LastView
  : Mdef       O      V   ObjAsMetaView
  : Mdesc      S      V   DescToMeta
  : Meta       V      V   V_Meta
  : OmitMap    iI     C   OmitColumn
  : OneCol     VN     V   OneColView
  : Pair       VV     V   PairView
  : RemapSub   ViII   V   RemapSubview
  : Replace    VIIV   V   ViewReplace
  : RowCmp     VIVI   I   RowCompare
  : RowEq      VIVI   I   RowEqual
  : RowHash    VI     I   RowHash
  : Size       V      I   ViewSize
  : SortMap    V      C   SortMap
  : Step       VIIII  V   StepView
  : StrLookup  Ss     I   StringLookup
  : Tag        VS     V   TagView
  : Take       VI     V   TakeView
  : Ungroup    VN     V   UngroupView
  : UniqueMap  V      C   UniqMap
  : ViewAsCol  V      C   ViewAsCol
  : Width      V      I   ViewWidth
               
  # name       in    out  compound-definition
  : Append     VV     V   {over size swap insert}
  : ColConv    C      C   { }
  : Counts     VN     C   {getcol countscol}
  : Delete     VII    V   {0 countview replace}
  : Except     VV     V   {over swap exceptmap remap}
  : ExceptMap  VV     C   {over swap isectmap swap size omitmap}
  : Insert     VIV    V   {0 swap replace}
  : Intersect  VV     V   {over swap isectmap remap}
  : NameCol    V      V   {meta 0 onecol}
  : Names      V      C   {meta 0 getcol}
  : Product    VV     V   {over over size spread rrot swap size repeat pair}
  : Repeat     VI     V   {over size imul 0 1 1 step}
  : Remap      Vi     V   {0 -1 remapsub}
  : Reverse    V      V   {dup size -1 1 -1 step}
  : Slice      VIII   V   {rrot 1 swap step}
  : Sort       V      V   {dup sortmap remap}
  : Spread     VI     V   {over size 0 rot 1 step}
  : Types      V      C   {meta 1 getcol}
  : Unique     V      V   {dup uniquemap remap}
  : Union      VV     V   {over except concat}
  : UnionMap   VV     C   {swap exceptmap}
  : ViewConv   V      V   { }
  
  # some operators are omitted from restricted execution environments
  unsafe Open Save
*/

  { "append",     "V:VV",     AppendCmd_VV       },
  { "bitruns",    "C:i",      BitRunsCmd_i       },
  { "blocked",    "V:V",      BlockedCmd_V       },
  { "clone",      "V:V",      CloneCmd_V         },
  { "coerce",     "C:OS",     CoerceCmd_OS       },
  { "colconv",    "C:C",      ColConvCmd_C       },
  { "colmap",     "V:Vn",     ColMapCmd_Vn       },
  { "colomit",    "V:Vn",     ColOmitCmd_Vn      },
  { "compare",    "I:VV",     CompareCmd_VV      },
  { "compat",     "I:VV",     CompatCmd_VV       },
  { "concat",     "V:VV",     ConcatCmd_VV       },
  { "counts",     "C:VN",     CountsCmd_VN       },
  { "countscol",  "C:C",      CountsColCmd_C     },
  { "countview",  "V:I",      CountViewCmd_I     },
  { "data",       "V:VX",     DataCmd_VX         },
  { "debug",      "I:I",      DebugCmd_I         },
  { "delete",     "V:VII",    DeleteCmd_VII      },
  { "except",     "V:VV",     ExceptCmd_VV       },
  { "exceptmap",  "C:VV",     ExceptMapCmd_VV    },
  { "first",      "V:VI",     FirstCmd_VI        },
  { "getcol",     "C:VN",     GetColCmd_VN       },
  { "getinfo",    "C:VVI",    GetInfoCmd_VVI     },
  { "group",      "V:VnS",    GroupCmd_VnS       },
  { "grouped",    "V:ViiS",   GroupedCmd_ViiS    },
  { "hashcol",    "C:SO",     HashColCmd_SO      },
  { "hashfind",   "I:VIViii", HashFindCmd_VIViii },
  { "hashview",   "C:V",      HashViewCmd_V      },
  { "ijoin",      "V:VV",     IjoinCmd_VV        },
  { "insert",     "V:VIV",    InsertCmd_VIV      },
  { "intersect",  "V:VV",     IntersectCmd_VV    },
  { "iota",       "C:I",      IotaCmd_I          },
  { "isectmap",   "C:VV",     IsectMapCmd_VV     },
  { "join",       "V:VVS",    JoinCmd_VVS        },
  { "last",       "V:VI",     LastCmd_VI         },
  { "max",        "O:VN",     MaxCmd_VN          },
  { "mdef",       "V:O",      MdefCmd_O          },
  { "mdesc",      "V:S",      MdescCmd_S         },
  { "meta",       "V:V",      MetaCmd_V          },
  { "min",        "O:VN",     MinCmd_VN          },
  { "namecol",    "V:V",      NameColCmd_V       },
  { "names",      "C:V",      NamesCmd_V         },
  { "omitmap",    "C:iI",     OmitMapCmd_iI      },
  { "onecol",     "V:VN",     OneColCmd_VN       },
  { "open",       "V:S",      OpenCmd_S          },
  { "pair",       "V:VV",     PairCmd_VV         },
  { "product",    "V:VV",     ProductCmd_VV      },
  { "remap",      "V:Vi",     RemapCmd_Vi        },
  { "remapsub",   "V:ViII",   RemapSubCmd_ViII   },
  { "repeat",     "V:VI",     RepeatCmd_VI       },
  { "replace",    "V:VIIV",   ReplaceCmd_VIIV    },
  { "resizecol",  "C:iII",    ResizeColCmd_iII   },
  { "reverse",    "V:V",      ReverseCmd_V       },
  { "rowcmp",     "I:VIVI",   RowCmpCmd_VIVI     },
  { "roweq",      "I:VIVI",   RowEqCmd_VIVI      },
  { "rowhash",    "I:VI",     RowHashCmd_VI      },
  { "set",        "V:MIX",    SetCmd_MIX         },
  { "size",       "I:V",      SizeCmd_V          },
  { "slice",      "V:VIII",   SliceCmd_VIII      },
  { "sort",       "V:V",      SortCmd_V          },
  { "sortmap",    "C:V",      SortMapCmd_V       },
  { "spread",     "V:VI",     SpreadCmd_VI       },
  { "step",       "V:VIIII",  StepCmd_VIIII      },
  { "strlookup",  "I:Ss",     StrLookupCmd_Ss    },
  { "structdesc", "S:V",      StructDescCmd_V    },
  { "structure",  "S:V",      StructureCmd_V     },
  { "sum",        "O:VN",     SumCmd_VN          },
  { "tag",        "V:VS",     TagCmd_VS          },
  { "take",       "V:VI",     TakeCmd_VI         },
  { "types",      "C:V",      TypesCmd_V         },
  { "ungroup",    "V:VN",     UngroupCmd_VN      },
  { "union",      "V:VV",     UnionCmd_VV        },
  { "unionmap",   "C:VV",     UnionMapCmd_VV     },
  { "unique",     "V:V",      UniqueCmd_V        },
  { "uniquemap",  "C:V",      UniqueMapCmd_V     },
  { "viewascol",  "C:V",      ViewAsColCmd_V     },
  { "viewconv",   "V:V",      ViewConvCmd_V      },
  { "width",      "I:V",      WidthCmd_V         },
  { "write",      "I:VO",     WriteCmd_VO        },

/* end of generated code */
vqcore/src_ruby/0000755000076500007650000000000010575021060013603 5ustar  jcwjcw00000000000000vqcore/src_ruby/defs.h0000644000076500007650000000015510575021060014676 0ustar  jcwjcw00000000000000/*
 * defs.h - Binding-specific definitions needed by the general code.
 */

typedef unsigned long Object_p;
vqcore/src_ruby/vlerq_ext.h0000644000076500007650000002055710575021060015776 0ustar  jcwjcw00000000000000/* vlerq_ext.h - generated code, do not edit */

/* 79 definitions generated for Ruby:

  # name       in     out    inline-code
  : drop       U      {}     {}
  : dup        U      UU     {$1 = $0;}
  : imul       II     I      {$0.i *=  $1.i;}
  : nip        UU     U      {$0 = $1;}
  : over       UU     UUU    {$2 = $0;}
  : rot        UUU    UUU    {$3 = $0; $0 = $1; $1 = $2; $2 = $3;}
  : rrot       UUU    UUU    {$3 = $2; $2 = $1; $1 = $0; $0 = $3;}
  : swap       UU     UU     {$2 = $0; $0 = $1; $1 = $2;}
  : tuck       UU     UUU    {$1 = $2; $0 = $1; $2 = $0;}
  
  tcl {
    # name       in    out
    : Def        OO     V
    : Deps       O      O
    : Emit       V      O
    : EmitMods   V      O
    : Get        VX     U
    : Load       O      V
    : LoadMods   OV     V
    : Loop       X      O
    : MutInfo    V      O
    : Ref        OX     O
    : Refs       O      I
    : Rename     VO     V
    : Save       VS     I
    : To         OO     O
    : Type       O      O
    : View       X      O
  }
  
  python {
    # name       in    out
  }
  
  ruby {
    # name       in    out
    : AtRow      OI     O
  }
  
  lua {
    # name       in    out
  }
  
  objc {
    # name       in    out
    : At         VIO    O
  }
  
  # name       in    out
  : BitRuns    i      C
  : Data       VX     V
  : Debug      I      I
  : HashCol    SO     C
  : Max        VN     O
  : Min        VN     O
  : Open       S      V
  : ResizeCol  iII    C
  : Set        MIX    V
  : StructDesc V      S
  : Structure  V      S
  : Sum        VN     O
  : Write      VO     I

  # name       in    out  internal-name
  : Blocked    V      V   BlockedView
  : Clone      V      V   CloneView
  : ColMap     Vn     V   ColMapView
  : ColOmit    Vn     V   ColOmitView
  : Coerce     OS     C   CoerceCmd
  : Compare    VV     I   ViewCompare
  : Compat     VV     I   ViewCompat
  : Concat     VV     V   ConcatView
  : CountsCol  C      C   NewCountsColumn
  : CountView  I      V   NoColumnView
  : First      VI     V   FirstView
  : GetCol     VN     C   ViewCol
  : Group      VnS    V   GroupCol
  : HashFind   VIViii I   HashDoFind
  : Ijoin      VV     V   IjoinView
  : GetInfo    VVI    C   GetHashInfo
  : Grouped    ViiS   V   GroupedView
  : HashView   V      C   HashValues
  : IsectMap   VV     C   IntersectMap
  : Iota       I      C   NewIotaColumn
  : Join       VVS    V   JoinView
  : Last       VI     V   LastView
  : Mdef       O      V   ObjAsMetaView
  : Mdesc      S      V   DescToMeta
  : Meta       V      V   V_Meta
  : OmitMap    iI     C   OmitColumn
  : OneCol     VN     V   OneColView
  : Pair       VV     V   PairView
  : RemapSub   ViII   V   RemapSubview
  : Replace    VIIV   V   ViewReplace
  : RowCmp     VIVI   I   RowCompare
  : RowEq      VIVI   I   RowEqual
  : RowHash    VI     I   RowHash
  : Size       V      I   ViewSize
  : SortMap    V      C   SortMap
  : Step       VIIII  V   StepView
  : StrLookup  Ss     I   StringLookup
  : Tag        VS     V   TagView
  : Take       VI     V   TakeView
  : Ungroup    VN     V   UngroupView
  : UniqueMap  V      C   UniqMap
  : ViewAsCol  V      C   ViewAsCol
  : Width      V      I   ViewWidth
               
  # name       in    out  compound-definition
  : Append     VV     V   {over size swap insert}
  : ColConv    C      C   { }
  : Counts     VN     C   {getcol countscol}
  : Delete     VII    V   {0 countview replace}
  : Except     VV     V   {over swap exceptmap remap}
  : ExceptMap  VV     C   {over swap isectmap swap size omitmap}
  : Insert     VIV    V   {0 swap replace}
  : Intersect  VV     V   {over swap isectmap remap}
  : NameCol    V      V   {meta 0 onecol}
  : Names      V      C   {meta 0 getcol}
  : Product    VV     V   {over over size spread rrot swap size repeat pair}
  : Repeat     VI     V   {over size imul 0 1 1 step}
  : Remap      Vi     V   {0 -1 remapsub}
  : Reverse    V      V   {dup size -1 1 -1 step}
  : Slice      VIII   V   {rrot 1 swap step}
  : Sort       V      V   {dup sortmap remap}
  : Spread     VI     V   {over size 0 rot 1 step}
  : Types      V      C   {meta 1 getcol}
  : Unique     V      V   {dup uniquemap remap}
  : Union      VV     V   {over except concat}
  : UnionMap   VV     C   {swap exceptmap}
  : ViewConv   V      V   { }
  
  # some operators are omitted from restricted execution environments
  unsafe Open Save
*/

  { "append",     "V:VV",     AppendCmd_VV       },
  { "atrow",      "O:OI",     AtRowCmd_OI        },
  { "bitruns",    "C:i",      BitRunsCmd_i       },
  { "blocked",    "V:V",      BlockedCmd_V       },
  { "clone",      "V:V",      CloneCmd_V         },
  { "coerce",     "C:OS",     CoerceCmd_OS       },
  { "colconv",    "C:C",      ColConvCmd_C       },
  { "colmap",     "V:Vn",     ColMapCmd_Vn       },
  { "colomit",    "V:Vn",     ColOmitCmd_Vn      },
  { "compare",    "I:VV",     CompareCmd_VV      },
  { "compat",     "I:VV",     CompatCmd_VV       },
  { "concat",     "V:VV",     ConcatCmd_VV       },
  { "counts",     "C:VN",     CountsCmd_VN       },
  { "countscol",  "C:C",      CountsColCmd_C     },
  { "countview",  "V:I",      CountViewCmd_I     },
  { "data",       "V:VX",     DataCmd_VX         },
  { "debug",      "I:I",      DebugCmd_I         },
  { "delete",     "V:VII",    DeleteCmd_VII      },
  { "except",     "V:VV",     ExceptCmd_VV       },
  { "exceptmap",  "C:VV",     ExceptMapCmd_VV    },
  { "first",      "V:VI",     FirstCmd_VI        },
  { "getcol",     "C:VN",     GetColCmd_VN       },
  { "getinfo",    "C:VVI",    GetInfoCmd_VVI     },
  { "group",      "V:VnS",    GroupCmd_VnS       },
  { "grouped",    "V:ViiS",   GroupedCmd_ViiS    },
  { "hashcol",    "C:SO",     HashColCmd_SO      },
  { "hashfind",   "I:VIViii", HashFindCmd_VIViii },
  { "hashview",   "C:V",      HashViewCmd_V      },
  { "ijoin",      "V:VV",     IjoinCmd_VV        },
  { "insert",     "V:VIV",    InsertCmd_VIV      },
  { "intersect",  "V:VV",     IntersectCmd_VV    },
  { "iota",       "C:I",      IotaCmd_I          },
  { "isectmap",   "C:VV",     IsectMapCmd_VV     },
  { "join",       "V:VVS",    JoinCmd_VVS        },
  { "last",       "V:VI",     LastCmd_VI         },
  { "max",        "O:VN",     MaxCmd_VN          },
  { "mdef",       "V:O",      MdefCmd_O          },
  { "mdesc",      "V:S",      MdescCmd_S         },
  { "meta",       "V:V",      MetaCmd_V          },
  { "min",        "O:VN",     MinCmd_VN          },
  { "namecol",    "V:V",      NameColCmd_V       },
  { "names",      "C:V",      NamesCmd_V         },
  { "omitmap",    "C:iI",     OmitMapCmd_iI      },
  { "onecol",     "V:VN",     OneColCmd_VN       },
  { "open",       "V:S",      OpenCmd_S          },
  { "pair",       "V:VV",     PairCmd_VV         },
  { "product",    "V:VV",     ProductCmd_VV      },
  { "remap",      "V:Vi",     RemapCmd_Vi        },
  { "remapsub",   "V:ViII",   RemapSubCmd_ViII   },
  { "repeat",     "V:VI",     RepeatCmd_VI       },
  { "replace",    "V:VIIV",   ReplaceCmd_VIIV    },
  { "resizecol",  "C:iII",    ResizeColCmd_iII   },
  { "reverse",    "V:V",      ReverseCmd_V       },
  { "rowcmp",     "I:VIVI",   RowCmpCmd_VIVI     },
  { "roweq",      "I:VIVI",   RowEqCmd_VIVI      },
  { "rowhash",    "I:VI",     RowHashCmd_VI      },
  { "set",        "V:MIX",    SetCmd_MIX         },
  { "size",       "I:V",      SizeCmd_V          },
  { "slice",      "V:VIII",   SliceCmd_VIII      },
  { "sort",       "V:V",      SortCmd_V          },
  { "sortmap",    "C:V",      SortMapCmd_V       },
  { "spread",     "V:VI",     SpreadCmd_VI       },
  { "step",       "V:VIIII",  StepCmd_VIIII      },
  { "strlookup",  "I:Ss",     StrLookupCmd_Ss    },
  { "structdesc", "S:V",      StructDescCmd_V    },
  { "structure",  "S:V",      StructureCmd_V     },
  { "sum",        "O:VN",     SumCmd_VN          },
  { "tag",        "V:VS",     TagCmd_VS          },
  { "take",       "V:VI",     TakeCmd_VI         },
  { "types",      "C:V",      TypesCmd_V         },
  { "ungroup",    "V:VN",     UngroupCmd_VN      },
  { "union",      "V:VV",     UnionCmd_VV        },
  { "unionmap",   "C:VV",     UnionMapCmd_VV     },
  { "unique",     "V:V",      UniqueCmd_V        },
  { "uniquemap",  "C:V",      UniqueMapCmd_V     },
  { "viewascol",  "C:V",      ViewAsColCmd_V     },
  { "viewconv",   "V:V",      ViewConvCmd_V      },
  { "width",      "I:V",      WidthCmd_V         },
  { "write",      "I:VO",     WriteCmd_VO        },

/* end of generated code */
vqcore/src_tcl/0000755000076500007650000000000010637717020013413 5ustar  jcwjcw00000000000000vqcore/src_tcl/cmds.c0000644000076500007650000001724610637717020014517 0ustar  jcwjcw00000000000000/*
 * cmds.c - Implementation of Tcl-specific operators.
 */

#include "ext_tcl.h"

ItemTypes DefCmd_OO (Item args[]) {
    int argc, c, r, cols, rows;
    View_p meta, result;
    Object_p obj, *argv;
    Column column;
    struct Buffer buffer;
    
    if (MdefCmd_O(args) != IT_view)
        return IT_error;
    if (args[0].v == NULL)
        return IT_view;
    meta = args[0].v;
        
    if (Tcl_ListObjGetElements(Interp(), args[1].o, &argc, &argv) != TCL_OK)
        return IT_unknown;
        
    cols = ViewSize(meta);
    if (cols == 0) {
        if (argc != 0) {
            args->e = EC_cizwv;
            return IT_error;
        }
        
        args->v = NoColumnView(0);
        return IT_view;
    }
    
    if (argc % cols != 0) {
        args->e = EC_nmcw;
        return IT_error;
    }

    result = NewView(meta);
    rows = argc / cols;
    
    for (c = 0; c < cols; ++c) {
        InitBuffer(&buffer);

        for (r = 0; r < rows; ++r)
            ADD_PTR_TO_BUF(buffer, argv[c + cols * r]);

        obj = BufferAsTclList(&buffer);
        column = CoerceColumn(ViewColType(result, c), obj);
        DecObjRef(obj);
        
        if (column.seq == NULL)
            return IT_unknown;
            
        SetViewCols(result, c, 1, column);
    }
    
    args->v = result;
    return IT_view;
}

static Object_p GetViewRows (View_p view, int row, int rows, int tags) {
    int r, c, cols;
    View_p meta;
    Item item;
    struct Buffer buf;
    
    meta = V_Meta(view);
    cols = ViewSize(meta);
    InitBuffer(&buf);
    
    for (r = 0; r < rows; ++r)
        for (c = 0; c < cols; ++c) {
            if (tags) {
                item.c = ViewCol(meta, 0);
                ADD_PTR_TO_BUF(buf, ItemAsObj(GetItem(c, &item), &item));
            }
            item.c = ViewCol(view, c);
            ADD_PTR_TO_BUF(buf, ItemAsObj(GetItem(r + row, &item), &item));
        }
        
    return BufferAsTclList(&buf);
}

static int ColumnNumber(Object_p obj, View_p meta) {
    int col;
    const char *name = Tcl_GetString(obj);
    
    switch (*name) {

        case '#': return -2;
        case '*': return -1;
        case '-': case '0': case '1': case '2': case '3': case '4':
                  case '5': case '6': case '7': case '8': case '9':
            if (Tcl_GetIntFromObj(Interp(), obj, &col) != TCL_OK)
                return -3;

            if (col < 0)
                col += ViewSize(meta);
                
            if (col < 0 || col >= ViewSize(meta))
                return -4;
            break;

        default:
            col = StringLookup(name, ViewCol(meta, MC_name));
            if (col < 0)
                return -3;
    }

    return col;
}

ItemTypes GetCmd_VX (Item args[]) {
    View_p view;
    int i, objc, r, row, col, rows;
    const Object_p *objv;
    ItemTypes currtype;

    view = args[0].v;
    currtype = IT_view;
    
    objv = (const void*) args[1].u.ptr;
    objc = args[1].u.len;

    if (objc == 0) {
        args->o = GetViewRows(view, 0, ViewSize(view), 0);
        return IT_object;
    }
    
    for (i = 0; i < objc; ++i) {
        if (currtype == IT_view)
            view = args[0].v;
        else /* TODO: make sure the object does not leak if newly created */
            view = ObjAsView(ItemAsObj(currtype, args));
        
        if (view == NULL)
            return IT_unknown;

        rows = ViewSize(view);

        if (Tcl_GetIntFromObj(0, objv[i], &row) != TCL_OK)
            switch (*Tcl_GetString(objv[i])) {
                case '@':   args->v = V_Meta(view);
                            currtype = IT_view;
                            continue;
                case '#':   args->i = rows;
                            currtype = IT_int;
                            continue;
                case '*':   row = -1;
                            break;
                default:    Tcl_GetIntFromObj(Interp(), objv[i], &row);
                            return IT_unknown;
            }
        else if (row < 0) {
            row += rows;
            if (row < 0) {
                args->e = EC_rioor;
                return IT_error;
            }
        }

        if (++i >= objc) {
            if (row >= 0)
                args->o = GetViewRows(view, row, 1, 1); /* one tagged row */
            else {
                struct Buffer buf;
                InitBuffer(&buf);
                for (r = 0; r < rows; ++r)
                    ADD_PTR_TO_BUF(buf, GetViewRows(view, r, 1, 0));
                args->o = BufferAsTclList(&buf);
            }
            return IT_object;
        }

        col = ColumnNumber(objv[i], V_Meta(view));

        if (row >= 0)
            switch (col) {
                default:    args->c = ViewCol(view, col);
                            currtype = GetItem(row, args);
                            break;
                case -1:    args->o = GetViewRows(view, row, 1, 0);
                            currtype = IT_object;
                            break;
                case -2:    args->i = row;
                            currtype = IT_int;
                            break;
                case -3:    return IT_unknown;
                case -4:    args->e = EC_cioor;
                            return IT_error;
            }
        else
            switch (col) {
                default:    args->c = ViewCol(view, col);
                            currtype = IT_column;
                            break;
                case -1:    args->o = GetViewRows(view, 0, rows, 0);
                            currtype = IT_object;
                            break;
                case -2:    args->c = NewIotaColumn(rows);
                            currtype = IT_column;
                            break;
                case -3:    return IT_unknown;
                case -4:    args->e = EC_cioor;
                            return IT_error;
            }
    }
    
    return currtype;
}

ItemTypes MutInfoCmd_V (Item_p a) {
    int i;
    Seq_p mods, *seqs;
    Object_p result;
    
    if (!IsMutable(a[0].v))
        return IT_unknown;
        
    mods = MutPrepare(a[0].v);
    seqs = (void*) (mods + 1);
    
    result = Tcl_NewListObj(0, NULL);

    for (i = 0; i < MP_delmap; ++i)
        Tcl_ListObjAppendElement(NULL, result, ViewAsObj(seqs[i]));
    for (i = MP_delmap; i < MP_limit; ++i)
        Tcl_ListObjAppendElement(NULL, result, ColumnAsObj(SeqAsCol(seqs[i])));
    
    a->o = result;
    return IT_object;
}

ItemTypes RefsCmd_O (Item args[]) {
    args->i = args[0].o->refCount;
    return IT_int;
}

ItemTypes RenameCmd_VO (Item args[]) {
    int i, c, objc;
    View_p meta, view, newmeta, newview;
    Object_p *objv;
    Item item;

    if (Tcl_ListObjGetElements(Interp(), args[1].o, &objc, &objv) != TCL_OK)
        return IT_unknown;
        
    if (objc % 2) {
        args->e = EC_rambe;
        return IT_error;
    }

    view = args[0].v;
    meta = V_Meta(view);
    newmeta = meta;
    
    for (i = 0; i < objc; i += 2) {
        c = ColumnByName(meta, objv[i]);
        if (c < 0)
            return IT_unknown;
        item.s = Tcl_GetString(objv[i+1]);
        newmeta = ViewSet(newmeta, c, MC_name, &item);
    }
    
    newview = NewView(newmeta);
    
    for (c = 0; c < ViewWidth(view); ++c)
        SetViewCols(newview, c, 1, ViewCol(view, c));

    args->v = newview;
    return IT_view;
}

ItemTypes ToCmd_OO (Item args[]) {
    Object_p result;

    result = Tcl_ObjSetVar2(Interp(), args[1].o, 0, args[0].o,
                                                    TCL_LEAVE_ERR_MSG);
    if (result == NULL)
        return IT_unknown;

    args->o = result;
    return IT_object;
}

ItemTypes TypeCmd_O (Item args[]) {
    args->s = args[0].o->typePtr != NULL ? args[0].o->typePtr->name : "";
    return IT_string;
}
vqcore/src_tcl/colobj.c0000644000076500007650000001243110611154237015025 0ustar  jcwjcw00000000000000/*
 * colobj.c - Implementation of column objects in Tcl.
 */

#include "ext_tcl.h"

static const char *ErrorMessage(ErrorCodes code) {
	switch (code) {
		case EC_cioor: return "column index out of range";
		case EC_rioor: return "row index out of range";
		case EC_cizwv: return "cannot insert in zero-width view";
		case EC_nmcw:	 return "item count not a multiple of column width";
		case EC_rambe: return "rename arg count must be even";
		case EC_nalor: return "nead at least one row";
		case EC_wnoa:	 return "wrong number of arguments";
	}
	return "?";
}

Object_p ItemAsObj (ItemTypes type, Item_p item) {
	switch (type) {

		case IT_int:
			return Tcl_NewIntObj(item->i);

		case IT_wide:
			return Tcl_NewWideIntObj(item->w);

		case IT_float:
			return Tcl_NewDoubleObj(item->f);

		case IT_double:
			return Tcl_NewDoubleObj(item->d);

		case IT_string:
			return Tcl_NewStringObj(item->s, -1);
			
		case IT_bytes:
			return Tcl_NewByteArrayObj(item->u.ptr, item->u.len);

		case IT_object:
			return item->o;

		case IT_column:
			return ColumnAsObj(item->c);

		case IT_view:
			if (item->v == NULL) {
				Tcl_SetResult(Interp(), "invalid view", TCL_STATIC);
				return NULL;
			}
			return ViewAsObj(item->v);

		case IT_error:
			Tcl_SetResult(Interp(), (char*) ErrorMessage(item->e), TCL_STATIC);
			return NULL;

		default:
			Assert(0);
			return NULL;
	}
}

int ColumnByName (View_p meta, Object_p obj) {
	int colnum;
	const char *str = Tcl_GetString(obj);
	
	switch (*str) {

		case '#':
			return -2;

		case '*':
			return -3;

		case '-': case '0': case '1': case '2': case '3': case '4':
				  case '5': case '6': case '7': case '8': case '9':
			if (Tcl_GetIntFromObj(NULL, obj, &colnum) != TCL_OK)
				return -4;
			if (colnum < 0)
				colnum += ViewSize(meta);
			if (colnum < 0 || colnum >= ViewSize(meta))
				return -5;
			return colnum;
			
		default:
			return StringLookup(str, ViewCol(meta, MC_name));
	}
}

int ObjToItem (ItemTypes type, Item_p item) {
	switch (type) {
		
		case IT_int:
			return Tcl_GetIntFromObj(Interp(), item->o, &item->i) == TCL_OK;

		case IT_wide:
			return Tcl_GetWideIntFromObj(Interp(), item->o,
											(Tcl_WideInt*) &item->w) == TCL_OK;

		case IT_float:
			if (Tcl_GetDoubleFromObj(Interp(), item->o, &item->d) != TCL_OK)
				return 0;
			item->f = (float) item->d;
			break;

		case IT_double:
			return Tcl_GetDoubleFromObj(Interp(), item->o, &item->d) == TCL_OK;

		case IT_string:
			item->s = Tcl_GetString(item->o);
			break;

		case IT_bytes:
			item->u.ptr = Tcl_GetByteArrayFromObj(item->o, &item->u.len);
			break;

		case IT_object:
			break;

		case IT_column:
			item->c = ObjAsColumn(item->o);
			return item->c.seq != NULL && item->c.seq->count >= 0;

		case IT_view:
			item->v = ObjAsView(item->o);
			return item->v != NULL;

		default:
			Assert(0);
			return 0;
	}
	
	return 1;
}

#define OBJ_TO_COLUMN_P(o) ((Column*) &(o)->internalRep.twoPtrValue)

static void FreeColIntRep (Tcl_Obj *obj) {
	PUSH_KEEP_REFS
	DecRefCount(OBJ_TO_COLUMN_P(obj)->seq);
	POP_KEEP_REFS
}

static void DupColIntRep (Tcl_Obj *src, Tcl_Obj *dup) {
	Column_p column = OBJ_TO_COLUMN_P(src);
	IncRefCount(column->seq);
	*OBJ_TO_COLUMN_P(dup) = *column;
	dup->typePtr = &f_colObjType;
}

static void UpdateColStrRep (Tcl_Obj *obj) {
	int r;
	Object_p list;
	Item item;
	struct Buffer buf;
	Column column;
	PUSH_KEEP_REFS
	
	InitBuffer(&buf);
	column = *OBJ_TO_COLUMN_P(obj);
	
	if (column.seq != NULL)
		for (r = 0; r < column.seq->count; ++r) {
			item.c = column;
			ADD_PTR_TO_BUF(buf, ItemAsObj(GetItem(r, &item), &item));
		}

	list = BufferAsTclList(&buf);

	/* this hack avoids creating a second copy of the string rep */
	obj->bytes = Tcl_GetStringFromObj(list, &obj->length);
	list->bytes = NULL;
	list->length = 0;
	
	DecObjRef(list);
	
	POP_KEEP_REFS
}

#define LO_list		data[0].o
#define LO_objv		data[1].p

static void ListObjCleaner (Seq_p seq) {
	DecObjRef(seq->LO_list);
}

static ItemTypes ListObjGetter (int row, Item_p item) {
	const Object_p *objv = item->c.seq->LO_objv;
	item->o = objv[row];
	return IT_object;
}

static struct SeqType ST_ListObj = {
	"listobj", ListObjGetter, 0, ListObjCleaner
};

static int SetColFromAnyRep (Tcl_Interp *interp, Tcl_Obj *obj) {
	int objc;
	Object_p dup, *objv;
	Seq_p seq;

	/* must duplicate the list because it'll be kept by ObjAsColumn */
	dup = Tcl_DuplicateObj(obj);
	
	if (Tcl_ListObjGetElements(interp, dup, &objc, &objv) != TCL_OK) {
		DecObjRef(dup);
		return TCL_ERROR;
	}

	PUSH_KEEP_REFS
	
	seq = IncRefCount(NewSequence(objc, &ST_ListObj, 0));
	seq->LO_list = IncObjRef(dup);
	seq->LO_objv = objv;

	if (obj->typePtr != NULL && obj->typePtr->freeIntRepProc != NULL)
		obj->typePtr->freeIntRepProc(obj);

	*OBJ_TO_COLUMN_P(obj) = SeqAsCol(seq);
	obj->typePtr = &f_colObjType;
	
	POP_KEEP_REFS
	return TCL_OK;
}

Tcl_ObjType f_colObjType = {
	"column", FreeColIntRep, DupColIntRep, UpdateColStrRep, SetColFromAnyRep
};

Column ObjAsColumn (Object_p obj) {
	if (Tcl_ConvertToType(Interp(), obj, &f_colObjType) != TCL_OK) {
		Column column;
		column.seq = NULL;
		column.pos = -1;
		return column;
	}
	
	return *OBJ_TO_COLUMN_P(obj);
}

Object_p ColumnAsObj (Column column) {
	Object_p result;

	result = Tcl_NewObj();
	Tcl_InvalidateStringRep(result);

	IncRefCount(column.seq);
	*OBJ_TO_COLUMN_P(result) = column;
	result->typePtr = &f_colObjType;
	return result;
}
vqcore/src_tcl/defs.h0000644000076500007650000000015710574360066014514 0ustar  jcwjcw00000000000000/*
 * defs.h - Binding-specific definitions needed by the general code.
 */

typedef struct Tcl_Obj *Object_p;
vqcore/src_tcl/ext_tcl.c0000644000076500007650000002714210637226473015236 0ustar  jcwjcw00000000000000/*
 * ext_tcl.c - Interface to the Tcl scripting language.
 */

#include "ext_tcl.h"

#ifndef PACKAGE_VERSION
#define PACKAGE_VERSION "4"
#endif

/* stub interface code, removes the need to link with libtclstub*.a */
#if STATIC_BUILD+0
#define MyInitStubs(x) 1
#else
#include "stubs.h"
#endif

#if NO_THREAD_CALLS+0
Shared_p GetShared (void) {
    static struct Shared data;
    return &data;
}
#define UngetShared Tcl_CreateExitHandler
#else
static Tcl_ThreadDataKey tls_data;
Shared_p GetShared (void) {
    return (Shared_p) Tcl_GetThreadData(&tls_data, sizeof(struct Shared));
}
#define UngetShared Tcl_CreateThreadExitHandler
#endif

typedef struct CmdDispatch {
    const char *name, *args;
    ItemTypes (*proc) (Item_p);
} CmdDispatch;

static CmdDispatch f_commands[] = {
#include "opdefs_gen.h"
    { NULL, NULL, NULL }
};

Object_p IncObjRef (Object_p objPtr) {
    Tcl_IncrRefCount(objPtr);
    return objPtr;
}

Object_p BufferAsTclList (Buffer_p bp) {
    int argc;
    Object_p result;
    
    argc = BufferFill(bp) / sizeof(Object_p);
    result = Tcl_NewListObj(argc, BufferAsPtr(bp, 1));
    ReleaseBuffer(bp, 0);
    return result;
}

void FailedAssert (const char *msg, const char *file, int line) {
    Tcl_Panic("Failed assertion at %s, line %d: %s\n", file, line, msg);
}

ItemTypes RefCmd_OX (Item args[]) {
    int objc;
    const Object_p *objv;
    
    objv = (const void*) args[1].u.ptr;
    objc = args[1].u.len;

    args->o = Tcl_ObjGetVar2(Interp(), args[0].o, 0,
                                TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG);
    return IT_object;
}

ItemTypes OpenCmd_S (Item args[]) {
    View_p result;
    
    result = OpenDataFile(args[0].s);
    if (result == NULL) {
        Tcl_AppendResult(Interp(), "cannot open file: ", args[0].s, NULL);
        return IT_unknown;
    }
    
    args->v = result;
    return IT_view;
}

static void LoadedStringCleaner (MappedFile_p map) {
    DecObjRef((Object_p) map->data[3].p);
}

ItemTypes LoadCmd_O (Item args[]) {
    int len;
    const char *ptr;
    View_p view;
    MappedFile_p map;
    
    ptr = (const char*) Tcl_GetByteArrayFromObj(args[0].o, &len);

    map = InitMappedFile(ptr, len, LoadedStringCleaner);
    map->data[3].p = IncObjRef(args[0].o);
    
    view = MappedToView(map, NULL);
    if (view == NULL)
        return IT_unknown;
        
    args->v = view;
    return IT_view;
}

ItemTypes LoadModsCmd_OV (Item args[]) {
    int len;
    const char *ptr;
    View_p view;
    MappedFile_p map;
    
    ptr = (const char*) Tcl_GetByteArrayFromObj(args[0].o, &len);

    map = InitMappedFile(ptr, len, LoadedStringCleaner);
    map->data[3].p = IncObjRef(args[0].o);
    
    view = MappedToView(map, args[1].v);
    if (view == NULL)
        return IT_unknown;
        
    args->v = view;
    return IT_view;
}

    static void *WriteDataFun(void *chan, const void *ptr, Int_t len) {
        Tcl_Write(chan, ptr, len);
        return chan;
    }

ItemTypes SaveCmd_VS (Item args[]) {
    Int_t bytes;
    Tcl_Channel chan;
    
    chan = Tcl_OpenFileChannel(Interp(), args[1].s, "w", 0666);
    if (chan == NULL || Tcl_SetChannelOption(Interp(), chan,
                                            "-translation", "binary") != TCL_OK)
        return IT_unknown;
        
    bytes = ViewSave(args[0].v, chan, NULL, WriteDataFun, 0);

    Tcl_Close(Interp(), chan);

    if (bytes < 0)
        return IT_unknown;
        
    args->w = bytes;
    return IT_wide;
}

ItemTypes WriteCmd_VO (Item args[]) {
    Int_t bytes;
    Tcl_Channel chan;
    
    chan = Tcl_GetChannel(Interp(), Tcl_GetString(args[1].o), NULL);
    if (chan == NULL || Tcl_SetChannelOption(Interp(), chan,
                                            "-translation", "binary") != TCL_OK)
        return IT_unknown;
        
    bytes = ViewSave(args[0].v, chan, NULL, WriteDataFun, 0);
    
    if (bytes < 0)
        return IT_unknown;
        
    args->w = bytes;
    return IT_wide;
}

#define EmitInitFun ((SaveInitFun) Tcl_SetByteArrayLength)

    static void *EmitDataFun(void *data, const void *ptr, Int_t len) {
        memcpy(data, ptr, len);
        return (char*) data + len;
    }

ItemTypes EmitCmd_V (Item args[]) {
    Object_p result = Tcl_NewByteArrayObj(NULL, 0);
        
    if (ViewSave(args[0].v, result, EmitInitFun, EmitDataFun, 0) < 0) {
        DecObjRef(result);
        return IT_unknown;
    }
        
    args->o = result;
    return IT_object;
}

ItemTypes EmitModsCmd_V (Item args[]) {
    Object_p result = Tcl_NewByteArrayObj(NULL, 0);
        
    if (ViewSave(args[0].v, result, EmitInitFun, EmitDataFun, 1) < 0) {
        DecObjRef(result);
        return IT_unknown;
    }
        
    args->o = result;
    return IT_object;
}

int AdjustCmdDef (Object_p cmd) {
    Object_p origname, newname;
    Tcl_CmdInfo cmdinfo;

    /* Use "::vlerq::blah ..." if it exists, else use "vlerq blah ...". */
    /* Could perhaps be simplified (optimized?) by using 8.5 ensembles. */
     
    if (Tcl_ListObjIndex(Interp(), cmd, 0, &origname) != TCL_OK)
        return TCL_ERROR;

    /* insert "::vlerq::" before the first list element */
    newname = Tcl_NewStringObj("::vlerq::", -1);
    Tcl_AppendObjToObj(newname, origname);
    
    if (Tcl_GetCommandInfo(Interp(), Tcl_GetString(newname), &cmdinfo))
        Tcl_ListObjReplace(NULL, cmd, 0, 1, 1, &newname);
    else {
        Object_p buf[2];
        DecObjRef(newname);
        buf[0] = Tcl_NewStringObj("vlerq", -1);
        buf[1] = origname;
        Tcl_ListObjReplace(NULL, cmd, 0, 1, 2, buf);
    }
    return TCL_OK;
}

ItemTypes ViewCmd_X (Item args[]) {
    int e = TCL_OK, i, n, index, objc;
    const Object_p *objv;
    Object_p result, buf[10], *cvec;
    Tcl_Interp *interp = Interp();
    const CmdDispatch *cmds = GetShared()->info->cmds;

    objv = (const void*) args[0].u.ptr;
    objc = args[0].u.len;

    if (objc < 1) {
        Tcl_WrongNumArgs(interp, 0, objv, "view arg ?op ...? ?| ...?");
        return IT_unknown;
    }
    
    Tcl_SetObjResult(interp, objv[0]); --objc; ++objv;
    
    while (e == TCL_OK && objc > 0) {
        for (n = 0; n < objc; ++n)
            if (objv[n]->bytes != 0 && *objv[n]->bytes == '|' && 
                    objv[n]->length == 1)
                break;

        if (n > 0) {
            cvec = n > 8 ? malloc((n+2) * sizeof(Object_p)) : buf;
                
            if (Tcl_GetIndexFromObjStruct(NULL, *objv, cmds, sizeof *cmds, 
                                            "", TCL_EXACT, &index) != TCL_OK)
                index = -1;

            cvec[0] = Tcl_NewStringObj("vlerq", -1);
            cvec[1] = objv[0];
            cvec[2] = IncObjRef(Tcl_GetObjResult(interp));
            for (i = 1; i < n; ++i)
                cvec[i+2] = objv[i];
            
            result = Tcl_NewListObj(n+1, cvec+1);

            if (index < 0 || *cmds[index].args != 'V') {
                e = AdjustCmdDef(result);
                if (e == TCL_OK) {
                    int ac;
                    Object_p *av;
                    Tcl_ListObjGetElements(NULL, result, &ac, &av);
                    /* don't use Tcl_EvalObjEx, it forces a string conversion */
                    e = Tcl_EvalObjv(interp, ac, av, 0);
                }
                DecObjRef(result);
            } else
                Tcl_SetObjResult(interp, result);
            
            DecObjRef(cvec[2]);
            if (n > 8)
                free(cvec);
        }
        
        objc -= n+1; objv += n+1; /*++k;*/
    }

    if (e != TCL_OK) {
#if 0
        char msg[50];
        sprintf(msg, "\n        (\"view\" step %d)", k);
        Tcl_AddObjErrorInfo(interp, msg, -1);
#endif
        return IT_unknown;
    }
    
    args->o = Tcl_GetObjResult(interp);
    return IT_object;
}

#define MAX_STACK 20

static int VlerqObjCmd (ClientData data, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[]) {
    int i, index, ok = TCL_ERROR;
    ItemTypes type;
    Object_p result;
    Item stack [MAX_STACK];
    const char *args;
    const CmdDispatch *cmdtable;
    PUSH_KEEP_REFS
    
    Interp() = interp;
    
    if (objc <= 1) {
        Tcl_WrongNumArgs(interp, 1, objv, "command ...");
        goto FAIL;
    }

    cmdtable = (const CmdDispatch*) data;
    if (Tcl_GetIndexFromObjStruct(interp, objv[1], cmdtable, sizeof *cmdtable, 
                                    "command", TCL_EXACT, &index) != TCL_OK)
        goto FAIL;

    objv += 2; objc -= 2;
    args = cmdtable[index].args + 2; /* skip return type and ':' */

    for (i = 0; args[i] != 0; ++i) {
        Assert(i < MAX_STACK);
        if (args[i] == 'X') {
            Assert(args[i+1] == 0);
            stack[i].u.ptr = (const void*) (objv+i);
            stack[i].u.len = objc-i;
            break;
        }
        if ((args[i] == 0 && i != objc) || (args[i] != 0 && i >= objc)) {
            char buf [10*MAX_STACK];
            const char* s;
            *buf = 0;
            for (i = 0; args[i] != 0; ++i) {
                if (*buf != 0)
                    strcat(buf, " ");
                switch (args[i] & ~0x20) {
                    case 'C': s = "list"; break;
                    case 'I': s = "int"; break;
                    case 'N': s = "col"; break;
                    case 'O': s = "any"; break;
                    case 'S': s = "string"; break;
                    case 'V': s = "view"; break;
                    case 'X': s = "..."; break;
                    default: Assert(0); s = "?"; break;
                }
                strcat(buf, s);
                if (args[i] & 0x20)
                    strcat(buf, "*");
            }
            Tcl_WrongNumArgs(interp, 2, objv-2, buf);
            goto FAIL;
        }
        stack[i].o = objv[i];
        if (!CastObjToItem(args[i], stack+i)) {
            if (*Tcl_GetStringResult(interp) == 0) {
                const char* s = "?";
                switch (args[i] & ~0x20) {
                    case 'C': s = "list"; break;
                    case 'I': s = "integer"; break;
                    case 'N': s = "column name"; break;
                    case 'V': s = "view"; break;
                }
                Tcl_AppendResult(interp, cmdtable[index].name, ": invalid ", s,
                                                                        NULL);
            }
            goto FAIL; /* TODO: append info about which arg is bad */
        }
    }
    
    GetShared()->info->cmds = cmdtable; /* for ViewCmd_X */
    
    type = cmdtable[index].proc(stack);
    if (type == IT_unknown)
        goto FAIL;

    result = ItemAsObj(type, stack);
    if (result == NULL)
        goto FAIL;

    Tcl_SetObjResult(interp, result);
    ok = TCL_OK;

FAIL:
    POP_KEEP_REFS
    return ok;
}

static void DoneShared (ClientData cd) {
    Shared_p sh = (Shared_p) cd;
    if (--sh->refs == 0)
        free(sh->info);
}

static void InitShared (void) {
    Shared_p sh = GetShared();
    if (sh->refs++ == 0)
        sh->info = calloc(1, sizeof(SharedInfo));
    UngetShared(DoneShared, (ClientData) sh);
}

DLLEXPORT int Vlerq_Init (Tcl_Interp *interp) {
    if (!MyInitStubs(interp) || Tcl_PkgRequire(interp, "Tcl", "8.4", 0) == NULL)
        return TCL_ERROR;

    Tcl_CreateObjCommand(interp, "vlerq", VlerqObjCmd, f_commands, NULL);
    InitShared();
    return Tcl_PkgProvide(interp, "vlerq", PACKAGE_VERSION);
}

DLLEXPORT int Vlerq_SafeInit (Tcl_Interp *interp) {
    if (!MyInitStubs(interp) || Tcl_PkgRequire(interp, "Tcl", "8.4", 0) == NULL)
        return TCL_ERROR;

    /* UNSAFE is defined in the "opdefs_gen.h" file included above */
    Tcl_CreateObjCommand(interp, "vlerq", VlerqObjCmd, f_commands + UNSAFE,
                                                                        NULL);
    InitShared();
    return Tcl_PkgProvide(interp, "vlerq", PACKAGE_VERSION);
}
vqcore/src_tcl/ext_tcl.h0000644000076500007650000000132210611154237015221 0ustar  jcwjcw00000000000000/*
 * ext_tcl.h - Definitions needed across the Tcl-specific code.
 */

#include 
#include 

#include "../src/intern.h"
#include "../src/wrap_gen.h"

#define USE_TCL_STUBS 1
#include 

/* colobj.c */

extern Tcl_ObjType f_colObjType;

Object_p  (ColumnAsObj) (Column column);

/* ext_tcl.c */

typedef struct SharedInfo {
    Tcl_Interp *interp;
    const struct CmdDispatch *cmds;
} SharedInfo;

#define Interp() (GetShared()->info->interp)
#define DecObjRef   Tcl_DecrRefCount

Object_p  (BufferAsTclList) (Buffer_p bp);
Object_p  (IncObjRef) (Object_p objPtr);

/* viewobj.c */

extern Tcl_ObjType f_viewObjType;

int       (AdjustCmdDef) (Object_p cmd);
Object_p  (ViewAsObj) (View_p view);
vqcore/src_tcl/loop.c0000644000076500007650000001310010634202252014514 0ustar  jcwjcw00000000000000/*
 * loop.c - Implementation of the Tcl-specific "loop" operator.
 */

/* TODO: code was copied from v3, needs a lot of cleanup */

#include "ext_tcl.h"

    typedef struct LoopInfo {
        int row;
        Object_p view;
        View_p v;
        Object_p cursor;
    } LoopInfo;

    typedef struct ColTrace {
        LoopInfo* lip;
        int col;
        Object_p name;
        int lastRow;
    } ColTrace;

static char* cursor_tracer(ClientData cd, Tcl_Interp* ip, const char *name1, const char *name2, int flags) {
    ColTrace* ct = (ColTrace*) cd;
    int row = ct->lip->row;
    if (row != ct->lastRow) {
        Object_p o;
        if (ct->col < 0)
            o = Tcl_NewIntObj(row);
        else {
            Item item;
            item.c = ViewCol(ct->lip->v, ct->col);
            o = ItemAsObj(GetItem(row, &item), &item);
        }
        if (Tcl_ObjSetVar2(ip, ct->lip->cursor, ct->name, o, 0) == 0)
            return "cursor_tracer?";
        ct->lastRow = row;
    }
    return 0;
}

static int loop_vop(int oc, Tcl_Obj* const* ov) {
    LoopInfo li;
    const char *cur;
    struct Buffer result;
    int type, e = TCL_OK;
    static const char *options[] = { "-where", "-index", "-collect", 0 };
    enum { eLOOP = -1, eWHERE, eINDEX, eCOLLECT };

    if (oc < 2 || oc > 4) {
        Tcl_WrongNumArgs(Interp(), 1, ov, "view ?arrayName? ?-type? body");
        return TCL_ERROR;
    }

    li.v = ObjAsView(ov[0]);
    if (li.v == NULL)
        return TCL_ERROR;

    --oc; ++ov;
    if (oc > 1 && *Tcl_GetString(*ov) != '-') {
        li.cursor = *ov++; --oc;
    } else
        li.cursor = Tcl_NewObj();
    cur = Tcl_GetString(IncObjRef(li.cursor));

    if (Tcl_GetIndexFromObj(0, *ov, options, "", 0, &type) == TCL_OK) {
        --oc; ++ov;
    } else
        type = eLOOP;

    {
        int i, nr = ViewSize(li.v), nc = ViewWidth(li.v);
        ColTrace* ctab = (ColTrace*) ckalloc((nc + 1) * sizeof(ColTrace));
        InitBuffer(&result);
        for (i = 0; i <= nc; ++i) {
            ColTrace* ctp = ctab + i;
            ctp->lip = &li;
            ctp->lastRow = -1;
            if (i < nc) {
                ctp->col = i;
                ctp->name = Tcl_NewStringObj(GetColItem(i,
                              ViewCol(V_Meta(li.v), MC_name), IT_string).s, -1);
            } else {
                ctp->col = -1;
                ctp->name = Tcl_NewStringObj("#", -1);
            }
            e = Tcl_TraceVar2(Interp(), cur, Tcl_GetString(ctp->name),
                              TCL_TRACE_READS, cursor_tracer, (ClientData) ctp);
        }
        if (e == TCL_OK)
            switch (type) {
                case eLOOP:
                    for (li.row = 0; li.row < nr; ++li.row) {
                        e = Tcl_EvalObj(Interp(), *ov);
                        if (e == TCL_CONTINUE)
                            e = TCL_OK;
                        else if (e != TCL_OK) {
                            if (e == TCL_BREAK)
                                e = TCL_OK;
                            else if (e == TCL_ERROR) {
                                char msg[50];
                                sprintf(msg, "\n    (\"loop\" body line %d)",
                                                        Interp()->errorLine);
                                Tcl_AddObjErrorInfo(Interp(), msg, -1);
                            }
                            break;
                        }
                    }
                    break;
                case eWHERE:
                case eINDEX:
                    for (li.row = 0; li.row < nr; ++li.row) {
                        int f;
                        e = Tcl_ExprBooleanObj(Interp(), *ov, &f);
                        if (e != TCL_OK)
                            break;
                        if (f)
                            ADD_INT_TO_BUF(result, li.row);
                    }
                    break;
                case eCOLLECT:
                    for (li.row = 0; li.row < nr; ++li.row) {
                        Object_p o;
                        e = Tcl_ExprObj(Interp(), *ov, &o);
                        if (e != TCL_OK)
                            break;
                        ADD_PTR_TO_BUF(result, o);
                    }
                    break;
                default: Assert(0); return TCL_ERROR;
            }
        for (i = 0; i <= nc; ++i) {
            ColTrace* ctp = ctab + i;
            Tcl_UntraceVar2(Interp(), cur, Tcl_GetString(ctp->name),
                            TCL_TRACE_READS, cursor_tracer, (ClientData) ctp);
            DecObjRef(ctp->name);
        }
        ckfree((char*) ctab);
        if (e == TCL_OK)
            switch (type) {
                case eWHERE: case eINDEX: {
                    Column map = SeqAsCol(BufferAsIntVec(&result));
                    if (type == eWHERE)
                        Tcl_SetObjResult(Interp(), 
                                ViewAsObj(RemapSubview(li.v, map, 0, -1)));
                    else
                        Tcl_SetObjResult(Interp(), ColumnAsObj(map));
                    break;
                }
                case eCOLLECT: {
                    Tcl_SetObjResult(Interp(), BufferAsTclList(&result));
                    break;
                }
                default:
                    ReleaseBuffer(&result, 0);
            }
    }
    
    DecObjRef(li.cursor);
    return e;
}

ItemTypes LoopCmd_X (Item args[]) {
    int objc;
    const Object_p *objv;

    objv = (const void*) args[0].u.ptr;
    objc = args[0].u.len;

    if (loop_vop(objc, objv) != TCL_OK)
        return IT_unknown;
        
    args->o = Tcl_GetObjResult(Interp());
    return IT_object;
}
vqcore/src_tcl/m2mvfs.tcl0000644000076500007650000001674210611155607015342 0ustar  jcwjcw00000000000000# m2mvfs.tcl -- In-memory VFS which appends its data as a MK starkit when done.

# This VFS driver collects data in memory which then gets saved to a Metakit
# data file when unmounted, using vlerq calls.  Does not support deletions,
# renames, and such.  Can only be used with a single mountpoint at a time.
#
# 1.4 adjusted for vlerq 3
# 1.5 fixed to actually work
# 1.6 minor cleanup
# 1.7 adjusted for vlerq 4
# 1.8 allow overwriting files

package provide vfs::m2m 1.8

package require vfs
package require vlerq

namespace eval vfs::m2m {
    namespace eval v {
        variable outfn   ;# output file name
        # following lists are all indexed by the same directory ordinal number
        variable dname   ;# list of directory names
        variable prows   ;# list of parent row numbers
        variable files   ;# list of list of (name size date contents) tuples
    }

# public

    proc Mount {mkfile local args} {
        set v::outfn [file normalize $mkfile]
        set v::dname [list ]
        set v::prows [list -1]
        set v::files [list {}]
        ::vfs::filesystem mount $local [list ::vfs::m2m::handler -]
        ::vfs::RegisterMount $local [list ::vfs::m2m::Unmount -]
        return m2m
    }

    proc Unmount {db local} {
        ::vfs::filesystem unmount $local
        if {$v::outfn ne ""} {
            set fd [::open $v::outfn a]
            vlerq write [makeDirsView] $fd
            ::close $fd
        }
        unset v::outfn v::dname v::prows v::files
    }

# private

    proc makeDirsView {} {
        set d {}
        foreach f $v::files {
            set x [lsort -index 0 -unique $f]
            lappend d [vlerq def {name size:I date:I contents:B} \
                        [eval concat $x]]
        }
        set desc {name parent:I {files {name size:I date:I contents:B}}}
        set dirs [vlerq data [vlerq mdef $desc] $v::dname $v::prows $d]
        vlerq group $dirs {} dirs
    }

    proc handler {db cmd root path actual args} {
        #puts [list M2M $db <$cmd> r: $root p: $path a: $actual $args]
        switch $cmd {
            matchindirectory { eval [linsert $args 0 $cmd $db $path $actual] }
            fileattributes   { eval [linsert $args 0 $cmd $db $root $path] } 
            default          { eval [linsert $args 0 $cmd $db $path] }
        }
    }

    proc fail {code} {
        ::vfs::filesystem posixerror $::vfs::posix($code)
    }

    proc lookUp {db path} {
        set parent 0
        if {$path ne "."} {
            set elems [file split $path]
            set remain [llength $elems]
            foreach e $elems {
                set r ""
                foreach r [lsearch -exact -int -all $v::prows $parent] {
                    if {$e eq [lindex $v::dname $r]} {
                        set parent $r
                        incr remain -1
                        break
                    }
                }
                if {$parent != $r} {
                    if {$remain == 1} {
                        set i [lsearch -exact \
                                        [subFileNames [list ? ? $parent]] $e]
                        if {$i >= 0} {
                            # eval this 4-item result returns info about a file
                            return [list lindex $v::files $parent $i]
                        }
                    }
                    fail ENOENT
                }
            }
        }
        # evaluating this 3-item result returns the files subview
        return [list lindex $v::files $parent]
    }

    proc isDir {tag} {
        return [expr {[llength $tag] == 3}]
    }

    proc subDirNums {tag} {
        lsearch -exact -int -all $v::prows [lindex $tag 2]
    }

    proc subFileNames {tag} {
        set r {}
        foreach x [lindex $v::files [lindex $tag 2]] { lappend r [lindex $x 0] }
        return $r
    }

# methods

    proc matchindirectory {db path actual pattern type} {
        set o {}
        if {$type == 0} { set type 20 }
        set tag [lookUp $db $path]
        if {$pattern ne ""} {
            set c {}
            if {[isDir $tag]} {
                if {$type & 16} {
                    set c [subFileNames $tag]
                }
                if {$type & 4} {
                    foreach r [subDirNums $tag] {
                        lappend c [lindex $v::dname $r]
                    }
                }
            }
            foreach x $c {
                if {[string match $pattern $x]} {
                    lappend o [file join $actual $x]
                }
            }
        } elseif {$type & ([isDir $tag]?4:16)} {
            set o [list $actual]
        }
        return $o
    }

    proc fileattributes {db root path args} {
        switch -- [llength $args] {
            0 { return [::vfs::listAttributes] }
            1 { return [eval [linsert $args 0 \
                                        ::vfs::attributesGet $root $path]] }
            2 { return [eval [linsert $args 0 \
                                        ::vfs::attributesSet $root $path]] }
        }
    }

    proc open {db file mode permissions} {
        switch -- $mode {
            "" - r {
                set tag [lookUp $db $file]
                if {[isDir $tag]} { fail ENOENT }
                foreach {name size date contents} [eval $tag] break
                if {[string length $contents] != $size} {
                    set contents [vfs::zip -mode decompress $contents]
                }
                set fd [vfs::memchan]
                fconfigure $fd -translation binary
                puts -nonewline $fd $contents
                fconfigure $fd -translation auto
                seek $fd 0
                return [list $fd]
            }
            w { ;# make sure the parent dir exists and create empty
                set tag [lookUp $db [file dirname $file]]
                set dpos [lindex $tag 2]
                set curr [lindex $v::files $dpos]
                set fpos [llength $curr]
                lappend curr [list [file tail $file] 0 [clock seconds] ""]
                lset v::files $dpos $curr
                set fd [vfs::memchan]
                return [list $fd [list ::vfs::m2m::doClose $db $dpos $fpos $fd]]
            }
            default { error "unsupported access mode: $mode" }
        }
    }

    proc doClose {db dpos fpos fd} {
        fconfigure $fd -translation binary
        seek $fd 0
        set d [read $fd]
        set n [string length $d]
        set z [vfs::zip -mode compress $d]
        if {[string length $z] < $n} { set d $z }
        lset v::files $dpos $fpos 1 $n
        lset v::files $dpos $fpos 3 $d
    }

    proc access {db path mode} {
        lookUp $db $path
    }

    proc stat {db path} {
        set tag [lookUp $db $path]
        set l 1
        if {[isDir $tag]} {
            set t directory
            set s 0
            set d 0
            set c ""
            incr l [llength [subFileNames $tag]]
            incr l [llength [subDirNums $tag]]
        } else {
            set t file
            foreach {n s d c} [eval $tag] break
        }
        return [list type $t size $s atime $d ctime $d mtime $d nlink $l \
            csize [string length $c] gid 0 uid 0 ino 0 mode 0777]
    }

    proc createdirectory {db path} {
        set tag [lookUp $db [file dirname $path]]
        lappend v::dname [file tail $path]
        lappend v::prows [lindex $tag 2]
        lappend v::files {}
    }

    proc utime {db path atime mtime} {
        set tag [lookUp $db $path]
        if {![isDir $tag]} {
            lset v::files [lindex $tag 2] [lindex $tag 3] 2 $mtime
        }
    }
}
vqcore/src_tcl/mkclvfs.tcl0000644000076500007650000001337010611154237015565 0ustar  jcwjcw00000000000000# mkclvfs.tcl -- Metakit Compatibility Layer Virtual File System driver
# Rewritten from mk4vfs.tcl, orig by Matt Newman and Jean-Claude Wippler 

# 1.0 initial release
# 1.1 view size renamed to count
# 1.2 replace view calls by vget (simpler and faster)
# 1.3 modified to use the vlerq extension i.s.o. thrive
# 1.4 minor cleanup
# 1.5 adjusted for vlerq 4

package provide vfs::mkcl 1.5

package require vfs
package require vlerq

namespace eval ::vfs::mkcl {
    interp alias {} ::vfs::mkcl::vopen {} ::vlerq open
    interp alias {} ::vfs::mkcl::vget {} ::vlerq get
        
    namespace eval v {
        variable seq 0  ;# used to generate a unique db handle
        variable rootv  ;# maps handle to the "dirs" root view
        variable dname  ;# maps handle to cached list of directory names
        variable prows  ;# maps handle to cached list of parent row numbers
    }

# public

    proc Mount {mkfile local args} {
        set db mkclvfs[incr v::seq]
        set v::rootv($db) [vget [vopen $mkfile] 0 dirs]
        set v::dname($db) [vget $v::rootv($db) * name]
        set v::prows($db) [vget $v::rootv($db) * parent]
        #parray v::dname
        #parray v::prows
        ::vfs::filesystem mount $local [list ::vfs::mkcl::handler $db]
        ::vfs::RegisterMount $local [list ::vfs::mkcl::Unmount $db]
        return $db
    }
    
    proc Unmount {db local} {
        ::vfs::filesystem unmount $local
        unset v::rootv($db) v::dname($db) v::prows($db)
    }
    
# private

    proc handler {db cmd root path actual args} {
        #puts [list MKCL $db <$cmd> r: $root p: $path a: $actual $args]
        switch $cmd {
            matchindirectory { eval [linsert $args 0 $cmd $db $path $actual] }
            fileattributes   { eval [linsert $args 0 $cmd $db $root $path] } 
            default          { eval [linsert $args 0 $cmd $db $path] }
        }
    }
    
    proc fail {code} {
        ::vfs::filesystem posixerror $::vfs::posix($code)
    }
    
    proc lookUp {db path} {
        set dirs $v::rootv($db)
        set parent 0
        set elems [file split $path]
        set remain [llength $elems]
        foreach e $elems {
            set r ""
            foreach r [lsearch -exact -int -all $v::prows($db) $parent] {
                if {$e eq [lindex $v::dname($db) $r]} {
                    set parent $r
                    incr remain -1
                    break
                }
            }
            if {$parent != $r} {
                if {$remain == 1} {
                    set files [vget $dirs $parent files]
                    set i [lsearch -exact [vget $files * name] $e]
                    if {$i >= 0} {
                        # eval this 3-item result returns the info about 1 file
                        return [list vget $files $i]
                    }
                }
                fail ENOENT
            }
        }
        # evaluating this 4-item result returns the files subview
        list vget $dirs $parent files
    }
    
    proc isDir {tag} {
        expr {[llength $tag] == 4}
    }
    
    if {$::tcl_version eq "8.4"} {
            proc apply {cmd args} { eval [concat $cmd $args] }
    } else {
            proc apply {cmd args} { {*}$cmd {*}$args }
    }
    
# methods

    proc matchindirectory {db path actual pattern type} {
        set o {}
        if {$type == 0} { set type 20 }
        set tag [lookUp $db $path]
        if {$pattern ne ""} {
            set c {}
            if {[isDir $tag]} {
                # collect file names
                if {$type & 16} {
                    set c [apply $tag * 0]
                }
                # collect directory names
                if {$type & 4} {
                    foreach r [lsearch -exact -int -all $v::prows($db) \
                                                            [lindex $tag 2]] {
                        lappend c [lindex $v::dname($db) $r]
                    }
                }
            }
            foreach x $c {
                if {[string match $pattern $x]} {
                    lappend o [file join $actual $x]
                }
            }
        } elseif {$type & ([isDir $tag]?4:16)} {
            set o [list $actual]
        }
        return $o
    }
    
    proc fileattributes {db root path args} {
        switch -- [llength $args] {
            0 { return [::vfs::listAttributes] }
            1 { set index [lindex $args 0]
                    return [::vfs::attributesGet $root $path $index] }
            2 { fail EROFS }
        }
    }
    
    proc open {db file mode permissions} {
        if {$mode ne "" && $mode ne "r"} { fail EROFS }
        set tag [lookUp $db $file]
        if {[isDir $tag]} { fail ENOENT }
        foreach {name size date contents} [apply $tag *] break
        if {[string length $contents] != $size} {
            set contents [::vfs::zip -mode decompress $contents]
        }
        set fd [::vfs::memchan]
        fconfigure $fd -translation binary
        puts -nonewline $fd $contents
        fconfigure $fd -translation auto -encoding [encoding system]
        seek $fd 0
        list $fd
    }
    
    proc access {db path mode} {
        if {$mode & 2} { fail EROFS }
        lookUp $db $path
    }
    
    proc stat {db path} {
        set tag [lookUp $db $path]
        set l 1
        if {[isDir $tag]} {
            set t directory
            set s 0
            set d 0
            set c ""
            incr l [apply $tag #]
            incr l [llength [lsearch -exact -int -all $v::prows($db) \
                                                        [lindex $tag 2]]]
        } else {
            set t file
            foreach {n s d c} [apply $tag *] break
        }
        list type $t size $s atime $d ctime $d mtime $d nlink $l \
                    csize [string length $c] gid 0 uid 0 ino 0 mode 0777
    }
}
vqcore/src_tcl/mklite.tcl0000644000076500007650000002050610611154237015404 0ustar  jcwjcw00000000000000# mklite.tcl -- Compatibility layer for Metakit

# 0.3 modified to use the vlerq extension i.s.o. thrive
# 0.4 adjusted for vlerq 4
# 0.5 support "mk::file open" (no other args) and more mk::select options

package provide mklite 0.5

package require vlerq

namespace eval mklite {
    variable mkdb   ;# the mkdb array maps open db handles to view references

# call emulateMk4tcl to define compatibility aliases in a specific namespace
# if the MKLITE_DEBUG env var is defined, all calls and returns will be traced

    proc emulateMk4tcl {{ns ::mk}} {
        foreach x {channel cursor file get loop select view} {
            # NOTE: clobbers existing mk::* cmds, may want to rename 'em first?
            if {[info exists ::env(MKLITE_DEBUG)]} {
                interp alias {} ${ns}::$x {} ::mklite::debug ::mklite::$x
            } else {
                interp alias {} ${ns}::$x {} ::mklite::$x
            }
        }
    }

    proc debug {args} {
        puts ">>> [list $args]"
        set r [uplevel 1 $args]
        set s [regsub -all {[^ -~]} $r ?]
        puts " << [string length $r]: [string range $s 0 49]"
        return $r
    }

    proc mk_obj {path} {
        variable mkdb
        # memoize last result (without row number), it's likely to be used again
        set pre [regsub {!\d+$} $path {}]
        if {$mkdb(?) eq $pre} { return $mkdb(:) }
        set n 0
        foreach {x y} [regsub -all {[:.!]} :$path { & }] {
            switch -- $x {
                : { set r $mkdb($y) }
                ! { set n $y }
                . { if {[catch { vlerq get $r $n $y } r]} { return 0 } }
            }
        }
        set mkdb(?) $pre
        set mkdb(:) $r
        return $r
    }

# partial emulation of the mk::* commands

    proc file {cmd args} {
        variable mkdb
        variable mkpath
        set db [lindex $args 0]
        if {$db eq ""} { return [array get mkpath] }
        set file [lindex $args 1]
        switch $cmd {
            open {
                set mkdb(?) ""
                if {$file ne ""} {
                    set mkdb($db) [vlerq open $file]
                } else {
                    set mkdb($db) 0
                }
                set mkpath($db) $file
                return $db 
            }
            load {
                fconfigure $file -translation binary
                set mkdb($db) [vlerq load [read $file]]
                return $db 
            }
            close {
                set mkdb(?) ""
                unset mkdb($db) mkpath($db)
                return 
            }
            views {
                return [vlerq get $mkdb($db) @ * 0]
            }
        }
        error "mkfile $cmd?"
    }

    proc view {cmd path args} {
        set a1 [lindex $args 0]
        switch $cmd {
            info {
                return [vlerq get [mk_obj $path] @ * 0]
            }
            layout {
                set layout "NOTYET"
                if {[llength $args] > 0 && $layout != $a1} {
                    #error "view restructuring not supported"
                }
                return $layout
            }
            size {
                set len [vlerq get [mk_obj $path] #]
                if {[llength $args] > 0 && $len != $a1} {
                    error "view resizing not supported"
                }
                return $len
            }
            default { error "mkview $cmd?" }
        }
    }

    proc cursor {cmd cursor args} {
        upvar $cursor v
        switch $cmd {
            create {
                NOTYET
            }
            incr {
                NOTYET
            }
            pos -
            position {
                if {$args != ""} {
                    unset v
                    regsub {!-?\d+$} $v {} v
                    append v !$args
                    return $args
                }
                if {![regexp {\d+$} $v n]} {
                    set n -1
                }
                return $n
            }
            default { error "mkcursor $cmd?" }
        }
    }

    proc get {path args} {
        set vw [mk_obj $path]
        set row [regsub {^.*!} $path {}]
        set sized 0
        if {[lindex $args 0] eq "-size"} {
            incr sized
            set args [lrange $args 1 end]
        }
        set ids 0
        if {[llength $args] == 0} {
            incr ids
            set args [vlerq get $vw @ * 0]
        }
        set r {}
        foreach x $args {
            if {$ids} { lappend r $x }
            set v [vlerq get $vw $row $x]
            if {$sized} { set v [string length $v] }
            lappend r $v
        }
        if {[llength $args] == 1} { set r [lindex $r 0] }
        return $r
    }

    proc loop {cursor path args} {
        upvar $cursor v
        #unset -nocomplain v ;# avoids errors if v already exists as array
        if {[llength $args] == 0} {
            set args [list $path]
            set path $v
            regsub {!-?\d+$} $path {} path
        }
        set first [lindex $args 0]
        set last [lindex $args 1]
        switch [llength $args] {
            1 { set first 0
                    set limit [vlerq get [mk_obj $path] #]
                    set step 1 }
            2 { set limit [vlerq get [mk_obj $path] #]
                    set step 1 }
            3 { set step 1 }
            4 { set step [lindex $args 2] }
            default { error "mkloop arg count?" }
        }
        set body [lindex $args end]
        set code 0
        for {set i $first} {$i < $limit} {incr i $step} {
            set v $path!$i
            set code [catch [list uplevel 1 $body] err]
            switch $code {
                1 -
                2 { return -code $code $err }
                3 { break }
            }
        }
    }

    # from http://wiki.tcl.tk/43
    proc _lreverse L {
         set res {}
         set i [llength $L]
         #while {[incr i -1]>=0} {lappend res [lindex $L $i]}
         while {$i} {lappend res [lindex $L [incr i -1]]} ;# rmax
         set res
    } ;# RS, tuned 10% faster by [rmax]

    proc select {path args} {
        set vw [mk_obj $path]
        set n [vlerq get $vw #]
        set r {}
        for {set i 0} {$i < $n} {incr i} { lappend r $i }
        set n [llength $args]
        set sorts {}
        for {set i 0} {$i < $n} {incr i} {
            set match std
            switch -- [lindex $args $i] {
                -sort    { lappend sorts [lindex $args [incr i]]; continue }
                -rsort   { lappend sorts - [lindex $args [incr i]]; continue }
                -first   { set first [lindex $args [incr i]]; continue }
                -count   { set count [lindex $args [incr i]]; continue }
                -glob    { set match glob; incr i }
                -globnc  { set match globnc; incr i }
                -keyword { set match keyword; incr i }
            }
            set cols [lindex $args $i]
            set k [lindex $args [incr i]]
            set kwre "\\m$k"
            # could use loop -collect, might be faster
            set r2 {}
            foreach x $r {
                foreach c $cols {
                    set v [vlerq get $vw $x $c]
                    switch $match {
                        glob    { set ok [string match $k $v] }
                        globnc  { set ok [string match -nocase $k $v] }
                        keyword { set ok [regexp -nocase $kwre $v] }
                        default { set ok [expr {$k eq $v}] }
                    }
                    if {$ok} { lappend r2 $x; break }
                }
            }
            set r $r2
        }
        if {[llength $sorts]} {
            foreach x [_lreverse $sorts] {
                if {$x eq "-"} {
                    set r [_lreverse $r]
                } else {
                    set v [vlerq remap [vlerq tag [vlerq colmap $vw $x] N] $r]
                    set r [vlerq get [vlerq sort $v] * N]
                }
            }
        }
        if {[info exists first]} {
            set r [lrange $r $first end]
        }
        if {[info exists count]} {
            set r [lrange $r 0 [incr count -1]]
        }
        return $r
    }

    proc channel {path name mode} {
        package require vfs ;# TODO: needs vfs, could use "chan create" in 8.5
        if {$mode ne "r"} { error "mkchannel? mode $mode" }
        set fd [vfs::memchan]
        fconfigure $fd -translation binary
        puts -nonewline $fd [get $path $name]
        seek $fd 0
        return $fd
    }
}
vqcore/src_tcl/opdefs_gen.h0000644000076500007650000002221410574360066015702 0ustar  jcwjcw00000000000000/* opdefs_gen.h - generated code, do not edit */

/* 94 definitions generated for Tcl:

  # name       in     out    inline-code
  : drop       U      {}     {}
  : dup        U      UU     {$1 = $0;}
  : imul       II     I      {$0.i *=  $1.i;}
  : nip        UU     U      {$0 = $1;}
  : over       UU     UUU    {$2 = $0;}
  : rot        UUU    UUU    {$3 = $0; $0 = $1; $1 = $2; $2 = $3;}
  : rrot       UUU    UUU    {$3 = $2; $2 = $1; $1 = $0; $0 = $3;}
  : swap       UU     UU     {$2 = $0; $0 = $1; $1 = $2;}
  : tuck       UU     UUU    {$1 = $2; $0 = $1; $2 = $0;}
  
  tcl {
    # name       in    out
    : Def        OO     V
    : Deps       O      O
    : Emit       V      O
    : EmitMods   V      O
    : Get        VX     U
    : Load       O      V
    : LoadMods   OV     V
    : Loop       X      O
    : MutInfo    V      O
    : Ref        OX     O
    : Refs       O      I
    : Rename     VO     V
    : Save       VS     I
    : To         OO     O
    : Type       O      O
    : View       X      O
  }
  
  python {
    # name       in    out
  }
  
  ruby {
    # name       in    out
    : AtRow      OI     O
  }
  
  lua {
    # name       in    out
  }
  
  objc {
    # name       in    out
    : At         VIO    O
  }
  
  # name       in    out
  : BitRuns    i      C
  : Data       VX     V
  : Debug      I      I
  : HashCol    SO     C
  : Max        VN     O
  : Min        VN     O
  : Open       S      V
  : ResizeCol  iII    C
  : Set        MIX    V
  : StructDesc V      S
  : Structure  V      S
  : Sum        VN     O
  : Write      VO     I

  # name       in    out  internal-name
  : Blocked    V      V   BlockedView
  : Clone      V      V   CloneView
  : ColMap     Vn     V   ColMapView
  : ColOmit    Vn     V   ColOmitView
  : Coerce     OS     C   CoerceCmd
  : Compare    VV     I   ViewCompare
  : Compat     VV     I   ViewCompat
  : Concat     VV     V   ConcatView
  : CountsCol  C      C   NewCountsColumn
  : CountView  I      V   NoColumnView
  : First      VI     V   FirstView
  : GetCol     VN     C   ViewCol
  : Group      VnS    V   GroupCol
  : HashFind   VIViii I   HashDoFind
  : Ijoin      VV     V   IjoinView
  : GetInfo    VVI    C   GetHashInfo
  : Grouped    ViiS   V   GroupedView
  : HashView   V      C   HashValues
  : IsectMap   VV     C   IntersectMap
  : Iota       I      C   NewIotaColumn
  : Join       VVS    V   JoinView
  : Last       VI     V   LastView
  : Mdef       O      V   ObjAsMetaView
  : Mdesc      S      V   DescToMeta
  : Meta       V      V   V_Meta
  : OmitMap    iI     C   OmitColumn
  : OneCol     VN     V   OneColView
  : Pair       VV     V   PairView
  : RemapSub   ViII   V   RemapSubview
  : Replace    VIIV   V   ViewReplace
  : RowCmp     VIVI   I   RowCompare
  : RowEq      VIVI   I   RowEqual
  : RowHash    VI     I   RowHash
  : Size       V      I   ViewSize
  : SortMap    V      C   SortMap
  : Step       VIIII  V   StepView
  : StrLookup  Ss     I   StringLookup
  : Tag        VS     V   TagView
  : Take       VI     V   TakeView
  : Ungroup    VN     V   UngroupView
  : UniqueMap  V      C   UniqMap
  : ViewAsCol  V      C   ViewAsCol
  : Width      V      I   ViewWidth
               
  # name       in    out  compound-definition
  : Append     VV     V   {over size swap insert}
  : ColConv    C      C   { }
  : Counts     VN     C   {getcol countscol}
  : Delete     VII    V   {0 countview replace}
  : Except     VV     V   {over swap exceptmap remap}
  : ExceptMap  VV     C   {over swap isectmap swap size omitmap}
  : Insert     VIV    V   {0 swap replace}
  : Intersect  VV     V   {over swap isectmap remap}
  : NameCol    V      V   {meta 0 onecol}
  : Names      V      C   {meta 0 getcol}
  : Product    VV     V   {over over size spread rrot swap size repeat pair}
  : Repeat     VI     V   {over size imul 0 1 1 step}
  : Remap      Vi     V   {0 -1 remapsub}
  : Reverse    V      V   {dup size -1 1 -1 step}
  : Slice      VIII   V   {rrot 1 swap step}
  : Sort       V      V   {dup sortmap remap}
  : Spread     VI     V   {over size 0 rot 1 step}
  : Types      V      C   {meta 1 getcol}
  : Unique     V      V   {dup uniquemap remap}
  : Union      VV     V   {over except concat}
  : UnionMap   VV     C   {swap exceptmap}
  : ViewConv   V      V   { }
  
  # some operators are omitted from restricted execution environments
  unsafe Open Save
*/

  { "open",       "V:S",      OpenCmd_S          },
  { "save",       "I:VS",     SaveCmd_VS         },
#define UNSAFE 2
  { "append",     "V:VV",     AppendCmd_VV       },
  { "bitruns",    "C:i",      BitRunsCmd_i       },
  { "blocked",    "V:V",      BlockedCmd_V       },
  { "clone",      "V:V",      CloneCmd_V         },
  { "coerce",     "C:OS",     CoerceCmd_OS       },
  { "colconv",    "C:C",      ColConvCmd_C       },
  { "colmap",     "V:Vn",     ColMapCmd_Vn       },
  { "colomit",    "V:Vn",     ColOmitCmd_Vn      },
  { "compare",    "I:VV",     CompareCmd_VV      },
  { "compat",     "I:VV",     CompatCmd_VV       },
  { "concat",     "V:VV",     ConcatCmd_VV       },
  { "counts",     "C:VN",     CountsCmd_VN       },
  { "countscol",  "C:C",      CountsColCmd_C     },
  { "countview",  "V:I",      CountViewCmd_I     },
  { "data",       "V:VX",     DataCmd_VX         },
  { "debug",      "I:I",      DebugCmd_I         },
  { "def",        "V:OO",     DefCmd_OO          },
  { "delete",     "V:VII",    DeleteCmd_VII      },
  { "deps",       "O:O",      DepsCmd_O          },
  { "emit",       "O:V",      EmitCmd_V          },
  { "emitmods",   "O:V",      EmitModsCmd_V      },
  { "except",     "V:VV",     ExceptCmd_VV       },
  { "exceptmap",  "C:VV",     ExceptMapCmd_VV    },
  { "first",      "V:VI",     FirstCmd_VI        },
  { "get",        "U:VX",     GetCmd_VX          },
  { "getcol",     "C:VN",     GetColCmd_VN       },
  { "getinfo",    "C:VVI",    GetInfoCmd_VVI     },
  { "group",      "V:VnS",    GroupCmd_VnS       },
  { "grouped",    "V:ViiS",   GroupedCmd_ViiS    },
  { "hashcol",    "C:SO",     HashColCmd_SO      },
  { "hashfind",   "I:VIViii", HashFindCmd_VIViii },
  { "hashview",   "C:V",      HashViewCmd_V      },
  { "ijoin",      "V:VV",     IjoinCmd_VV        },
  { "insert",     "V:VIV",    InsertCmd_VIV      },
  { "intersect",  "V:VV",     IntersectCmd_VV    },
  { "iota",       "C:I",      IotaCmd_I          },
  { "isectmap",   "C:VV",     IsectMapCmd_VV     },
  { "join",       "V:VVS",    JoinCmd_VVS        },
  { "last",       "V:VI",     LastCmd_VI         },
  { "load",       "V:O",      LoadCmd_O          },
  { "loadmods",   "V:OV",     LoadModsCmd_OV     },
  { "loop",       "O:X",      LoopCmd_X          },
  { "max",        "O:VN",     MaxCmd_VN          },
  { "mdef",       "V:O",      MdefCmd_O          },
  { "mdesc",      "V:S",      MdescCmd_S         },
  { "meta",       "V:V",      MetaCmd_V          },
  { "min",        "O:VN",     MinCmd_VN          },
  { "mutinfo",    "O:V",      MutInfoCmd_V       },
  { "namecol",    "V:V",      NameColCmd_V       },
  { "names",      "C:V",      NamesCmd_V         },
  { "omitmap",    "C:iI",     OmitMapCmd_iI      },
  { "onecol",     "V:VN",     OneColCmd_VN       },
  { "pair",       "V:VV",     PairCmd_VV         },
  { "product",    "V:VV",     ProductCmd_VV      },
  { "ref",        "O:OX",     RefCmd_OX          },
  { "refs",       "I:O",      RefsCmd_O          },
  { "remap",      "V:Vi",     RemapCmd_Vi        },
  { "remapsub",   "V:ViII",   RemapSubCmd_ViII   },
  { "rename",     "V:VO",     RenameCmd_VO       },
  { "repeat",     "V:VI",     RepeatCmd_VI       },
  { "replace",    "V:VIIV",   ReplaceCmd_VIIV    },
  { "resizecol",  "C:iII",    ResizeColCmd_iII   },
  { "reverse",    "V:V",      ReverseCmd_V       },
  { "rowcmp",     "I:VIVI",   RowCmpCmd_VIVI     },
  { "roweq",      "I:VIVI",   RowEqCmd_VIVI      },
  { "rowhash",    "I:VI",     RowHashCmd_VI      },
  { "set",        "V:MIX",    SetCmd_MIX         },
  { "size",       "I:V",      SizeCmd_V          },
  { "slice",      "V:VIII",   SliceCmd_VIII      },
  { "sort",       "V:V",      SortCmd_V          },
  { "sortmap",    "C:V",      SortMapCmd_V       },
  { "spread",     "V:VI",     SpreadCmd_VI       },
  { "step",       "V:VIIII",  StepCmd_VIIII      },
  { "strlookup",  "I:Ss",     StrLookupCmd_Ss    },
  { "structdesc", "S:V",      StructDescCmd_V    },
  { "structure",  "S:V",      StructureCmd_V     },
  { "sum",        "O:VN",     SumCmd_VN          },
  { "tag",        "V:VS",     TagCmd_VS          },
  { "take",       "V:VI",     TakeCmd_VI         },
  { "to",         "O:OO",     ToCmd_OO           },
  { "type",       "O:O",      TypeCmd_O          },
  { "types",      "C:V",      TypesCmd_V         },
  { "ungroup",    "V:VN",     UngroupCmd_VN      },
  { "union",      "V:VV",     UnionCmd_VV        },
  { "unionmap",   "C:VV",     UnionMapCmd_VV     },
  { "unique",     "V:V",      UniqueCmd_V        },
  { "uniquemap",  "C:V",      UniqueMapCmd_V     },
  { "view",       "O:X",      ViewCmd_X          },
  { "viewascol",  "C:V",      ViewAsColCmd_V     },
  { "viewconv",   "V:V",      ViewConvCmd_V      },
  { "width",      "I:V",      WidthCmd_V         },
  { "write",      "I:VO",     WriteCmd_VO        },

/* end of generated code */
vqcore/src_tcl/ratcl.tcl0000644000076500007650000001754610633200335015231 0ustar  jcwjcw00000000000000# ratcl.tcl -- Relational algebra ond other utility operators for vlerq

package provide ratcl 4
package require vlerq 4

namespace eval vlerq {}
interp alias {} view {} vlerq view

namespace eval ratcl {
    namespace export vopdef
    
    proc vopdef {name params body} {
        proc ::vlerq::$name $params $body
    }

    vopdef as        {v cmd}  { interp alias {} $cmd {} view $v; return $cmd }
    vopdef asview    {l args} { vlerq def $args $l }
    vopdef collect   {v expr} { uplevel 1 [list view $v loop -collect $expr] }
    vopdef freeze    {v}      { view $v emit | load }
    vopdef index     {v cond} { uplevel 1 [list view $v loop -index $cond] }
    vopdef pick      {v n}    { view $v where {[lindex $n $(#)] != 0} }
    vopdef project   {v args} { view $v colmap $args | unique }
    vopdef use       {v w}    { return $w }
    vopdef where     {v cond} { uplevel 1 [list view $v loop -where $cond] }

    vopdef do {w cmds} {
        upvar 1 _v v
        set v $w
        set x ""
        foreach c [split $cmds \n] {
            append x $c "\n                     "
            if {![info complete $x]} continue
            set x [string trim $x]
            regsub {^#.*} $x {} x
            if {$x eq ""} continue
            set cm "view \$_v $x"
            set v [uplevel 1 $cm]
            set x ""
        }
        set w $v
        unset v
        return $w
    }

    vopdef debug {w cmds} {
        upvar 1 _v v
        set v $w
        puts " rows-in  col  msec  view-operation"
        puts " -------  ---  ----  --------------"
        set x ""
        set w "                                   "
        foreach c [split $cmds \n] {
            append x $c \n $w
            if {![info complete $x]} continue
            set x [string trim $x]
            if {[regexp {^#} $x]} {
                puts [format {%20s %.58s} "" $x]
                set x ""
            }
            switch -- $x {
                "" { }
                ?    { puts "$w ?\n[view $v dump]" }
                default {
                    if {[catch { view $v size } nr]} { set nr "" }
                    if {[catch { view $v width } nc]} { set nc "" }
                    set cm "view \$_v $x"
                    set us [lindex [time {
                        set v [uplevel 1 $cm]
                        catch {view $v size}
                    }] 0]
                    puts [format {%8s %4s %5.0f  %s} \
                                    $nr $nc [expr {$us/1000.0}] $x]
                }
            }
            set x ""
        }
        if {[catch { view $v size } nr]} { set nr " -------" }
        if {[catch { view $v width } nc]} { set nc " ---" }
        puts [format {%8s %4s  ----  --------------} $nr $nc]
        set w $v
        unset v
        return $w
    }

    vopdef dump {vid {maxrows 20}} {
        set n [view $vid size]
        if {[view $vid width] == 0} { return "  ($n rows, no columns)" }
        set i -1
        if {$n > $maxrows} { set vid [view $vid first $maxrows] }
        foreach x [view $vid names] y [view $vid types] {
            set v2 [view $vid onecol [incr i]]
            switch $y {
                B       { set s { "[string length $($x)]b" } }
                V       { set s { "#[view $($x) size]" } }
                default { set s { $($x) } }
            }
            set c [view $v2 collect $s]
            set w [string length $x]
            foreach z $c {
                if {[string length $z] > $w} { set w [string length $z] }
            }
            if {$w > 50} { set w 50 }
            switch $y {
                B - I - L - F - D - V   { append fmt "  " %${w}s }
                default                 { append fmt "  " %-$w.${w}s }
            }
            append hdr "  " [format %-${w}s $x]
            append bar "  " [string repeat - $w]
            lappend d $c
        }
        set r [list $hdr $bar]
        for {set i 0} {$i < $n} {incr i} {
            if {$i >= $maxrows} break
            set cmd [list format $fmt]
            foreach x $d { lappend cmd [regsub -all {[^ -~]} [lindex $x $i] .] }
            lappend r [eval $cmd]
        }
        if {$i < $n} { lappend r [string map {- .} $bar] }
        ::join $r \n
    }

    vopdef html {vid} {
        set names [view $vid names]
        set types [view $vid types]
        set o 
        append o {}
        append o \n {}
        foreach x $names { append o  }
        append o \n
        view $vid loop c {
            append o {
            set i -1
            foreach x $names y $types val [view $vid get $c(#) *] {
                switch $y {
                    b - B   { set z [string length $val]b }
                    v - V   { set z [view $val html] }
                    default { 
                        set z [string map {& &\; < <\; > >\;} $val] 
                    }
                }
                switch $y {
                    s - S - v - V { append o {
            }
            append o \n
        }
        append o 
 $x 
} $c(#) } }
                    default { append o {} }
                }
                append o $z 
\n
    }

    vopdef transpose {v {p x}} {
        set n [vlerq size $v]
        foreach {pn pt} [split ${p}:S :] break
        set m [view $v size | collect { "$pn$(#):$pt" }]
        set c [view $v get @ | collect { [vlerq get $v * $(#)] }]
        view $m def [eval [linsert $c 0 concat]]
    }

    vopdef freq {v i} {
        set n [vlerq iota [vlerq width $v]]
        llength $n ;# force $n to list, avoids assert in CastObjToItem, case 'n'
        set g [vlerq group $v $n _]
        view [vlerq colmap $g $n] pair [view ${i}:I def [vlerq counts $g _]]
    }

    vopdef sorton {v args} {
        set n [view $v size]
        if {[incr n -1] > 0} {
            set dir +
            set cols {}
            # TODO: optimize, i.e. sort more at once and use faster reverse sort
            foreach x $args {
                switch -- $x {
                    + - -       { set dir $x }
                    default { set cols [linsert $cols 0 $dir $x ]}
                }
            }
            foreach {dir col} $cols {
                set c [view $v onecol $col]
                if {$dir eq "-"} {
                    set map [view $v onecol $col | reverse | sortmap | \
                                    asview N:I | reverse | collect {$n-$(N)}]
                } else {
                    set map [view $c sortmap]
                }
                set v [view $v remap $map]
            }
        }
        return $v
    }

    vopdef read {fd {data ""}} {
        fconfigure $fd -translation binary
        while {[string length $data] < 8} {
            append data [::read $fd [expr {8 - [string length $data]}]]
        }
        binary scan $data a3cI hdr ext siz
        switch -- $hdr {
            "JL\x1A" - "LJ\x1A" {
                if {$ext < 0} {
                    set siz [expr {(($ext & 0x3F) << 36) + \
                                    (($siz & 0xFFFFFFFF) << 4)}]
                }
            }
            default { set siz -1 }
        }
        if {$siz < 0} {
            while {![eof $fd]} {
                append data [::read $fd]
            }
        } else {
            incr siz -[string length $data]
            while {$siz > 0} {
                set more [::read $fd $siz]
                append data $more
                incr siz -[string length $more]
            }
            set more ""
        }
        vlerq load $data
    }
}
vqcore/src_tcl/stubs.h0000644000076500007650000000221010611154237014714 0ustar  jcwjcw00000000000000/*
 * stubs.h - Internal stub code, adapted from CritLib
 */

TclStubs               *tclStubsPtr        = NULL;
TclPlatStubs           *tclPlatStubsPtr    = NULL;
struct TclIntStubs     *tclIntStubsPtr     = NULL;
struct TclIntPlatStubs *tclIntPlatStubsPtr = NULL;

static int MyInitStubs (Tcl_Interp *ip) {

    typedef struct HeadOfInterp {
        char                 *result;
        Tcl_FreeProc *freeProc;
        int                     errorLine;
        TclStubs         *stubTable;
    } HeadOfInterp;

    HeadOfInterp *hoi = (HeadOfInterp*) ip;

    if (hoi->stubTable == NULL || hoi->stubTable->magic != TCL_STUB_MAGIC) {
        ip->result = "This extension requires stubs-support.";
        ip->freeProc = TCL_STATIC;
        return 0;
    }

    tclStubsPtr = hoi->stubTable;

    if (Tcl_PkgRequire(ip, "Tcl", "8.1", 0) == NULL) {
        tclStubsPtr = NULL;
        return 0;
    }

    if (tclStubsPtr->hooks != NULL) {
            tclPlatStubsPtr = tclStubsPtr->hooks->tclPlatStubs;
            tclIntStubsPtr = tclStubsPtr->hooks->tclIntStubs;
            tclIntPlatStubsPtr = tclStubsPtr->hooks->tclIntPlatStubs;
    }

    return 1;
}
vqcore/src_tcl/viewobj.c0000644000076500007650000003713410637226473015243 0ustar  jcwjcw00000000000000/*
 * viewobj.c - Implementation of view objects in Tcl.
 */

#include "ext_tcl.h"

#define DEP_DEBUG 0

#define OBJ_TO_VIEW_P(o) ((o)->internalRep.twoPtrValue.ptr1)
#define OBJ_TO_ORIG_P(o) ((o)->internalRep.twoPtrValue.ptr2)

#define OBJ_TO_ORIG_CNT(o)  (((Seq_p) OBJ_TO_ORIG_P(o))->OR_objc)
#define OBJ_TO_ORIG_VEC(o)  ((Object_p*) ((Seq_p) OBJ_TO_ORIG_P(o) + 1))

#define OR_depx     data[0].o
#define OR_objc     data[1].i
#define OR_depc     data[2].i
#define OR_depv     data[3].p

/* forward */
static void SetupViewObj (Object_p, View_p, int objc, Object_p *objv, Object_p);
static void ClearViewObj (Object_p obj);

static void FreeViewIntRep (Tcl_Obj *obj) {
    PUSH_KEEP_REFS

    Assert(((Seq_p) OBJ_TO_ORIG_P(obj))->refs == 1);
    ClearViewObj(obj);
    
    DecRefCount(OBJ_TO_VIEW_P(obj));
    DecRefCount(OBJ_TO_ORIG_P(obj));
    
    POP_KEEP_REFS
}

static void DupViewIntRep (Tcl_Obj *src, Tcl_Obj *dup) {
    Assert(0);
}

static void UpdateViewStrRep (Tcl_Obj *obj) {
    int length;
    const char *string;
    Object_p origobj;
    PUSH_KEEP_REFS
    
    /* TODO: avoid creating a Tcl list and copying the string, use a buffer */
    origobj = Tcl_NewListObj(OBJ_TO_ORIG_CNT(obj), OBJ_TO_ORIG_VEC(obj));
    string = Tcl_GetStringFromObj(origobj, &length);

    obj->bytes = strcpy(ckalloc(length+1), string);
    obj->length = length;

    DecObjRef(origobj);

    POP_KEEP_REFS
}

static char *RefTracer (ClientData cd, Tcl_Interp *interp, const char *name1, const char *name2, int flags) {
    Object_p obj = (Object_p) cd;
    
#if DEBUG+0
    DbgIf(DBG_trace) printf("       rt %p var: %s\n", (void*) obj, name1);
#endif

    if (flags && TCL_TRACE_WRITES) {
        Tcl_UntraceVar2(Interp(), name1, name2,
                        TCL_TRACE_WRITES | TCL_TRACE_UNSETS | TCL_GLOBAL_ONLY,
                        RefTracer, obj);
    }

    InvalidateView(obj);
    DecObjRef(obj);
    return NULL;
}

static int SetViewFromAnyRep (Tcl_Interp *interp, Tcl_Obj *obj) {
    int e = TCL_ERROR, objc, rows;
    Object_p *objv;
    View_p view;
    
    if (Tcl_ListObjGetElements(interp, obj, &objc, &objv) != TCL_OK)
        return TCL_ERROR;

    PUSH_KEEP_REFS

    switch (objc) {

        case 0:
            view = EmptyMetaView();
            SetupViewObj(obj, view, objc, objv, NULL);
            break;

        case 1:
            if (Tcl_GetIntFromObj(interp, objv[0], &rows) == TCL_OK &&
                                                                rows >= 0) {
                view = NoColumnView(rows);
                SetupViewObj(obj, view, objc, objv, NULL);
            } else {
                Object_p o;
                const char *var = Tcl_GetString(objv[0]) + 1;
                
                if (var[-1] != '@')
                    goto FAIL;
                    
#if DEBUG+0
                DbgIf(DBG_trace) printf("svfar %p var: %s\n", (void*) obj, var);
#endif
                o = (Object_p) Tcl_VarTraceInfo(Interp(), var, TCL_GLOBAL_ONLY,
                                                            RefTracer, NULL);
                if (o == NULL) {
                    o = Tcl_GetVar2Ex(interp, var, NULL,
                                        TCL_LEAVE_ERR_MSG | TCL_GLOBAL_ONLY);
                    if (o == NULL)
                        goto FAIL;

                    o = NeedMutable(o);
                    Assert(o != NULL);
                    
                    if (Tcl_TraceVar2(interp, var, 0,
                            TCL_TRACE_WRITES|TCL_TRACE_UNSETS|TCL_GLOBAL_ONLY,
                                            RefTracer, IncObjRef(o)) != TCL_OK)
                        goto FAIL;
                }
                
                view = ObjAsView(o);
                Assert(view != NULL);

                SetupViewObj(obj, view, objc, objv, /*o*/ NULL);
            }
            
            break;

        default: {
            Object_p cmd;
            Tcl_SavedResult state;

            Assert(interp != NULL);
            Tcl_SaveResult(interp, &state);

            cmd = IncObjRef(Tcl_DuplicateObj(obj));
            view = NULL;

            /* def -> cmd namespace name conv can prob be avoided in Tcl 8.5 */
            if (AdjustCmdDef(cmd) == TCL_OK) {
                int ac;
                Object_p *av;
                Tcl_ListObjGetElements(NULL, cmd, &ac, &av);
                /* don't use Tcl_EvalObjEx, it forces a string conversion */
                if (Tcl_EvalObjv(interp, ac, av, TCL_EVAL_GLOBAL) == TCL_OK) {
                    /* result to view, may call EvalIndirectView recursively */
                    view = ObjAsView(Tcl_GetObjResult(interp));
                }
            }

            DecObjRef(cmd);

            if (view == NULL) {
                Tcl_DiscardResult(&state);
                goto FAIL;
            }

            SetupViewObj(obj, view, objc, objv, NULL);
            Tcl_RestoreResult(interp, &state);
        }
    }

    e = TCL_OK;

FAIL:
    POP_KEEP_REFS
    return e;
}

Tcl_ObjType f_viewObjType = {
    "view", FreeViewIntRep, DupViewIntRep, UpdateViewStrRep, SetViewFromAnyRep
};

View_p ObjAsView (Object_p obj) {
    if (Tcl_ConvertToType(Interp(), obj, &f_viewObjType) != TCL_OK)
        return NULL;
    return OBJ_TO_VIEW_P(obj);
}

static void AddDependency (Object_p obj, Object_p child) { 
    Object_p *deps;
    Seq_p origin = OBJ_TO_ORIG_P(obj);
    
#if DEBUG+0
    DbgIf(DBG_deps) printf(" +dep %p %p\n", (void*) obj, (void*) child);
#endif

    if (origin->OR_depv == NULL) 
        origin->OR_depv = calloc(10, sizeof(Object_p));
    
    Assert(origin->OR_depc < 10);
    deps = origin->OR_depv;
    deps[origin->OR_depc++] = child;
}

static void RemoveDependency (Object_p obj, Object_p child) {    
    Object_p *deps;
    Seq_p origin = OBJ_TO_ORIG_P(obj);
    
#if DEBUG+0
    DbgIf(DBG_deps) printf(" -dep %p %p\n", (void*) obj, (void*) child);
#endif

    deps = origin->OR_depv;
    Assert(deps != NULL);
    
    if (deps != NULL) {
        int i;

        /* removed from end in case we're called from the invalidation loop */
        for (i = origin->OR_depc; --i >= 0; )
            if (deps[i] == child)
                break;
        /*printf("  -> i %d n %d\n", i, origin->OR_depc);*/
        
        Assert(i < origin->OR_depc);
        deps[i] = deps[--origin->OR_depc];
            
        if (origin->OR_depc == 0) {
            free(deps);
            origin->OR_depv = NULL;
        }
    }
}

void InvalidateView (Object_p obj) {
    Object_p *deps;
    Seq_p origin = OBJ_TO_ORIG_P(obj);
    
#if DEP_DEBUG+0
    printf("inval %p deps %d refs %d\n",
                    (void*) obj, origin->OR_depc, obj->refCount);
#endif

    if (obj->typePtr != &f_viewObjType)
        return;
    
    deps = origin->OR_depv;
    if (deps != NULL) {
        /* careful, RemoveDependency will remove the item during iteration */
        while (origin->OR_depc > 0) {
            int last = origin->OR_depc - 1;
            InvalidateView(deps[last]);
            Assert(origin->OR_depc <= last); /* make sure count went down */
        }
        Assert(origin->OR_depv == NULL);
    }

#if 1
    Assert(obj->typePtr == &f_viewObjType);
    Tcl_GetString(obj);
    FreeViewIntRep(obj);
    obj->typePtr = NULL;
#else
    /* FIXME: hack to allow changes to list, even when the object is shared! */
    { Object_p nobj = Tcl_NewListObj(OBJ_TO_ORIG_CNT(obj),
                                        OBJ_TO_ORIG_VEC(obj));
        DecRefCount(OBJ_TO_VIEW_P(obj));
        DecRefCount(origin);
        obj->typePtr = nobj->typePtr;
        obj->internalRep = nobj->internalRep;
        nobj->typePtr = NULL;
        DecObjRef(nobj);
        /*Tcl_InvalidateStringRep(obj);*/
    }
#endif
}

#if 0
static void OriginCleaner (Seq_p seq) {
    int i, items = seq->OR_objc;
    const Object_p *objv = (const void*) (seq + 1);

    for (i = 0; i < items; ++i)
        DecObjRef(objv[i]);

    Assert(seq->OR_depc == 0);
    Assert(seq->OR_depv == NULL);
}

static ItemTypes OriginGetter (int row, Item_p item) {
    const Object_p *objv = (const void*) (item->c.seq + 1);
    item->o = objv[row];
    return IT_object;
}
#endif

static struct SeqType ST_Origin = { "origin", NULL, 0, NULL };

static void SetupViewObj (Object_p obj, View_p view, int objc, Object_p *objv, Object_p extradep) {
    int i;
    Object_p *vals;
    Seq_p origin;
    
    origin = NewSequenceNoRef(objc, &ST_Origin, objc * sizeof(Object_p));
    /* data[0] is a pointer to the reference for "@..." references */
    /* data[1] has the number of extra bytes, i.e. objc * sizeof (Seq_p) */
    /* data[2] is the dependency count */
    /* data[3] is the dependency vector if data[2].i > 0 */
    origin->OR_depx = extradep;
    origin->OR_objc = objc;
    vals = (void*) (origin + 1);
    
    for (i = 0; i < objc; ++i)
        vals[i] = IncObjRef(objv[i]);

    if (obj->typePtr != NULL && obj->typePtr->freeIntRepProc != NULL)
        obj->typePtr->freeIntRepProc(obj);
    
    OBJ_TO_VIEW_P(obj) = IncRefCount(view);
    OBJ_TO_ORIG_P(obj) = IncRefCount(origin);
    obj->typePtr = &f_viewObjType;
    
    for (i = 0; i < objc; ++i)
        if (vals[i]->typePtr == &f_viewObjType)
            AddDependency(vals[i], obj);
            
    if (extradep != NULL)
        AddDependency(extradep, obj);
}

static void ClearViewObj (Object_p obj) {
    int i, objc;
    Object_p *objv;
    Seq_p origin = OBJ_TO_ORIG_P(obj);
    
    /* can't have any child dependencies at this stage */
    Assert(origin->OR_depc == 0);
    Assert(origin->OR_depv == NULL);

    objc = OBJ_TO_ORIG_CNT(obj);
    objv = OBJ_TO_ORIG_VEC(obj);
    
    for (i = 0; i < objc; ++i) {
        if (objv[i]->typePtr == &f_viewObjType)
            RemoveDependency(objv[i], obj);
        DecObjRef(objv[i]);
    }
        
    if (origin->OR_depx != NULL)
        RemoveDependency(origin->OR_depx, obj);
}

static Object_p MetaViewAsObj (View_p meta) {
    char typeCh;
    int width, rowNum;
    Object_p result, fieldobj;
    View_p subv;
    Column names, types, subvs;

    names = ViewCol(meta, MC_name);
    types = ViewCol(meta, MC_type);
    subvs = ViewCol(meta, MC_subv);

    result = Tcl_NewListObj(0, NULL);

    width = ViewSize(meta);
    for (rowNum = 0; rowNum < width; ++rowNum) {
        fieldobj = Tcl_NewStringObj(GetColItem(rowNum, names, IT_string).s, -1);

        /* this ignores all but the first character of the type */
        typeCh = *GetColItem(rowNum, types, IT_string).s;

        switch (typeCh) {

            case 'S':
                break;

            case 'V':
                subv = GetColItem(rowNum, subvs, IT_view).v;
                fieldobj = Tcl_NewListObj(1, &fieldobj);
                Tcl_ListObjAppendElement(NULL, fieldobj, MetaViewAsObj(subv));
                break;

            default:
                Tcl_AppendToObj(fieldobj, ":", 1);
                Tcl_AppendToObj(fieldobj, &typeCh, 1);
                break;
        }

        Tcl_ListObjAppendElement(NULL, result, fieldobj);
    }

    return result;
}

Object_p ViewAsObj (View_p view) {
    View_p meta = V_Meta(view);
    int c, rows = ViewSize(view), cols = ViewSize(meta);
    Object_p result;
    struct Buffer buffer;
    
    InitBuffer(&buffer);

    if (meta == V_Meta(meta)) {
        if (rows > 0) {
            ADD_PTR_TO_BUF(buffer, Tcl_NewStringObj("mdef", 4));
            ADD_PTR_TO_BUF(buffer, MetaViewAsObj(view));
        }
    } else {
        if (cols == 0) {
            ADD_PTR_TO_BUF(buffer, Tcl_NewIntObj(rows));
        } else {
            ADD_PTR_TO_BUF(buffer, Tcl_NewStringObj("data", 4));
            ADD_PTR_TO_BUF(buffer, ViewAsObj(meta));
            for (c = 0; c < cols; ++c)
                ADD_PTR_TO_BUF(buffer, ColumnAsObj(ViewCol(view, c)));
        }
    }

    result = Tcl_NewObj();
    Tcl_InvalidateStringRep(result);
    
    SetupViewObj(result, view, BufferFill(&buffer) / sizeof(Object_p),
                                            BufferAsPtr(&buffer, 1), NULL);
    
    ReleaseBuffer(&buffer, 0);
    return result;
}

View_p ObjAsMetaView (Object_p obj) {
    int r, rows, objc;
    Object_p names, types, subvs, *objv, entry, nameobj, subvobj;
    const char *name, *sep, *type;
    View_p view = NULL;

    if (Tcl_ListObjLength(Interp(), obj, &rows) != TCL_OK)
        return NULL;

    names = Tcl_NewListObj(0, 0);
    types = Tcl_NewListObj(0, 0);
    subvs = Tcl_NewListObj(0, 0);

    for (r = 0; r < rows; ++r) {
        Tcl_ListObjIndex(NULL, obj, r, &entry);
        if (Tcl_ListObjGetElements(Interp(), entry, &objc, &objv) != TCL_OK ||
                objc < 1 || objc > 2)
            goto DONE;

        name = Tcl_GetString(objv[0]);
        sep = strchr(name, ':');
        type = objc > 1 ? "V" : "S";

        if (sep != NULL) {
            if (sep[1] != 0) {
                if (strchr("BDFLISV", sep[1]) == NULL)
                    goto DONE;
                type = sep+1;
            }
            nameobj= Tcl_NewStringObj(name, sep - name);
        } else
            nameobj = objv[0];

        if (objc > 1) {
            view = ObjAsMetaView(objv[1]);
            if (view == NULL)
                goto DONE;
            subvobj = ViewAsObj(view);
        } else
            subvobj = Tcl_NewObj();

        Tcl_ListObjAppendElement(NULL, names, nameobj);
        Tcl_ListObjAppendElement(NULL, types, Tcl_NewStringObj(type, -1));
        Tcl_ListObjAppendElement(NULL, subvs, subvobj);
    }

    view = NewView(V_Meta(EmptyMetaView()));
    SetViewCols(view, MC_name, 1, CoerceColumn(IT_string, names));
    SetViewCols(view, MC_type, 1, CoerceColumn(IT_string, types));
    SetViewCols(view, MC_subv, 1, CoerceColumn(IT_view, subvs));
    
DONE:
    DecObjRef(names);
    DecObjRef(types);
    DecObjRef(subvs);
    return view;
}

Object_p NeedMutable (Object_p obj) {
    int objc;
    Object_p *objv;
    View_p view;

    view = ObjAsView(obj);
    if (view == NULL)
        return NULL;
    
    if (IsMutable(view))
        return obj;
    
    objc = OBJ_TO_ORIG_CNT(obj);
    objv = OBJ_TO_ORIG_VEC(obj);
    
    if (objc == 1 && *Tcl_GetString(objv[0]) == '@') {
        const char *var = Tcl_GetString(objv[0]) + 1;
        Object_p o = (Object_p) Tcl_VarTraceInfo(Interp(), var,
                                            TCL_GLOBAL_ONLY, RefTracer, NULL);
        Assert(o != NULL);
        return o;
    }
    
    if (objc > 1 && strcmp(Tcl_GetString(objv[0]), "get") == 0) {
        Object_p origdef, tmp = NeedMutable(objv[1]); /* recursive */
        Assert(tmp != NULL);
        
        origdef = Tcl_NewListObj(objc, objv);
        Tcl_ListObjReplace(NULL, origdef, 1, 1, 1, &tmp);
        return origdef;
    }
    
    return obj;
}

static void ListOneDep (Buffer_p buf, Object_p obj) {
    Object_p o, vec[3];
    
    if (obj->typePtr == &f_viewObjType) {
        View_p view = OBJ_TO_VIEW_P(obj);
        Seq_p seq = ViewCol(view, 0).seq;
        vec[0] = Tcl_NewStringObj(seq != NULL ? seq->type->name : "", -1);
        vec[1] = MetaViewAsObj(V_Meta(view));
        vec[2] = Tcl_NewIntObj(ViewSize(view));
        o = Tcl_NewListObj(3, vec);
    } else if (Tcl_ListObjIndex(NULL, obj, 0, &o) != TCL_OK)
        o = Tcl_NewStringObj("?", 1);

    ADD_PTR_TO_BUF(*buf, o);
}

ItemTypes DepsCmd_O (Item_p a) {
    int i;
    Object_p obj, *objv;
    Seq_p origin;
    struct Buffer buffer;

    obj = a[0].o;
    ObjAsView(obj);
    
    if (obj->typePtr != &f_viewObjType)
        return IT_unknown;
    
    InitBuffer(&buffer);
    
    origin = OBJ_TO_ORIG_P(obj);
    objv = OBJ_TO_ORIG_VEC(obj);
    
    if (origin->OR_depx != NULL)
        ListOneDep(&buffer, origin->OR_depx);
    else
        ADD_PTR_TO_BUF(buffer, Tcl_NewStringObj("-", 1));
    
    for (i = 0; i < origin->OR_depc; ++i)
        ListOneDep(&buffer, objv[i]);
    
    a->o = BufferAsTclList(&buffer);
    return IT_object;
}
vqcore/tests/0000755000076500007650000000000010637717020013124 5ustar  jcwjcw00000000000000vqcore/tests/all.tcl0000755000076500007650000000024410574647554014421 0ustar  jcwjcw00000000000000#!/usr/bin/env tclkit

source [file join [file dir [info script]] initests.tcl]

runAllTests

eval unset [info vars ?]
eval unset [info vars ??]
#puts [info vars *]vqcore/tests/basic.test0000755000076500007650000000277210611154237015116 0ustar  jcwjcw00000000000000#!/usr/bin/env tclkit
# %renumber<^\s*test >%

source [file join [file dir [info script]] initests.tcl]

test 0 {} {
    package require vlerq
} $version

#puts pwd-[pwd]
#puts auto-$auto_path
#puts loaded-[info loaded]

test 1 {} {
    vlerq type ""
} {}

test 2 {} {
    vlerq type [list 1 2 3]
} list

test 3 {} {
    vlerq refs [list 1 2 3]
} 1

test 4 {} -body {
    set v [list 1 2 3]
    vlerq refs $v
} -result 2 -cleanup { unset v }

test 5 {} {
    vlerq viewconv [vlerq def A {a b c}]
} {data {mdef A} {a b c}}

test 6 {0-bit ints} {
    vlerq def A:I {0 0 0}
} {data {mdef A:I} {0 0 0}}

test 7 {1-bit ints} {
    vlerq def A:I {0 1 1 0 1 0 0 0 1}
} {data {mdef A:I} {0 1 1 0 1 0 0 0 1}}

test 8 {2-bit ints} {
    vlerq def A:I {0 1 2 3 2 1 0}
} {data {mdef A:I} {0 1 2 3 2 1 0}}

test 9 {4-bit ints} {
    vlerq def A:I {0 1 14 15 2 13}
} {data {mdef A:I} {0 1 14 15 2 13}}

test 10 {8-bit ints} {
    vlerq def A:I {0 -1 100 -100}
} {data {mdef A:I} {0 -1 100 -100}}

test 11 {16-bit ints} {
    vlerq def A:I {1234 2345 3456}
} {data {mdef A:I} {1234 2345 3456}}

test 12 {32-bit ints} {
    vlerq def A:I {123456 0 -654321}
} {data {mdef A:I} {123456 0 -654321}}

test 13 {64-bit ints} {
    vlerq def A:L {12345678901 23456789012}
} {data {mdef A:L} {12345678901 23456789012}}

test 14 {32-bit floats} {
    vlerq def A:F {1.25 2.5 3.75}
} {data {mdef A:F} {1.25 2.5 3.75}}

test 15 {64-bit floats} {
    vlerq def A:D {1234567.25 2345678.75}
} {data {mdef A:D} {1234567.25 2345678.75}}

::tcltest::cleanupTests
vqcore/tests/bits.test0000644000076500007650000000320510611154237014763 0ustar  jcwjcw00000000000000#!/usr/bin/env tclkit
# %renumber<^\s*test >%

source [file join [file dir [info script]] initests.tcl]

test 0 {} {
    package require vlerq
} $version

test 1 {} {
    vlerq bitruns {}
} {}

test 2 {} {
    vlerq bitruns {0 1 0 0 1 1 1 0}
} {0 1 1 2 3 1}

test 3 {} {
    vlerq bitruns {1 0 1 1 0 0 0 1}
} {1 1 1 2 3 1}

test 4 {} {
    vlerq bitruns [split [string repeat 0 20] ""]
} {0 20}

test 5 {} {
    vlerq bitruns [split [string repeat 01 10] ""]
} {0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1}

test 6 {} {
    vlerq bitruns [split [string repeat 001 10] ""]
} {0 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1}

test 7 {} {
    vlerq bitruns [split [string repeat 00001 10] ""]
} {0 4 1 4 1 4 1 4 1 4 1 4 1 4 1 4 1 4 1 4 1}

test 8 {} {
    vlerq bitruns [split [string repeat 000000001 10] ""]
} {0 8 1 8 1 8 1 8 1 8 1 8 1 8 1 8 1 8 1 8 1}

test 9 {} {
    vlerq bitruns [split [string repeat 0011 10] ""]
} {0 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2}

test 10 {} {
    vlerq bitruns [split [string repeat 0100111 5] ""]
} {0 1 1 2 3 1 1 2 3 1 1 2 3 1 1 2 3 1 1 2 3}

test 11 {} {
    vlerq bitruns [split [string repeat 011000 10] ""]
} {0 1 2 4 2 4 2 4 2 4 2 4 2 4 2 4 2 4 2 4 2 3}

test 12 {} {
    set z [string repeat 0 100]
    vlerq bitruns [split ${z}1${z} ""]
} {0 100 1 100}

test 13 {} {
    set z [string repeat 0 1000]
    vlerq bitruns [split ${z}1${z} ""]
} {0 1000 1 1000}

test 14 {} {
    set z [string repeat 0 10000]
    vlerq bitruns [split ${z}1${z} ""]
} {0 10000 1 10000}

test 15 {} {
    set z [string repeat 0 10000]
    vlerq bitruns [split ${z}1${z}1${z} ""]
} {0 10000 1 10000 1 10000}

unset -nocomplain  z

::tcltest::cleanupTests
vqcore/tests/blocked.test0000644000076500007650000000202710611154237015426 0ustar  jcwjcw00000000000000#!/usr/bin/env tclkit
# %renumber<^\s*test >%

source [file join [file dir [info script]] initests.tcl]

test 0 {} {
    package require vlerq
} $version

test 1 {structure of sample mkblk.db file} {
    set bdb [vlerq open data/mkblk.db]
    vlerq structure $bdb
} ((II))

test 2 {blocked view has 3 blocks} {
    vlerq get $bdb 0 bv #
} 4

test 3 {blocked view structure and size} {
    set v [vlerq blocked [vlerq get $bdb 0 bv]]
    list [vlerq names $v] [vlerq structure $v] [vlerq size $v]
} {{k1 k2} II 2500}

test 4 {block sizes} {
    vlerq counts [vlerq get $bdb 0 bv] _B
} {999 999 500 2}

test 5 {contents of last block} {
    vlerq get $bdb 0 bv -1 _B *
} {{999 -999} {1999 -1999}}

test 6 {blocked view access} {
    foreach x {0 1 998 999 1000 1998 1999 2000 2498 2499} {
      lappend k1 [vlerq get $v $x k1]
      lappend k2 [vlerq get $v $x k2]
    }
    list $k1 $k2
} {{0 1 998 999 1000 1998 1999 2000 2498 2499}\
     {0 -1 -998 -999 -1000 -1998 -1999 -2000 -2498 -2499}}

unset -nocomplain v x k1 k2

::tcltest::cleanupTests
vqcore/tests/column.test0000644000076500007650000000355010611154237015322 0ustar  jcwjcw00000000000000#!/usr/bin/env tclkit
# %renumber<^\s*test >%

source [file join [file dir [info script]] initests.tcl]

test 0 {} {
    package require vlerq
} $version

test 1 {} {
    vlerq colconv {}
} {}

test 2 {} {
    vlerq type [vlerq colconv {}]
} column

test 3 {} {
    vlerq colconv {1 2 3}
} {1 2 3}

test 4 {} {
    vlerq type [vlerq colconv {1 2 3}]
} column

test 5 {} {
    vlerq coerce {} I
} {}

test 6 {} {
    vlerq coerce {0 1 1000 -0 -1 -1000} I
} {0 1 1000 0 -1 -1000}

test 7 {} {
    vlerq coerce {a aa "" 0 1 A AA "" -0 -1} S
} {a aa {} 0 1 A AA {} -0 -1}

test 8 {} {
    vlerq iota 0
} {}

test 9 {} {
    vlerq iota 5
} {0 1 2 3 4}

test 10 {} {
    vlerq omitmap {2 3 7} 9
} {0 1 4 5 6 8}

test 11 {} {
    # 2007-02-06 new, allow unsorted map
    vlerq omitmap {2 7 3} 9
} {0 1 4 5 6 8}

test 12 {} {
    vlerq getcol [vlerq def A {a b c}] 0
} {a b c}
    
test 13 {} {
    vlerq getcol [vlerq def A {a b c}] -1
} {a b c}
    
test 14 {} {
    vlerq getcol [vlerq def A {a b c}] A
} {a b c}
    
test 15 {} {
    vlerq getcol [vlerq def A:I {1 2 3}] A
} {1 2 3}
    
test 16 {} {
    vlerq getcol [vlerq def {A B} {a A b B c C}] 0
} {a b c}
    
test 17 {} {
    vlerq getcol [vlerq def {A B} {a A b B c C}] 1
} {A B C}
    
test 18 {} {
    vlerq getcol [vlerq def {A B} {a A b B c C}] -2
} {a b c}
    
test 19 {} {
    vlerq getcol [vlerq def {A B} {a A b B c C}] -1
} {A B C}
    
test 20 {} {
    vlerq getcol [vlerq def {A B} {a A b B c C}] A
} {a b c}
    
test 21 {} {
    vlerq getcol [vlerq def {A B} {a A b B c C}] B
} {A B C}

test 22 {} {
    vlerq resizecol {0 11 22 33 44 55} 3 2
} {0 11 22 0 0 33 44 55}

test 23 {} {
    set v [vlerq resizecol {0 11 22 33 44 55} 2 -3]
} {0 11 55}

test 24 {} {
    set v [vlerq resizecol $v 2 7 ]
} {0 11 0 0 0 0 0 0 0 55}

test 25 {} {
    set v [vlerq resizecol $v 1 -8]
} {0 55}

unset -nocomplain v

::tcltest::cleanupTests
vqcore/tests/commit.test0000644000076500007650000001460710611154237015322 0ustar  jcwjcw00000000000000#!/usr/bin/env tclkit
# %renumber<^\s*test >%

source [file join [file dir [info script]] initests.tcl]
set tmp [makeDirectory testfiles.tmp]

test 0 {load extension} {
    package require vlerq
} $version

test 1 {} {
    set v [vlerq def A a]
    set e [vlerq emit $v]
    string length $e
} 38

test 2 {} {
    binary scan $e H* w
    regsub -all {..} [string replace $w 0 3 4?4?] {& }
} {4? 4? 1a 00 00 00 00 26 61 00 02 80 83 41 3a 53\
     81 82 88 81 8a 80 80 00 00 00 00 00 00 16 80 00\
     00 0b 00 00 00 0b }

test 3 {} {
    vlerq load $e
} {data {mdef A} a}

test 4 {} {
    vlerq emitmods $v
} ""

test 5 {} {
    set v [vlerq set $v 0 A x]
} {data {mdef A} x}

test 6 {} {
    vlerq mutinfo $v
} {{data {mdef A} {}}\
     {data {mdef A} x}\
     {data {mdef _:I} 1} 0 1 0 0}

test 7 {} {
    set d [vlerq emitmods $v]
    string length $d
} 43

test 8 {} {
    binary scan $d H* w
    regsub -all {..} [string replace $w 0 3 4?4?] {& }
} {4? 4? 1a 00 00 00 00 2b 01 01 78 00 02 80 80 80\
     81 88 81 81 89 82 8a 81 8c 80 80 80 00 00 00 00\
     00 00 1b 90 00 00 0e 00 00 00 0d }

test 9 {} {
    vlerq loadmods $d [vlerq def A a]
} {data {mdef A} x}

test 10 {} {
    set v [vlerq def {A:I B} {11 a 22 bb 33 ccc}]
    set e [vlerq emit $v]
    string length $e
} 55

test 11 {} {
    binary scan $e H* w
    regsub -all {..} [string replace $w 0 3 4?4?] {& }
} {4? 4? 1a 00 00 00 00 37 0b 16 21 61 00 62 62 00\
     63 63 63 00 32 04 80 87 41 3a 49 2c 42 3a 53 83\
     83 88 89 8b 82 94 80 80 00 00 00 00 00 00 27 80\
     00 00 11 00 00 00 16 }

test 12 {} {
    vlerq load $e
} {data {mdef {A:I B}} {11 22 33} {a bb ccc}}

test 13 {} {
    vlerq emitmods $v
} ""

test 14 {} {
    set v [vlerq set $v 1 A 44 B dd]
} {data {mdef {A:I B}} {11 44 33} {a dd ccc}}

test 15 {} {
    vlerq mutinfo $v
} {{data {mdef {A:I B}} {} {}}\
     {data {mdef {A:I B}} 44 dd}\
     {data {mdef {_:I _:I}} 1 1} {0 0 0} {0 1 0} {0 0 0} 0}

test 16 {} {
    set d [vlerq emitmods $v]
    string length $d
} 50

test 17 {} {
    binary scan $d H* w
    regsub -all {..} [string replace $w 0 3 4?4?] {& }
} {4? 4? 1a 00 00 00 00 32 04 01 2c 01 64 64 00 03\
     80 80 80 81 88 81 81 89 81 8a 81 8b 83 8c 81 8f\
     80 80 80 00 00 00 00 00 00 22 90 00 00 12 00 00\
     00 10 }

test 18 {} {
    vlerq loadmods $d [vlerq def {A:I B} {11 a 22 bb 33 ccc}]
} {data {mdef {A:I B}} {11 44 33} {a dd ccc}}

test 19 {} {
    set v [vlerq def {A:I B} {11 a 22 bb}]
    set w [vlerq insert $v 1 [vlerq def {A:I B} {33 ccc 44 dddd}]]
    set d [vlerq emitmods $w]
    string length $d
} 51

test 20 {} {
    vlerq mutinfo $w
} {{data {mdef {A:I B}} {33 44} {ccc dddd}} 0 0 {0 0} {0 0} {0 1 1 0} {}}

test 21 {} {
    binary scan $d H* w
    regsub -all {..} [string replace $w 0 3 4?4?] {& }
} {4? 4? 1a 00 00 00 00 33 21 2c 63 63 63 00 64 64\
     64 64 00 54 14 80 80 80 80 82 82 88 89 8a 81 93\
     80 81 94 80 00 00 00 00 00 00 23 90 00 00 0e 00\
     00 00 15 }

test 22 {} {
    vlerq loadmods $d $v
} {data {mdef {A:I B}} {11 33 44 22} {a ccc dddd bb}}

test 23 {} {
    set v [vlerq def {A:I B} {11 a 22 bb 33 ccc}]
    set w [vlerq delete $v 1 1]
    set d [vlerq emitmods $w]
    string length $d
} 31

test 24 {} {
    vlerq mutinfo $w
} {{data {mdef {A:I B}} {} {}} 0 0 {0 1 0} {0 0} {0 0} {}}

test 25 {} {
    binary scan $d H* w
    regsub -all {..} [string replace $w 0 3 4?4?] {& }
} {4? 4? 1a 00 00 00 00 1f 04 80 80 81 88 80 80 80\
     00 00 00 00 00 00 0f 90 00 00 06 00 00 00 09 }

test 26 {} {
    vlerq loadmods $d $v
} {data {mdef {A:I B}} {11 33} {a ccc}}

test 27 {} {
    set v [vlerq def {A:I B} {11 a 22 bb 33 ccc}]
    set w [vlerq insert $v 1 [vlerq def {A:I B} {1 1 2 2}]]
    vlerq mutinfo $w
} {{data {mdef {A:I B}} {1 2} {1 2}} 0 0 {0 0 0} {0 0 0} {0 1 1 0 0} {}}

test 28 {} {
    set w [vlerq insert $w 4 [vlerq def {A:I B} {3 3}]]
    vlerq mutinfo $w
} {{data {mdef {A:I B}} {1 2 3} {1 2 3}} 0 0 {0 0 0} {0 0 0} {0 1 1 0 1 0} {}}

test 29 {} {
    vlerq loadmods [vlerq emitmods $w] $v
} {data {mdef {A:I B}} {11 1 2 22 3 33} {a 1 2 bb 3 ccc}}

test 30 {} {
    set v [vlerq def {A:I B} {11 a 22 bb}]
    set w [vlerq insert $v 1 [vlerq def {A:I B} {1 c 2 d 3 e}]]
    vlerq mutinfo $w
} {{data {mdef {A:I B}} {1 2 3} {c d e}} 0 0 {0 0} {0 0} {0 1 1 1 0} {}}

test 31 {} {
    set w [vlerq delete $w 2 1]
    vlerq mutinfo $w
} {{data {mdef {A:I B}} {1 3} {c e}} 0 0 {0 0} {0 0} {0 1 1 0} {}}

test 32 {} {
    vlerq loadmods [vlerq emitmods $w] $v
} {data {mdef {A:I B}} {11 1 3 22} {a c e bb}}

test 33 {} {
    set v [vlerq def {A:I B} {11 a 22 bb 33 ccc 44 dddd 55 eeeee}]
    set w [vlerq delete $v 1 1]
    vlerq mutinfo $w
} {{data {mdef {A:I B}} {} {}} 0 0 {0 1 0 0 0} {0 0 0 0} {0 0 0 0} {}}

test 34 {} {
    set w [vlerq delete $w 2 1]
    vlerq mutinfo $w
} {{data {mdef {A:I B}} {} {}} 0 0 {0 1 0 1 0} {0 0 0} {0 0 0} {}}

test 35 {} {
    vlerq loadmods [vlerq emitmods $w] $v
} {data {mdef {A:I B}} {11 33 55} {a ccc eeeee}}

test 36 {bitmaps are compressed} {
    set v [vlerq tag 10000 A]
    set w [vlerq set $v 5000 A -123]
    set d [vlerq emitmods $w]
    string length $d
} 44 ;# would be 1292 uncompressed

test 37 {} {
    vlerq slice $w 4998 1 5
} {data {mdef A:I} {4998 4999 -123 5001 5002}}

test 38 {} {
    lreplace [vlerq mutinfo $w] 3 5 ? ? ?
} {{data {mdef A:I} {}} {data {mdef A:I} -123} {data {mdef _:I} 1} ? ? ? 0}

test 39 {} {
    binary scan $d H* w
    regsub -all {..} [string replace $w 0 3 4?4?] {& }
} {4? 4? 1a 00 00 00 00 2c 00 04 e2 20 01 38 70 01\
     85 80 80 80 87 88 81 81 8f 81 90 80 80 00 00 00\
     00 00 00 1c 90 00 00 0b 00 00 00 11 }

test 40 {} {
    vlerq slice [vlerq loadmods $d $v] 4998 1 5
} {data {mdef A:I} {4998 4999 -123 5001 5002}}

test 41 {} {
    set v [vlerq def {A B} {a A b B c C d D e E}]
    set w [vlerq set [vlerq set $v 3 A 3] 1 B 1]
    set d [vlerq emitmods $w]
    string length $d
} 54

test 42 {set high row, then low row} {
    vlerq mutinfo $w
} {{data {mdef {A B}} {} {}}\
     {data {mdef {A B}} {b 3} {1 D}}\
     {data {mdef {_:I _:I}} {0 1} {1 0}}\
     {0 0 0 0 0} {0 1 0 1 0} {0 0 0 0 0} {1 0}}

test 43 {} {
    binary scan $d H* w
    regsub -all {..} [string replace $w 0 3 4?4?] {& }
} {4? 4? 1a 00 00 00 00 36 0a 10 33 00 02 01 31 00\
     02 80 80 80 81 88 82 81 89 82 8a 81 8c 80 81 8d\
     82 8e 81 90 80 80 80 00 00 00 00 00 00 26 90 00\
     00 15 00 00 00 11 }

test 44 {} {
    vlerq loadmods $d $v
} {data {mdef {A B}} {a b c 3 e} {A 1 C D E}}

unset -nocomplain d e v w

::tcltest::cleanupTests
vqcore/tests/emit.test0000644000076500007650000001447510611154237014773 0ustar  jcwjcw00000000000000#!/usr/bin/env tclkit
# %renumber<^\s*test >%

source [file join [file dir [info script]] initests.tcl]
set tmp [makeDirectory testfiles.tmp]

test 0 {load extension} {
    package require vlerq
} $version

test 1 {} {
    set v [vlerq emit 123]
    string length $v
} 27

test 2 {} {
    vlerq load $v
} 123

test 3 {} -body {
    binary scan $v H* w
    regsub -all {..} $w {& }
} -match glob -result {4? 4? 1a 00 00 00 00 1b 80 80 fb 80 00 00 00 00\
                         00 00 0b 80 00 00 03 00 00 00 08 }
test 4 {} {
    set fd [open $tmp/t1.db w]
    fconfigure $fd -translation binary
    set r [vlerq write 124 $fd]
    close $fd
    set r
} 27
    
test 5 {} {
    vlerq open $tmp/t1.db
} 124
    
test 6 {} {
    vlerq save 125 $tmp/t2.db
} 27
    
test 7 {} {
    vlerq open $tmp/t2.db
} 125
    
test 8 {} {
    set v [vlerq emit [vlerq def A {a b c}]]
    string length $v
} 42

test 9 {} {
    vlerq load $v
} {data {mdef A} {a b c}}

test 10 {} -body {
    binary scan $v H* w
    regsub -all {..} $w {& }
} -match glob -result {4? 4? 1a 00 00 00 00 2a 61 00 62 00 63 00 2a 80\
                         83 41 3a 53 83 86 88 81 8e 80 80 00 00 00 00 00\
                         00 1a 80 00 00 0b 00 00 00 0f }
test 11 {} {
    set fd [open $tmp/t3.db w]
    fconfigure $fd -translation binary
    set r [vlerq write [vlerq def A {a b d}] $fd]
    close $fd
    set r
} 42

test 12 {} {
    vlerq open $tmp/t3.db
} {data {mdef A} {a b d}}
    
test 13 {} {
    vlerq save [vlerq def A {a b e}] $tmp/t4.db
} 42

test 14 {} {
    vlerq open $tmp/t4.db
} {data {mdef A} {a b e}}

test 15 {fix binary input conversion: used Tcl string i.s.o. bytearray} {
    binary scan [vlerq emit [vlerq def A:B \xAB\xAC\xAD\xAE\xAF]] H* w
    regsub -all {..} [string replace $w 0 3 4?4?] {& }
} {4? 4? 1a 00 00 00 00 29 ab ac ad ae af 05 80 83\
     41 3a 42 81 85 88 81 8d 80 80 00 00 00 00 00 00\
     19 80 00 00 0b 00 00 00 0e }
    
test 16 {fix to preserve null bytes inside B fields} {
    binary scan [vlerq emit [vlerq def A:B \xAB\x00\xAC\x00\xAD]] H* w
    regsub -all {..} [string replace $w 0 3 4?4?] {& }
} {4? 4? 1a 00 00 00 00 29 ab 00 ac 00 ad 05 80 83\
     41 3a 42 81 85 88 81 8d 80 80 00 00 00 00 00 00\
     19 80 00 00 0b 00 00 00 0e }

test 17 {} {
    set v [vlerq group [vlerq def A {a aa aaa}] {} v] 
    set w [vlerq group 123 {} w] 
    set x [vlerq group [vlerq def {B C} {b c bb cc}] {} x] 
    set y [vlerq pair $v [vlerq pair $w $x]]
} {data {mdef {{v A} {w {}} {x {B C}}}} {{data {mdef A} {a aa aaa}}}\
                                          123\
                                          {{data {mdef {B C}} {b bb} {c cc}}}}
test 18 {} {
    set z [vlerq emit $y]
    binary scan $z H* w
    regsub -all {..} [string replace $w 0 3 4?4?] {& }
} {4? 4? 1a 00 00 00 00 63 61 00 61 61 00 61 61 61\
     00 32 04 80 83 89 88 82 91 80 80 80 fb 62 00 62\
     62 00 32 63 00 63 63 00 32 80 82 85 9d 81 a2 80\
     85 a3 81 a8 80 80 95 76 5b 41 3a 53 5d 2c 77 3a\
     56 2c 78 5b 42 3a 53 2c 43 3a 53 5d 81 87 93 83\
     9a 8c a9 80 00 00 00 00 00 00 53 80 00 00 1e 00\
     00 00 35 }
     
test 19 {} {
    vlerq load $z
} {data {mdef {{v A} {w {}} {x {B C}}}} {{data {mdef A} {a aa aaa}}}\
                                          123\
                                          {{data {mdef {B C}} {b bb} {c cc}}}}
test 20 {} {
    set z [vlerq emit [vlerq def {{A B}} [list [vlerq def B {1 2}] \
                                               [vlerq def B {3 4 5}]]]]
    binary scan $z H* w
    regsub -all {..} [string replace $w 0 3 4?4?] {& }
} {4? 4? 1a 00 00 00 00 3d 31 00 32 00 22 33 00 34\
     00 35 00 2a 80 82 84 88 81 8c 80 80 83 86 8d 81\
     93 80 80 86 41 5b 42 3a 53 5d 82 8e 94 80 00 00\
     00 00 00 00 2d 80 00 00 0b 00 00 00 22 }

test 21 {} {
    set z [vlerq emit [vlerq def A:V [list [vlerq def B {1 2}] \
                                           [vlerq def C {3 4 5}]]]]
    binary scan $z H* w
    regsub -all {..} [string replace $w 0 3 4?4?] {& }
} {4? 4? 1a 00 00 00 00 42 31 00 32 00 22 33 00 34\
     00 35 00 2a 80 83 42 3a 53 82 84 88 81 8c 80 80\
     83 43 3a 53 83 86 8d 81 93 80 80 83 41 3a 56 82\
     96 94 80 00 00 00 00 00 00 32 80 00 00 08 00 00\
     00 2a }
                         
test 22 {} {
    vlerq load $z
} {data {mdef {{A {}}}} {{data {mdef B} {1 2}} {data {mdef C} {3 4 5}}}}

test 23 {0-bit ints} {
    vlerq load [vlerq emit [vlerq def A:I {0 0 0}]]
} {data {mdef A:I} {0 0 0}}

test 24 {1-bit ints} {
    vlerq load [vlerq emit [vlerq def A:I {0 1 1 0 1 0 0 0 1}]]
} {data {mdef A:I} {0 1 1 0 1 0 0 0 1}}

test 25 {2-bit ints} {
    vlerq load [vlerq emit [vlerq def A:I {0 1 2 3 2 1 0}]]
} {data {mdef A:I} {0 1 2 3 2 1 0}}

test 26 {4-bit ints} {
    vlerq load [vlerq emit [vlerq def A:I {0 1 14 15 2 13}]]
} {data {mdef A:I} {0 1 14 15 2 13}}
    
test 27 {8-bit ints} {
    vlerq load [vlerq emit [vlerq def A:I {0 -1 100 -100}]]
} {data {mdef A:I} {0 -1 100 -100}}
    
test 28 {16-bit ints} {
    vlerq load [vlerq emit [vlerq def A:I {1234 2345 3456}]]
} {data {mdef A:I} {1234 2345 3456}}
    
test 29 {32-bit ints} {
    vlerq load [vlerq emit [vlerq def A:I {123456 0 -654321}]]
} {data {mdef A:I} {123456 0 -654321}}
    
test 30 {64-bit ints} {
    vlerq load [vlerq emit [vlerq def A:L {12345678901 23456789012}]]
} {data {mdef A:L} {12345678901 23456789012}}

test 31 {32-bit floats} {
    vlerq load [vlerq emit [vlerq def A:F {1.25 2.5 3.75}]]
} {data {mdef A:F} {1.25 2.5 3.75}}

test 32 {64-bit floats} {
    vlerq load [vlerq emit [vlerq def A:D {1234567.25 2345678.75}]]
} {data {mdef A:D} {1234567.25 2345678.75}}

test 33 {} {
    set v [vlerq tag 10000 A]
    vlerq get [vlerq meta $v]
} {A I {}}
    
test 34 {} {
    string length [vlerq emit $v]
} 20035

test 35 {} {
    vlerq def A {1 {}}
} {data {mdef A} {1 {}}}
    
test 36 {F117, 2006-12-16} {
    set z [vlerq emit [vlerq def A {1 {}}]]
    binary scan $z H* w
    regsub -all {..} [string replace $w 0 3 4?4?] {& }
} {4? 4? 1a 00 00 00 00 26 31 00 02 80 83 41 3a 53\
     82 82 88 81 8a 80 80 00 00 00 00 00 00 16 80 00\
     00 0b 00 00 00 0b }
    
test 37 {F117, 2006-12-16} {
    vlerq load [vlerq emit [vlerq def A {1 {}}]]
} {data {mdef A} {1 {}}}
    
test 38 {} {
    vlerq def A {{} 1}
} {data {mdef A} {{} 1}}
    
test 39 {} {
    vlerq load [vlerq emit [vlerq def A {{} 1}]]
} {data {mdef A} {{} 1}}

unset -nocomplain r v w x y z fd
    
::tcltest::cleanupTests
vqcore/tests/error.test0000644000076500007650000001513710611154237015162 0ustar  jcwjcw00000000000000#!/usr/bin/env tclkit
# %renumber<^\s*test >%

source [file join [file dir [info script]] initests.tcl]

test 0 {load extension} {
    package require vlerq
} $version

test 1 {vlerq without command name} -body {
    vlerq
} -returnCodes 1 -result {wrong # args: should be "vlerq command ..."}

test 2 {vlerq with a bad command name} -body {
    vlerq ?
} -returnCodes 1 -result {bad command "?": must be open, save, append, bitruns, blocked, clone, coerce, colconv, colmap, colomit, compare, compat, concat, counts, countscol, countview, data, debug, def, delete, deps, emit, emitmods, except, exceptmap, first, get, getcol, getinfo, group, grouped, hashcol, hashfind, hashview, ijoin, insert, intersect, iota, isectmap, join, last, load, loadmods, loop, max, mdef, mdesc, meta, min, mutinfo, namecol, names, omitmap, onecol, pair, product, ref, refs, remap, remapsub, rename, repeat, replace, resizecol, reverse, rowcmp, roweq, rowhash, set, size, slice, sort, sortmap, spread, step, strlookup, structdesc, structure, sum, tag, take, to, type, types, ungroup, union, unionmap, unique, uniquemap, view, viewascol, viewconv, width, or write}

test 3 {colconv without list} -body {
    vlerq colconv
} -returnCodes 1 -result {wrong # args: should be "vlerq colconv list"}

test 4 {colconv with a non-list} -body {
    vlerq colconv "\{"
} -returnCodes 1 -result {unmatched open brace in list}

test 5 {viewconv without value} -body {
    vlerq viewconv
} -returnCodes 1 -result {wrong # args: should be "vlerq viewconv view"}

test 6 {type without value} -body {
    vlerq type
} -returnCodes 1 -result {wrong # args: should be "vlerq type any"}

test 7 {refs without value} -body {
    vlerq refs
} -returnCodes 1 -result {wrong # args: should be "vlerq refs any"}

test 8 {meta without view} -body {
    vlerq meta
} -returnCodes 1 -result {wrong # args: should be "vlerq meta view"}

test 9 {size without view} -body {
    vlerq size
} -returnCodes 1 -result {wrong # args: should be "vlerq size view"}

test 10 {negative size} {
    catch { vlerq size -123 } ;# TODO: return proper error message
} 1

test 11 {bad variable reference} -body {
    vlerq size @?
} -returnCodes 1 -result {can't read "?": no such variable}

test 12 {ref without varname} -body {
    vlerq ref
} -returnCodes 1 -result {wrong # args: should be "vlerq ref any ..."}

test 13 {to with too few args} -body {
    vlerq to ?
} -returnCodes 1 -result {wrong # args: should be "vlerq to any any"}

test 14 {non-existent view operation} -body {
    vlerq viewconv {foo bar}
} -returnCodes 1 -match glob -result {bad command "foo": must be open, *}

test 15 {locate the load path of the vlerq extension} -body {
    foreach x [info loaded] {
      foreach {path name} $x break
      if {$name eq "Vlerq"} break
    }
    set path
    # match either a reasonable real path or the empty string if statically linked
} -match regexp -result {^(.*/libvlerq.*\..*|)$}

test 16 {open is not allowed in safe interpreters} -body {
    set i [interp create -safe]
    load $path Vlerq $i
    catch { $i eval {vlerq open} } msg
    interp delete $i
    set msg
} -match glob -result {bad command "open": must be append, *}
    
test 17 {open should be supported in normal interpreters} {
    catch { vlerq open } msg
    set msg
} {wrong # args: should be "vlerq open string"}

test 18 {open file which does not exist} -body {
    vlerq open blah-blah-blah
} -returnCodes 1 -result {cannot open file: blah-blah-blah}

test 19 {define zero-width view with data} -body {
    vlerq def {} {1 2 3}
} -returnCodes 1 -result {cannot insert in zero-width view}
    
test 20 {define with incorrect number of items} -body {
    vlerq def {A B} {1 2 3}
} -returnCodes 1 -result {item count not a multiple of column width}

test 21 {view cmd without args} -body {
    vlerq view
} -returnCodes 1 -result {wrong # args: should be "view arg ?op ...? ?| ...?"}

test 22 {} -body {
    vlerq view 3 | ?
} -returnCodes 1 -match glob -result {bad command "?": must be open, *}

test 23 {untyped sum} -body {
    set x [vlerq sum [vlerq def A {1 2 3 4}] A]
} -returnCodes 1 -result {} ;# TODO: sum should return an error message

test 24 {} -body {
    vlerq def A:I [list ""]
} -returnCodes 1 -result {expected integer but got ""}
    
test 25 {} -body {
    vlerq def A:I 1.2
} -returnCodes 1 -result {expected integer but got "1.2"}
    
test 26 {} -body {
    vlerq def A:L 2.3
} -returnCodes 1 -result {expected integer but got "2.3"}
    
test 27 {} -body {
    vlerq def A:F a
} -returnCodes 1 -result {expected floating-point number but got "a"}
    
test 28 {} -body {
    vlerq def A:D b
} -returnCodes 1 -result {expected floating-point number but got "b"}

test 29 {} -body {
    vlerq def A { {}? }
} -returnCodes 1 -result \
    {list element in braces followed by "?" instead of space}

test 30 {} -body {
    vlerq data [vlerq mdef A] { {}? }
} -returnCodes 1 -result \
    {list element in braces followed by "?" instead of space}

test 31 {F118, 2006-12-16} -body {
    vlerq get [vlerq def a {1 2 3 4}] 4 a
} -returnCodes 1 -result {row index out of range}
    
test 32 {} -body {
    vlerq get [vlerq def a {1 2 3 4}] -5 a
} -returnCodes 1 -result {row index out of range}
    
test 33 {} -body {
    vlerq get [vlerq def a {1 2 3 4}] 0 1
} -returnCodes 1 -result {column index out of range}
    
test 34 {} -body {
    vlerq get [vlerq def a {1 2 3 4}] 0 -2
} -returnCodes 1 -result {column index out of range}
    
test 35 {} -body {
    vlerq get [vlerq def a {1 2 3 4}] -5 -2
} -returnCodes 1 -result {row index out of range}

test 36 {} -body {
    vlerq mdesc {a]b[,}
} -returnCodes 1 -result {invalid view}

test 37 {} -body {
    vlerq mdef {{a b c}}
} -returnCodes 1 -result {invalid view}

test 38 {} -body {
    vlerq rename
} -returnCodes 1 -result {wrong # args: should be "vlerq rename view any"}

test 39 {} -body {
    vlerq getcol
} -returnCodes 1 -result {wrong # args: should be "vlerq getcol view col"}

test 40 {} -body {
    vlerq group
} -returnCodes 1 \
    -result {wrong # args: should be "vlerq group view col* string"}

test 41 {} -body {
    # F142, 2007-03-02
    vlerq def a:0 1
} -returnCodes 1 -result {invalid view}

test 42 {F150} -body {
    vlerq colmap [vlerq def A {}] B
} -returnCodes 1 -result {colmap: invalid column name}

test 43 {F151 concat} -body {
    set v [vlerq def {A B} {}]
    set w [vlerq def A {}]
    vlerq concat $v $w
} -returnCodes 1 -result {invalid view}
      
test 44 {F151 union} -body {
    vlerq union $v $w
} -returnCodes 1 -result {invalid view}
      
test 45 {incompatible intersect} -body {
    vlerq intersect $v $w
} -returnCodes 1 -result {invalid view}
      
unset -nocomplain v w x i

::tcltest::cleanupTests
vqcore/tests/file.test0000644000076500007650000001422010611154237014740 0ustar  jcwjcw00000000000000#!/usr/bin/env tclkit
# %renumber<^\s*test >%

source [file join [file dir [info script]] initests.tcl]

test 0 {load extension} {
    package require vlerq
} $version

test 1 {} {
    vlerq meta [vlerq open data/lkit-le.db]
} {mdef {{dirs {name parent:I {files {name size:I date:I contents:B}}}}}}

test 2 {} {
    vlerq meta [vlerq open data/lkit-be.db]
} {mdef {{dirs {name parent:I {files {name size:I date:I contents:B}}}}}}

test 3 {} -body {
    set v [vlerq get [vlerq open data/lkit-le.db] 0 0]
} -match glob -result {data *\
    { lib app-listk cgi1.6} {-1 0 1 1}\
    {{data * {main.tcl ChangeLog} {67 167} {1039266154 1046092593} {* *}}\
     {data * {} {} {} {}}\
     {data * {pkgIndex.tcl listk.tcl tcl2html.tcl} {72 2452 5801}\
              {1039266186 1046093102 1046093789} {* * *}}\
     {data * {pkgIndex.tcl cgi.tcl} {532 65885} {1020940611 1020940611} {* *}}}}

test 4 {} {
    list [string length [vlerq get $v 0 2 0 3]] \
         [string length [vlerq get $v 0 2 1 3]] \
         [string length [vlerq get $v 2 2 0 3]] \
         [string length [vlerq get $v 2 2 1 3]] \
         [string length [vlerq get $v 2 2 2 3]] \
         [string length [vlerq get $v 3 2 0 3]] \
         [string length [vlerq get $v 3 2 1 3]]
} {54 130 72 1132 2434 317 15621}
    
test 5 {} -body {
    set w [vlerq get [vlerq open data/lkit-be.db] 0 0]
} -match glob -result {data *\
    { lib app-listk cgi1.6} {-1 0 1 1}\
    {{data * {ChangeLog main.tcl} {167 67} {1046092593 1039266154} {* *}}\
     {data * {} {} {} {}}\
     {data * {listk.tcl pkgIndex.tcl tcl2html.tcl} {2452 72 5801}\
              {1046093102 1039266186 1046093789} {* * *}}\
     {data * {cgi.tcl pkgIndex.tcl} {65885 532} {1020940611 1020940611} {* *}}}}

test 6 {} {
    list [string length [vlerq get $w 0 2 0 3]] \
         [string length [vlerq get $w 0 2 1 3]] \
         [string length [vlerq get $w 2 2 0 3]] \
         [string length [vlerq get $w 2 2 1 3]] \
         [string length [vlerq get $w 2 2 2 3]] \
         [string length [vlerq get $w 3 2 0 3]] \
         [string length [vlerq get $w 3 2 1 3]]
} {130 54 1132 72 2434 15621 317}
    
test 7 {} -body {
    set fd [open data/lkit-le.db]
    fconfigure $fd -translation binary
    set data [read $fd]
    close $fd
    vlerq get [vlerq load $data] 0 0
} -match glob -result {data *\
    { lib app-listk cgi1.6} {-1 0 1 1}\
    {{data * {main.tcl ChangeLog} {67 167} {1039266154 1046092593} {* *}}\
     {data * {} {} {} {}}\
     {data * {pkgIndex.tcl listk.tcl tcl2html.tcl} {72 2452 5801}\
              {1039266186 1046093102 1046093789} {* * *}}\
     {data * {pkgIndex.tcl cgi.tcl} {532 65885} {1020940611 1020940611} {* *}}}}

test 8 {} -body {
    set fd [open data/lkit-be.db]
    fconfigure $fd -translation binary
    set data [read $fd]
    close $fd
    vlerq get [vlerq load $data] 0 0
} -match glob -result {data *\
    { lib app-listk cgi1.6} {-1 0 1 1}\
    {{data * {ChangeLog main.tcl} {167 67} {1046092593 1039266154} {* *}}\
     {data * {} {} {} {}}\
     {data * {listk.tcl pkgIndex.tcl tcl2html.tcl} {2452 72 5801}\
              {1046093102 1039266186 1046093789} {* * *}}\
     {data * {cgi.tcl pkgIndex.tcl} {65885 532} {1020940611 1020940611} {* *}}}}

test 9 {} {
    vlerq structure $v
} SI(SIIB)
    
test 10 {} {
    vlerq structdesc $v
} {name:S,parent:I,files[name:S,size:I,date:I,contents:B]}
    
test 11 {} {
    vlerq compat $v $w
} 1
    
test 12 {} {
    vlerq compare $v $w
} 1
    
test 13 {} {
    vlerq compare $w $v
} -1
    
test 14 {} {
    set r {}
    foreach i {0 1 2 3} {
      lappend r [vlerq compare [vlerq get $v $i 2] [vlerq get $w $i 2]]
    }
    set r
} {1 0 1 1}
    
test 15 {} {
    set r {}
    foreach i {0 1 2 3} {
      lappend r [vlerq compare [vlerq get $w $i 2] [vlerq get $v $i 2]]
    }
    set r
} {-1 0 -1 -1}
    
test 16 {} {
    set r {}
    foreach i {0 1 2 3} {
      lappend r [vlerq compare [vlerq sort [vlerq get $v $i 2]] \
                               [vlerq sort [vlerq get $w $i 2]]]
    }
    set r
} {0 0 0 0}

test 17 {} {
    vlerq open data/gtest.db
} {data {mdef {{frequents {drinker bar perweek:I}}\
                 {likes {drinker beer perday:I}}\
                 {serves {bar beer quantity:I}}}}\
      {{data {mdef {drinker bar perweek:I}}\
         {adam woody sam norm wilt norm lola norm woody pierre}\
         {lolas cheers cheers cheers joes joes lolas lolas lolas frankies}\
         {1 5 5 3 2 1 6 2 1 0}}}\
      {{data {mdef {drinker beer perday:I}}\
         {adam wilt sam norm norm nan woody lola}\
         {bud rollingrock bud rollingrock bud sierranevada pabst mickies}\
         {2 1 2 3 2 1 2 5}}}\
      {{data {mdef {bar beer quantity:I}}\
         {cheers cheers joes joes joes lolas lolas winkos frankies}\
         {bud samaddams bud samaddams mickies mickies pabst rollingrock snafu}\
         {500 255 217 13 2222 1515 333 432 5}}}}
    
test 18 {} {
    set v [vlerq def {A {B C}} [list a [vlerq def C {1 2 3}] \
                                     b [vlerq def C {4 5 6 7}]]]
    vlerq get $v
} {a {data {mdef C} {1 2 3}} b {data {mdef C} {4 5 6 7}}}

test 19 {} {
    vlerq get [vlerq load [vlerq emit $v]]
} {a {data {mdef C} {1 2 3}} b {data {mdef C} {4 5 6 7}}}
    
test 20 {} {
    set v [vlerq def {A B:V} [list a [vlerq def C {1 2 3}] \
                                   b [vlerq def {D E} {4 5 6 7}]]]
    vlerq get $v
} {a {data {mdef C} {1 2 3}} b {data {mdef {D E}} {4 6} {5 7}}}

test 21 {} {
    vlerq meta [vlerq load [vlerq emit $v]]
} {mdef {A {B {}}}}
    
test 22 {} {
    set z [vlerq emit $v]
    binary scan $z H* w
    regsub -all {..} [string replace $w 0 3 4?4?] {& }
} {4? 4? 1a 00 00 00 00 5e 61 00 62 00 22 31 00 32\
     00 33 00 2a 34 00 36 00 22 35 00 37 00 22 80 83\
     43 3a 53 83 86 8d 81 93 80 80 87 44 3a 53 2c 45\
     3a 53 82 84 94 81 98 80 84 99 81 9d 80 80 87 41\
     3a 53 2c 42 3a 56 82 84 88 81 8c 80 9f 9e 80 00\
     00 00 00 00 00 4e 80 00 00 11 00 00 00 3d }
                         
test 23 {} {
    vlerq get [vlerq load [vlerq emit $v]] 0 *
} {a {data {mdef C} {1 2 3}}}

test 24 {} {
    vlerq get [vlerq load [vlerq emit $v]] 1 *
} {b {data {mdef {D E}} {4 6} {5 7}}}

unset -nocomplain r v w i z fd
    
::tcltest::cleanupTests
vqcore/tests/get.test0000644000076500007650000000474610611154237014614 0ustar  jcwjcw00000000000000#!/usr/bin/env tclkit
# %renumber<^\s*test >%

source [file join [file dir [info script]] initests.tcl]

test 0 {load extension} {
    package require vlerq
} $version

test 1 {} {
    set v [vlerq data [vlerq mdef {A B}] {a b c} {d e f}]
    vlerq get $v
} {a d b e c f}
    
test 2 {}  { vlerq get 5 #         } 5 
test 3 {}  { vlerq get 5 *         } {{} {} {} {} {}} 
test 4 {}  { vlerq get 5 * *       } {} 
test 5 {}  { vlerq get 5 * #       } {0 1 2 3 4} 

test 6 {}  { vlerq get 5 @ #       } 0 
test 7 {}  { vlerq get 5 @ * 0     } {} 
test 8 {}  { vlerq get 5 @ *       } {} 
test 9 {}  { vlerq get 5 @ * *     } {} 
test 10 {} { vlerq get 5 @ * #     } {} 
                                    
test 11 {} { vlerq get 5 @ @ #     } 3
test 12 {} { vlerq get 5 @ @ * 0   } {name type subv} 
test 13 {} { vlerq get 5 @ @ * 1   } {S S V} 
test 14 {} { vlerq get 5 @ @ * 2   } {{} {} {}} 
test 15 {} { vlerq get 5 @ @ * -1  } {{} {} {}} 
test 16 {} { vlerq get 5 @ @ * -2  } {S S V} 
test 17 {} { vlerq get 5 @ @ * -3  } {name type subv} 
test 18 {} { vlerq get 5 @ @ *     } {{name S {}} {type S {}} {subv V {}}} 
test 19 {} { vlerq get 5 @ @ * *   } {name S {} type S {} subv V {}} 
test 20 {} { vlerq get 5 @ @ * #   } {0 1 2} 

test 21 {} { vlerq get "" #        } 0
test 22 {} { vlerq get "" * 0      } {} 
test 23 {} { vlerq get "" *        } {} 
test 24 {} { vlerq get "" * *      } {} 
test 25 {} { vlerq get "" * #      } {} 
    
test 26 {} { vlerq get "" @ #      } 3
test 27 {} { vlerq get "" @ * 0    } {name type subv} 
test 28 {} { vlerq get "" @ * 1    } {S S V} 
test 29 {} { vlerq get "" @ * 2    } {{} {} {}} 
test 30 {} { vlerq get "" @ * -1   } {{} {} {}} 
test 31 {} { vlerq get "" @ * -2   } {S S V} 
test 32 {} { vlerq get "" @ * -3   } {name type subv} 
test 33 {} { vlerq get "" @ *      } {{name S {}} {type S {}} {subv V {}}} 
test 34 {} { vlerq get "" @ * *    } {name S {} type S {} subv V {}} 
test 35 {} { vlerq get "" @ * #    } {0 1 2} 

test 36 {} { vlerq get "" @ * name } {name type subv} 
test 37 {} { vlerq get "" @ * type } {S S V} 
test 38 {} { vlerq get "" @ * subv } {{} {} {}} 
    
test 39 {} { vlerq get "" @ 0      } {name name type S subv {}} 
test 40 {} { vlerq get "" @ 1      } {name type type S subv {}} 
test 41 {} { vlerq get "" @ 2      } {name subv type V subv {}} 
    
test 42 {} { vlerq get "" @ # * #  } {0 1 2} 

test 43 {} {
    vlerq get [vlerq def A {a b c}] * #
} {0 1 2}
    
test 43 {} {
    vlerq get [vlerq def A {a b c}] -2 #
} 1
    
::tcltest::cleanupTests
vqcore/tests/hash.test0000644000076500007650000002722510611154237014755 0ustar  jcwjcw00000000000000#!/usr/bin/env tclkit
# %renumber<^\s*test >%

source [file join [file dir [info script]] initests.tcl]

test 0 {} {
    package require vlerq
} $version

test 1 {} {
    vlerq hashcol I {}
} {}

test 2 {} {
    vlerq hashcol I {0 1 10 -0 -1 -10}
} {0 1 10 0 -1 -10}

test 3 {} {
    vlerq hashcol L {0 -0 123456789 12345678901 12345678902}
} {0 0 123456789 -539222985 -539222988}

test 4 {} tcl8.4 {
    vlerq hashcol D {0 -0 12345.6789 12345.678901 12345.678902}
} {0 -2147483648 -1493572489 -1494073142 -1500863666}

test 5 {} tcl8.4 {
    vlerq hashcol F {0 -0 12345.6789 12345.678901 12345.678902}
} {0 -2147483648 1178658487 1178658487 1178658487}

test 6 {} {
    vlerq hashcol S {"" a aa A 0 1 -0}
} {0 698601184 1080305280 -107479360 -938362831 1636964016 1298176885}

test 7 {} {
    vlerq hashcol B {"" a aa A 0 1 -0}
} {3166080 698601184 1080305280 -107479360 -938362831 1636964016 1298176885}

test 8 {} {
    vlerq hashview {}
} {}

test 9 {} {
    vlerq hashview [vlerq meta ""]
} {-236896329 -54087954 589683543}

test 10 {} {
    vlerq rowhash [vlerq meta ""] 1
} -54087954

test 11 {} {
    vlerq rowhash [vlerq def A:B abc] 0
} -307079773

test 12 {} {
    vlerq getinfo {} {} 0
} {{} {0 0 0 0} {}}

test 13 {} {
    set v [vlerq def A:I {1 2 1 2 1 3}]
    vlerq getinfo $v $v 0
} {{0 1 5} {0 0 0 2 0 3 0 1} {1 2 1 2 1 3}}

test 14 {} {
    set v [vlerq def A {a b a b a c}]
    set h [vlerq getinfo $v $v 0]
} {{0 1 5} {2 0 3 1 0 0 0 0}\
     {698601184 -1021039261 698601184 -1021039261 698601184 1554287586}}

test 15 {} {
    eval [linsert $h 0 vlerq hashfind $v 1 $v]
} 1

test 16 {} {
    eval [linsert $h 0 vlerq hashfind [vlerq def A x] 0 $v]
} -1

test 17 {} {
    vlerq getinfo {} {} 1
} {{} {} {}}

test 18 {} {
    set v [vlerq def A:I {1 2 1 2 1 3}]
    vlerq getinfo $v $v 1
} {{0 1 5} {3 5 6} {0 2 4 1 3 5}}

test 19 {} {
    set v [vlerq def A {a b a b a c}]
    vlerq getinfo $v $v 1
} {{0 1 5} {3 5 6} {0 2 4 1 3 5}}

test 20 {} {
    vlerq uniquemap {}
} {}

test 21 {} {
    vlerq uniquemap [vlerq def A:I {1 2 1 2 1 3}]
} {0 1 5}

test 22 {} {
    vlerq uniquemap [vlerq def A:I {1 2 3 4 5 6}]
} {0 1 2 3 4 5}

test 23 {} {
    vlerq uniquemap [vlerq def A {a b a b a c}]
} {0 1 5}

test 24 {} {
    vlerq uniquemap [vlerq def A {a a a a a a}]
} {0}

test 25 {} {
    vlerq uniquemap [vlerq data [vlerq mdef {A B:I}] {a 0 a 0 a -0} \
                                                     {1 0 0 0 -0 0}]
} {0 1 2 5}

test 26 {} {
    vlerq unique [vlerq def A {a b a b a c}]
} {data {mdef A} {a b c}}

test 27 {} {
    vlerq isectmap [vlerq def A {d b a}] [vlerq def A {a b c}]
} {1 2}
    
test 28 {} {
    vlerq intersect [vlerq def A {a b c}] [vlerq def A {d b a}]
} {data {mdef A} {a b}}
    
test 29 {} {
    vlerq except [vlerq def A {a b c d e}] [vlerq def A {d b a}]
} {data {mdef A} {c e}}
    
test 30 {} {
    vlerq union [vlerq def A {a b c}] [vlerq def A {e b a d}]
} {data {mdef A} {a b c e d}}
    
test 31 {} {
    set v [vlerq def A {a b c d e}]
    vlerq getinfo $v $v 1
} {{0 1 2 3 4} {1 2 3 4 5} {0 1 2 3 4}}

test 32 {} {
    set v [vlerq def A {a b b c c c}]
    vlerq getinfo $v $v 1
} {{0 1 3} {1 3 6} {0 1 2 3 4 5}}

test 33 {} {
    set v [vlerq def A {a b a b a c}]
    vlerq getinfo $v $v 1
} {{0 1 5} {3 5 6} {0 2 4 1 3 5}}

test 34 {} {
    set v [vlerq def A {a b c d d}]
    vlerq getinfo $v $v 1
} {{0 1 2 3} {1 2 3 5} {0 1 2 3 4}}

test 35 {} {
    vlerq group [vlerq def A {a b c d e}] 0 G
} {data {mdef {A {G {}}}} {a b c d e} {1 1 1 1 1}}

test 36 {} {
    vlerq group [vlerq def A {a b b c c c}] 0 G
} {data {mdef {A {G {}}}} {a b c} {1 2 3}}

test 37 {} {
    vlerq group [vlerq def A {a b b c c c}] {} G
} {data {mdef {{G A}}} {{data {mdef A} {a b b c c c}}}}
    
test 38 {} {
    vlerq group [vlerq def A {a b a b a c}] 0 G
} {data {mdef {A {G {}}}} {a b c} {3 2 1}}

test 39 {} {
    vlerq group [vlerq def A {a b a b a c}] A G
} {data {mdef {A {G {}}}} {a b c} {3 2 1}}

test 40 {} {
    set v [vlerq group [vlerq def {A B:I} {a 0 b 1 c 1 d 1 d 0}] 0 G]
} {data {mdef {A {G B:I}}} {a b c d} {{data {mdef B:I} 0}\
                                        {data {mdef B:I} 1}\
                                        {data {mdef B:I} 1}\
                                        {data {mdef B:I} {1 0}}}}
test 41 {} {
    vlerq hashcol V [vlerq getcol $v 1]
} {1 0 0 3}
    
test 42 {} {
    vlerq hashcol V [vlerq getcol $v G]
} {1 0 0 3}
    
test 43 {} {
    vlerq getinfo [vlerq def A {a b c}] [vlerq def A {a b c d e a b c d e}] 2
} {{0 1 2} {2 4 6} {0 5 1 6 2 7}}

test 44 {} {
    vlerq getinfo [vlerq def A {a b c}] [vlerq def A {a c a c}] 2
} {{0 1 2} {2 2 4} {0 2 1 3}}

test 45 {} {
    vlerq getinfo [vlerq def A {a b c d}] [vlerq def A {a b c e a b c e}] 2
} {{0 1 2 3} {2 4 6 6} {0 4 1 5 2 6}}

test 46 {} {
    vlerq getinfo [vlerq def A {a b c}] [vlerq def A {d e f}] 2
} {{0 1 2} {0 0 0} {}}

test 47 {} {
    vlerq getinfo [vlerq def A a] [vlerq def A {a b a b a b}] 2
} {0 3 {0 2 4}}

test 48 {} {
    vlerq getinfo [vlerq def A {a a a}] [vlerq def A {a b a b a b}] 2
} {{0 0 0} 3 {0 2 4}}

test 49 {} {
    set v [vlerq def {B C} {c d e f c d d e}]
    set w [vlerq def {B C} {c d c d d e}]
    vlerq getinfo $v $w 2
} {{0 1 0 2} {2 2 3} {0 1 2}}

test 50 {} {
    set v [vlerq def {A B} {}]
    set w [vlerq def {B C} {}]
    vlerq isectmap [vlerq namecol $v] [vlerq namecol $w]
} 1

test 51 {} {
    vlerq isectmap [vlerq namecol $w] [vlerq namecol $v]
} 0

test 52 {} {
    vlerq join [vlerq def A {a b c}] [vlerq def A {a b c d e a b c d e}] J
} {data {mdef {A {J {}}}} {a b c} {2 2 2}}

test 53 {} {
    vlerq join [vlerq def A {a b c}] [vlerq def A {a c a c}] J
} {data {mdef {A {J {}}}} {a b c} {2 0 2}}

test 54 {} {
    vlerq join [vlerq def A {a b c d}] [vlerq def A {a b c e a b c e}] J
} {data {mdef {A {J {}}}} {a b c d} {2 2 2 0}}

test 55 {} {
    vlerq join [vlerq def A {a b c}] [vlerq def A {d e f}] J
} {data {mdef {A {J {}}}} {a b c} {0 0 0}}

test 56 {} {
    vlerq join [vlerq def A a] [vlerq def A {a b a b a b}] J
} {data {mdef {A {J {}}}} a 3}

test 57 {} {
    vlerq join [vlerq def A {a a a}] [vlerq def A {a b a b a b}] J
} {data {mdef {A {J {}}}} {a a a} {3 3 3}}

test 58 {} {
    set v [vlerq data [vlerq mdef {A B}] {a b c} {A B C}]
    set w [vlerq data [vlerq mdef {A C}] {a c a c} {1 3 1 3}]
    vlerq join $v $w J
} {data {mdef {A B {J C}}} {a b c} {A B C} {{data {mdef C} {1 1}}\
                                              {data {mdef C} {}}\
                                              {data {mdef C} {3 3}}}}
test 59 {} {
    vlerq ungroup [vlerq join $v $w J] -1
} {data {mdef {A B C}} {a a c c} {A A C C} {1 1 3 3}}
    
test 60 {} {
    vlerq ungroup [vlerq join $v $w J] J
} {data {mdef {A B C}} {a a c c} {A A C C} {1 1 3 3}}
    
test 61 {} {
    vlerq ijoin $v $w
} {data {mdef {A B C}} {a a c c} {A A C C} {1 1 3 3}}
    
test 62 {} {
    set v [vlerq def {A B C} {a c d a e f e c d a d e}]
    set w [vlerq def {B C D} {c d e c d f d e f}]
    vlerq ijoin $v $w
} {data {mdef {A B C D}} {a a e e a} {c c c c d} {d d d d e} {e f e f f}}

test 63 {} {
    vlerq join [vlerq def A {a b c}] [vlerq def B {A B C}] J
} {data {mdef {A {J B}}} {a b c} {{data {mdef B} {A B C}}\
                                    {data {mdef B} {A B C}}\
                                    {data {mdef B} {A B C}}}}
test 64 {} {
    set v [vlerq data [vlerq mdef {A B}] {a b c} {A B C}]
    vlerq join $v $v J
} {data {mdef {A B {J {}}}} {a b c} {A B C} {1 1 1}}

test 65 {} {
    set v [vlerq def {A B C} {a c d a e f e c d a d e}]
    set w [vlerq def {B C D} {c d e c d f d e f}]
    vlerq join $v $w J
} {data {mdef {A B C {J D}}} {a a e a} {c e c d} {d f d e}\
                               {{data {mdef D} {e f}}\
                                {data {mdef D} {}}\
                                {data {mdef D} {e f}}\
                                {data {mdef D} f}}}
test 66 {} {
    set r {}
    foreach x {a b c d e f g} {
      lappend r [vlerq strlookup $x {b c d e f}]
    }
    set r
} {-1 0 1 2 3 4 -1}

test 67 {} {
    # vlerq cvstrac #38
    vlerq except [vlerq def {a b} {1 2 3 4 1 2}] [vlerq def {a b} {3 4}]
} {data {mdef {a b}} {1 1} {2 2}}
    
test 68 {} {
    vlerq except [vlerq def {a b} {1 2 3 4}] [vlerq def {a b} {3 4}]
} {data {mdef {a b}} 1 2}

set v [vlerq group [vlerq def {a b} {1 2 3 4 5 6 7 8}] a g]

test 69 {} {
    vlerq loop $v -collect { [vlerq rowhash $v $(#)] }
} {-1702861950 -1165893242 -1501528190 1853940110}
     
test 70 {} {
    vlerq getinfo $v $v 0
} {{0 1 2 3} {4 0 0 3 0 0 2 1} {-1702861950 -1165893242 -1501528190 1853940110}}

test 71 {} {
    # bt: failed on 2006-12-02
    set v [vlerq group [vlerq def {a b} {1 2 3 4 5 6 7 8}] a g]
    vlerq get [vlerq except $v [vlerq slice $v 2 2 2]]
} {3 {data {mdef b} 4} 7 {data {mdef b} 8}}

test 72 {} {
    set v [vlerq def {a b} {1 {2 3 4} 2 {3 4 5} 3 4}]
    set w [vlerq loop $v -collect { [vlerq def d $(b)] }]
    set w [vlerq def {{c d}} $w]
    set v [vlerq pair $v $w]
} {data {mdef {a b {c d}}} {1 2 3}\
                             {{2 3 4} {3 4 5} 4}\
                             {{data {mdef d} {2 3 4}}\
                              {data {mdef d} {3 4 5}}\
                              {data {mdef d} 4}}}
test 73 {} {
    vlerq ungroup $v c
} {data {mdef {a b d}} {1 1 1 2 2 2 3}\
                         {{2 3 4} {2 3 4} {2 3 4} {3 4 5} {3 4 5} {3 4 5} 4}\
                         {2 3 4 3 4 5 4}}

test 74 {join ok} {
    vlerq join [vlerq def a {1 3}] [vlerq def {a b} {1 2 3 4}] J
} {data {mdef {a {J b}}} {1 3} {{data {mdef b} 2} {data {mdef b} 4}}}
    
test 75 {join bad: F115} {
    vlerq join [vlerq def a:I {1 3}] [vlerq def {a:I b} {1 2 3 4}] J
} {data {mdef {a:I {J b}}} {1 3} {{data {mdef b} 2} {data {mdef b} 4}}}

test 76 {} {
    set v [vlerq def A {1 2 3 4 5}]
    set w [vlerq def A {4 2 2 6 4}]
    vlerq exceptmap $v $w
} {0 2 4}
    
test 77 {} {
    set v [vlerq def A {4 2 2 6 4}]
    set w [vlerq def A {1 2 3 4 5}]
    vlerq unionmap $v $w
} {0 2 4}

test 78 {} {
    set v [vlerq def {a b c} {1 a b 2 c d}]
    vlerq group $v {a c} g
} {data {mdef {a c {g b}}} {1 2} {b d} {{data {mdef b} a} {data {mdef b} c}}}

test 79 {} {
    # bt: failed on 2007-02-05, see fff/138
    vlerq group $v {c a} g
} {data {mdef {c a {g b}}} {b d} {1 2} {{data {mdef b} a} {data {mdef b} c}}}

test 80 {} {
    vlerq getinfo $v $v 1
} {{0 1} {1 2} {0 1}}

test 81 {} {
    vlerq grouped [vlerq colmap $v b] {1 2} {0 1} g
} {data {mdef {{g b}}} {{data {mdef b} a} {data {mdef b} c}}}

test 82 {} {
    set v [vlerq def {A B C} {a c d a e f e c d a d e}]
    set w [vlerq def {B C D} {c d e c d f d e f}]
    vlerq ijoin $v $w
} {data {mdef {A B C D}} {a a e e a} {c c c c d} {d d d d e} {e f e f f}}

test 83 {} {
    vlerq join $v $w J
} {data {mdef {A B C {J D}}} {a a e a} {c e c d} {d f d e}\
                               {{data {mdef D} {e f}}\
                                {data {mdef D} {}}\
                                {data {mdef D} {e f}}\
                                {data {mdef D} f}}}

test 84 {} {
    vlerq isectmap [vlerq meta $v] [vlerq meta $w]
} {1 2}

test 85 {} {
    vlerq isectmap [vlerq meta $w] [vlerq meta $v]
} {0 1}

test 86 {} {
    # bt: failed on 2007-02-10, see fff/140
    set x [vlerq colmap $v {C A B}]
    vlerq ijoin $x $w
} {data {mdef {C A B D}} {d d d d e} {a a e e a} {c c c c d} {e f e f f}}

test 87 {} {
    vlerq join $x $w J
} {data {mdef {C A B {J D}}} {d f d e} {a a e a} {c e c d}\
                               {{data {mdef D} {e f}}\
                                {data {mdef D} {}}\
                                {data {mdef D} {e f}}\
                                {data {mdef D} f}}}

test 88 {} {
    vlerq isectmap [vlerq meta $x] [vlerq meta $w]
} {0 2}

test 89 {} {
    vlerq isectmap [vlerq meta $w] [vlerq meta $x]
} {0 1}

unset -nocomplain r v w x h
    
::tcltest::cleanupTests
vqcore/tests/indirect.test0000644000076500007650000000425110611154237015625 0ustar  jcwjcw00000000000000#!/usr/bin/env tclkit
# %renumber<^\s*test >%

source [file join [file dir [info script]] initests.tcl]

test 0 {} {
    package require vlerq
} $version

test 1 {} {
    set v [vlerq def A {a b c d e f}]
    vlerq remap $v {}
} {data {mdef A} {}}

test 2 {} {
    vlerq remap $v {1 3 5}
} {data {mdef A} {b d f}}

test 3 {} {
    vlerq remap $v {5 3 1 0 2 4}
} {data {mdef A} {f d b a c e}}

test 4 {} {
    vlerq remap $v {1 -1 -2 4 3 -1 5}
} {data {mdef A} {b b b e d d f}}

test 5 {} {
    vlerq step $v 6 0 1 1
} {data {mdef A} {a b c d e f}}

test 6 {} {
    vlerq step 0 1 1 1 1
} 0

test 7 {} {
    vlerq step $v 5 1 1 1
} {data {mdef A} {b c d e f}}

test 8 {} {
    vlerq step $v 3 0 2 1
} {data {mdef A} {a a b b c c}}

test 9 {} {
    vlerq step $v 6 0 1 2
} {data {mdef A} {a c e a c e}}

test 10 {} {
    vlerq step $v 6 -1 1 -1

} {data {mdef A} {f e d c b a}}

test 11 {} {
    vlerq step $v 12 3 1 1
} {data {mdef A} {d e f a b c d e f a b c}}

test 12 {} {
    vlerq step $v 12 3 1 -1
} {data {mdef A} {d c b a f e d c b a f e}}

test 13 {} {
    vlerq concat [vlerq def A {}] [vlerq def A {1 2 3}]
} {data {mdef A} {1 2 3}}

test 14 {} {
    vlerq concat [vlerq def A {a b c}] [vlerq def A {1 2 3}]
} {data {mdef A} {a b c 1 2 3}}

test 15 {} {
    set v [vlerq data [vlerq mdef {A B}] {a b c} {1 2 3}]
    vlerq meta [vlerq grouped $v {1 2 3} {0 1 2} G]
} {mdef {{G {A B}}}}

test 16 {} {
    vlerq grouped $v {1 2 3} {0 1 2} G
} {data {mdef {{G {A B}}}} {{data {mdef {A B}} a 1}\
                               {data {mdef {A B}} b 2}\
                               {data {mdef {A B}} c 3}}}
test 17 {} {
    set v [vlerq data [vlerq mdef {A B}] {a b c d e f} {1 2 3 4 5 6}]
    vlerq grouped $v {1 3 6} {0 1 2 3 4 5} G
} {data {mdef {{G {A B}}}} {{data {mdef {A B}} a 1}\
                               {data {mdef {A B}} {b c} {2 3}}\
                               {data {mdef {A B}} {d e f} {4 5 6}}}}
test 18 {} {
    vlerq grouped $v {1 3 6} {5 3 4 0 1 2} G
} {data {mdef {{G {A B}}}} {{data {mdef {A B}} f 6}\
                               {data {mdef {A B}} {d e} {4 5}}\
                               {data {mdef {A B}} {a b c} {1 2 3}}}}
unset -nocomplain v

::tcltest::cleanupTests
vqcore/tests/initests.tcl0000644000076500007650000000340110574360066015474 0ustar  jcwjcw00000000000000# common test setup script

#puts "vars: [info vars ?] [info vars ??]"

if {[info exists testsInited]} return

package require Tcl 8.4

if {[lsearch [namespace children] ::tcltest] == -1} {
  package require tcltest 2.2
  namespace import tcltest::*
}

singleProcess true ;# run without forking

testsDirectory [file dirname [info script]]

# if run from the tests directory, move one level up
if {[pwd] eq [testsDirectory]} {
  cd ..
}

temporaryDirectory [pwd]
workingDirectory [file dirname [testsDirectory]]

# TextMate support on Mac OS X: run make before running any test from editor
if {[info exists env(TM_FILENAME)]} {
  if {[catch { exec make } msg]} {
    puts stderr $msg
    exit 1
  }
}

proc readfile {filename} {                                                      
  set fd [open $filename]                                                       
  set data [read $fd]                                                           
  close $fd                                                                     
  return $data                                                                  
}

# extract version number from pkgIndex.tcl
regexp {ifneeded vlerq\s(\S+)\s} [readfile pkgIndex.tcl] - version
unset -

# make sure the pkgIndex.tcl is found
if {[lsearch $auto_path [workingDirectory]] < 0} {
  lappend auto_path [workingDirectory]
}

testConstraint 64bit            [expr {$tcl_platform(wordSize) == 8}]
testConstraint bigendian        [expr {$tcl_platform(byteOrder) eq "bigEndian"}]
testConstraint kitten           [file exists [temporaryDirectory]/kitten.kit]
testConstraint metakit          [expr {![catch { package require Mk4tcl }]}]
testConstraint tcl$tcl_version  1
testConstraint vfs              [expr {![catch { package require vfs }]}]

set testsInited 1
vqcore/tests/kitten.test0000644000076500007650000000222210611154237015316 0ustar  jcwjcw00000000000000#!/usr/bin/env tclkit
# %renumber<^\s*test >%

source [file join [file dir [info script]] initests.tcl]

test 0 {load extension} {
    package require vlerq
} $version

test 1 {load mkclvfs package} vfs {
    if {[file exists src_tcl/mkclvfs.tcl]} {
      source src_tcl/mkclvfs.tcl
    } else {
      source library/mkclvfs.tcl
    }
    package require vfs::mkcl
} 1.5

test 2 {} -constraints {vfs kitten} -body {
    set fs [vfs::mkcl::Mount [temporaryDirectory]/kitten.kit /kitten]
} -match glob -result mkclvfs*

test 3 {} {vfs kitten} {
    lsort -dict [glob -directory /kitten -tails -types f *]
} {ChangeLog main.tcl}

test 4 {} {vfs kitten} {
    lsort -dict [glob -directory /kitten -tails -types d *]
} {doc lib}

test 5 {} -constraints {vfs kitten} -body {
    lsort -dict [glob -directory /kitten/lib -tails -types f *]
} -match glob -result {httpdist.tcl * md5.tcl}

test 6 {} -constraints {vfs kitten} -body {
    lsort -dict [glob -directory /kitten/lib -tails -types d *]
} -match glob -result {ascenc-0.11 autoproxy * tls-1.4 wcb2.8 wikit yeti-0.4}

test 7 {} {vfs kitten} {
    vfs::unmount /kitten
} {}

unset -nocomplain fs

::tcltest::cleanupTests
vqcore/tests/l.large.test0000644000076500007650000000334210611154237015350 0ustar  jcwjcw00000000000000#!/usr/bin/env tclkit
# %renumber<^\s*test >%

# large file tests, skipped by default because they take a lot of time

source [file join [file dir [info script]] initests.tcl]
set tmp [makeDirectory testfiles.tmp]

test 0 {load extension} {
    package require vlerq
} $version

proc bigview {n} {
    vlerq repeat [vlerq group [vlerq def A [vlerq iota $n]] {} _B] $n
}

test 1 {} {
    set v [bigview 10]
    vlerq structdesc $v
} {_B[A:S]}

test 2 {} {
    vlerq size [vlerq blocked $v]
} 100

test 3 {} {
    vlerq save $v $tmp/b1.db
} 346

test 4 {} -body {
    vlerq size [vlerq blocked [vlerq open $tmp/b1.db]]
} -result 100 -cleanup { file delete $tmp/b1.db }

test 5 {} {
    # correct: gives same result on 32b- and 64b on 2006-12-13
    string length [vlerq emit [bigview 7088]]
} 268571360

test 6 {} {
    # wrong: gave different result (268651792) on 32b and 64b on 2006-12-13
    # diff = 16 bytes less
    string length [vlerq emit [bigview 7089]]
} 268651808

test 7 {} {
    set v [bigview 10000]
    vlerq size [vlerq blocked $v]
} 100000000

test 8 {} {
    # wrong: gave different result (539080016) on 32b and 64b on 2006-12-13
    # diff 40160 bytes = 2510x 16 bytes less
    vlerq save $v $tmp/b2.db
} 539120176

test 9 {} -body {
    vlerq size [vlerq blocked [vlerq open $tmp/b2.db]]
} -result 100000000 -cleanup { file delete $tmp/b2.db }

test 10 {} {
    set v [bigview 20000]
    vlerq size [vlerq blocked $v]
} 400000000

test 11 {} 64bit {
    vlerq save $v $tmp/b3.db
} 2378195504

test 12 {} -constraints 64bit -body {
    vlerq size [vlerq blocked [vlerq open $tmp/b3.db]]
} -result 400000000 -cleanup { file delete $tmp/b3.db }

test 13 {} {
    vlerq size [vlerq blocked [bigview 40000]]
} 1600000000

::tcltest::cleanupTests
vqcore/tests/l.leaks.test0000644000076500007650000000135010634205106015347 0ustar  jcwjcw00000000000000#!/usr/bin/env tclkit
# %renumber<^\s*test >%

# memory leaks tests, skipped by default because this may take a lot of time

source [file join [file dir [info script]] initests.tcl]

set cmd {vlerq open data/mkblk.db}
set cmd {vlerq def {A B C} {1 2 3 4 5 6 7 8 9}}
set cmd {vlerq loop [vlerq def A {1 2}] { append a $(A) }; unset a "" }

proc memuse {} {
  set out [exec ps l -p [pid]]
  lindex [split $out \n] 1 [lsearch $out RSS]
}

test 0 {} {
    package require vlerq
} $version

memuse

test 1 {} {
    memuse
} [memuse]

test 2 {} {
    eval $cmd
    return
} {}

test 3 {} {
    eval $cmd
    memuse
} [memuse]

test 4 {} {
    for {set i 0} {$i < 10000} {incr i} {
      eval $cmd
    }
    memuse
} [memuse]

::tcltest::cleanupTests
vqcore/tests/loop.test0000644000076500007650000000461110611154237014775 0ustar  jcwjcw00000000000000#!/usr/bin/env tclkit
# %renumber<^\s*test >%

source [file join [file dir [info script]] initests.tcl]

test 0 {} {
    package require vlerq
} $version

set v [vlerq def {A B C} {1 2 3 11 22 33 111 222 333}]

test 1 {} {
    set i 0
    vlerq loop $v c { incr i }
    set i
} 3

test 2 {} {
    set r {}
    vlerq loop $v c { lappend r $c(#) }
    set r
} {0 1 2}
    
test 3 {} {
    set r {}
    vlerq loop $v c { lappend r $c(B) $c(A) }
    set r
} {2 1 22 11 222 111}

set w [vlerq def A {1 2 3 4 5 6 7 8 9}]

test 4 {} {
    vlerq loop $w c -index 1
} {0 1 2 3 4 5 6 7 8}

test 5 {} {
    vlerq loop $w c -index { $c(A) % 2 }
} {0 2 4 6 8}

test 6 {} {
    vlerq loop $w c -index { $c(A) > 3 && $c(A) < 6 }
} {3 4}

test 7 {} {
    vlerq loop $w c -index { $c(A) == $c(#) + 1 }
} {0 1 2 3 4 5 6 7 8}

test 8 {} {
    vlerq get [vlerq loop $w c -where 1]
} {1 2 3 4 5 6 7 8 9}
    
test 9 {} {
    vlerq get [vlerq loop $w c -where { $c(A) % 2 }]
} {1 3 5 7 9}
    
test 10 {} {
    vlerq get [vlerq loop $w c -where { $c(A) > 3 && $c(A) < 6 }]
} {4 5}
    
test 11 {} {
    vlerq get [vlerq loop $w c -where { $c(A) == $c(#) + 1 }]
} {1 2 3 4 5 6 7 8 9}

test 12 {loop var must end up in current namespace} {
    namespace eval t1 { vlerq loop $w c1 -index { $c1(A) % 2 } }
    list [info exists c1] [array get t1::c1]
} {0 {A 9}}
namespace forget t1

unset c
test 13 {loop with parray} -body {
    vlerq loop [vlerq def {A B C} {1 2 3 11 22 33 111 222 333}] c {parray c}
} -output {}

test 14 {loop on single column} {
    set r {}
    vlerq loop [vlerq def A {1 2 3}] c { lappend r $c(A) }
    set r
} {1 2 3}
unset c

test 15 {try to loop on non-array} {
    set c 1
    catch { vlerq loop [vlerq def A {1 2 3}] c { lappend r $c(A) } } r
    unset c
    set r
} {can't trace "c(#)": variable isn't array}

test 16 {} {
    set r {}
    vlerq loop [vlerq def A {1 2 3}] {
      lappend r x$(A)
      if {$(A) >= 2} break
      lappend r y$(A)
    }
    set r
} {x1 y1 x2}

test 17 {} {
    set r {}
    vlerq loop [vlerq def A {1 2 3}] {
      lappend r x$(A)
      if {$(A) >= 2} continue
      lappend r y$(A)
    }
    set r
} {x1 y1 x2 x3}

test 18 {} {
    set r {}
    set c [catch {
      vlerq loop [vlerq def A {1 2 3}] {
        lappend r x$(A)
        if {$(A) >= 2} { error booh! }
        lappend r y$(A)
      }
    } e]
    lappend r $c $e
} {x1 y1 x2 1 booh!}

unset -nocomplain r c e v w i

::tcltest::cleanupTests
vqcore/tests/m2m.test0000644000076500007650000000301210611154237014511 0ustar  jcwjcw00000000000000#!/usr/bin/env tclkit
# %renumber<^\s*test >%

source [file join [file dir [info script]] initests.tcl]

test 0 {load extension} {
    package require vlerq
} $version

test 1 {load m2mvfs package} vfs {
    if {[file exists src_tcl/m2mvfs.tcl]} {
      source src_tcl/m2mvfs.tcl
    } else {
      source library/m2mvfs.tcl
    }
    package require vfs::m2m
} 1.8

test 2 {} vfs {
    vfs::m2m::Mount "" mem
} {m2m}

test 3 {} vfs {
    ::vfs::filesystem unmount mem
    # TODO: detect repeated mounts, should probably be an error
    vfs::m2m::Mount m2m.tmp mem
} {m2m}

test 4 {} vfs {
    glob -nocomplain mem/*
} {}

test 5 {} -constraints vfs -body {
    set fd [open mem/aa w]
} -match regexp -result {^(rechan\d+|mem\d+)$}

test 6 {} vfs {
    glob -nocomplain mem/*
} mem/aa

test 7 {} vfs {
    file size mem/aa
} 0

test 8 {} vfs {
    puts -nonewline $fd haha
    close $fd
    file size mem/aa
} 4

test 9 {} vfs {
    file mkdir mem/d
} {}

test 10 {} vfs {
    set fd [open mem/d/ff w]
    puts -nonewline $fd wow
    close $fd
    file size mem/d/ff
} 3

test 11 {} vfs {
    set fd [open mem/d/eee w]
    puts -nonewline $fd "Hello world!"
    close $fd
    file size mem/d/eee
} 12

test 12 {} vfs {
    glob mem/*
} {mem/aa mem/d}

test 13 {} vfs {
    glob mem/d/*
} {mem/d/ff mem/d/eee}

test 14 {} vfs {
    file delete m2m.tmp
    vfs::unmount mem
} {}

test 15 {} vfs {
    file size m2m.tmp
} 191

test 16 {} vfs {
    #puts [exec xxd m2m.tmp]
    file delete m2m.tmp
} {}

unset -nocomplain fd

::tcltest::cleanupTests
vqcore/tests/mkcl.test0000644000076500007650000000475610611154237014764 0ustar  jcwjcw00000000000000#!/usr/bin/env tclkit
# %renumber<^\s*test >%

source [file join [file dir [info script]] initests.tcl]

test 0 {load extension} {
    package require vlerq
} $version

test 1 {load mkclvfs package} vfs {
    if {[file exists src_tcl/mkclvfs.tcl]} {
      source src_tcl/mkclvfs.tcl
    } else {
      source library/mkclvfs.tcl
    }
    package require vfs::mkcl
} 1.5

test 2 {} -constraints vfs -body {
    set fs [vfs::mkcl::Mount data/lkit-le.db /try1]
} -match glob -result mkclvfs*

test 3 {} vfs {
    glob /try1/*
} {/try1/main.tcl /try1/ChangeLog /try1/lib}

test 4 {} -constraints vfs -body {
    file stat /try1/lib sb
    puts ""
    parray sb
} -match glob -output {
sb(atime) = 0
sb(ctime) = 0
sb(dev)   = *
sb(gid)   = 0
sb(ino)   = 0
sb(mode)  = 16895
sb(mtime) = 0
sb(nlink) = 3
sb(size)  = 0
sb(type)  = directory
sb(uid)   = 0
}

test 5 {} -constraints vfs -body {
    file stat /try1/ChangeLog sb
    puts ""
    parray sb
} -match glob -output {
sb(atime) = 1046092593
sb(ctime) = 1046092593
sb(dev)   = *
sb(gid)   = 0
sb(ino)   = 0
sb(mode)  = 33279
sb(mtime) = 1046092593
sb(nlink) = 1
sb(size)  = 167
sb(type)  = file
sb(uid)   = 0
}

test 6 {} vfs {
    set fd [open /try1/ChangeLog]
    set data \n
    append data [read $fd]
    close $fd
    set data
} {
2003-02-24  jcw
   * tcl2html.tcl: added Jeff Hobb's code to show tcl file nicely
   * listk.tcl: adjusted to use the above for *.tcl files
   * all: added change log
}

test 7 {} vfs {
    file size /try1/lib/cgi1.6/cgi.tcl
} 65885

test 8 {} vfs {
    vfs::unmount /try1
} {}
    
test 9 {} -constraints vfs -body {
    set fs [vfs::mkcl::Mount data/lkit-be.db /try2]
} -match glob -result mkclvfs*

test 10 {} vfs {
    glob /try2/*
} {/try2/ChangeLog /try2/main.tcl /try2/lib}

test 11 {} -constraints vfs -body {
    file stat /try2/ChangeLog sb
    puts ""
    parray sb
} -match glob -output {
sb(atime) = 1046092593
sb(ctime) = 1046092593
sb(dev)   = *
sb(gid)   = 0
sb(ino)   = 0
sb(mode)  = 33279
sb(mtime) = 1046092593
sb(nlink) = 1
sb(size)  = 167
sb(type)  = file
sb(uid)   = 0
}

test 12 {} vfs {
    set fd [open /try2/ChangeLog]
    set data \n
    append data [read $fd]
    close $fd
    set data
} {
2003-02-24  jcw
   * tcl2html.tcl: added Jeff Hobb's code to show tcl file nicely
   * listk.tcl: adjusted to use the above for *.tcl files
   * all: added change log
}

test 13 {} vfs {
    file size /try2/lib/cgi1.6/cgi.tcl
} 65885

test 14 {} vfs {
    vfs::unmount /try2
} {}

unset -nocomplain fs fd sb
    
::tcltest::cleanupTests
vqcore/tests/mklite.test0000644000076500007650000000741110611154237015312 0ustar  jcwjcw00000000000000#!/usr/bin/env tclkit
# %renumber<^\s*test >%

source [file join [file dir [info script]] initests.tcl]

test 0 {load extension} {
    package require vlerq
} $version

test 1 {load mkclvfs package} {
    if {[file exists src_tcl/mklite.tcl]} {
      source src_tcl/mklite.tcl
    } else {
      source library/mklite.tcl
    }
    package require mklite
} 0.5

test 2 {open mk file} {
    mklite::file open db data/gtest.db -readonly
} db

test 3 {root names via vlerq} {
    vlerq names [vlerq open data/gtest.db]
} {frequents likes serves}

test 4 {root names} {
    mklite::file views db
} {frequents likes serves}

test 5 {mk compatibility layer} {
    mklite::emulateMk4tcl
} {}

test 6 {view sizes} {
    set F db.frequents
    set L db.likes
    set S db.serves
    list [mk::view size $F] [mk::view size $L] [mk::view size $S]
} {10 8 9}

test 7 {view names} {
    list [mk::view info $F] [mk::view info $L] [mk::view info $S]
} {{drinker bar perweek} {drinker beer perday} {bar beer quantity}}

test 8 {get all cols} {
    mk::get $F!2
} {drinker sam bar cheers perweek 5}

test 9 {get all cols sizes} {
    mk::get $F!2 -size
} {drinker 3 bar 6 perweek 1}

test 10 {get one col} {
    mk::get $F!2 bar
} cheers

test 11 {get one col size} {
    mk::get $F!2 -size bar
} 6

test 12 {get several cols} {
    mk::get $F!2 bar drinker
} {cheers sam}

test 13 {get several cols sizes} {
    mk::get $F!2 -size bar drinker
} {6 3}

test 14 {frequents data} {
    set r ""
    mk::loop c $F { append r "  " [mk::get $c drinker bar perweek] \n }
    set r
} { \
  adam lolas 1
  woody cheers 5
  sam cheers 5
  norm cheers 3
  wilt joes 2
  norm joes 1
  lola lolas 6
  norm lolas 2
  woody lolas 1
  pierre frankies 0
}

test 15 {likes data} {
    set r ""
    mk::loop c $L { append r "  " [mk::get $c drinker beer perday] \n }
    set r
} { \
  adam bud 2
  wilt rollingrock 1
  sam bud 2
  norm rollingrock 3
  norm bud 2
  nan sierranevada 1
  woody pabst 2
  lola mickies 5
}

test 16 {serves data} {
    set r ""
    mk::loop c $S { append r "  " [mk::get $c bar beer quantity] \n }
    set r
} { \
  cheers bud 500
  cheers samaddams 255
  joes bud 217
  joes samaddams 13
  joes mickies 2222
  lolas mickies 1515
  lolas pabst 333
  winkos rollingrock 432
  frankies snafu 5
}

test 17 {select} {
    mk::select $F drinker norm
} {3 5 7}

test 18 {select bar} {
    mk::select $F bar lolas
} {0 6 7 8}

test 19 {select glob} {
    mk::select $F -glob bar *e*
} {1 2 3 4 5 9}

test 20 {select globnc} {
    mk::select $F -globnc bar *E*
} {1 2 3 4 5 9}

test 21 {select keyword} {
    mk::select $S -keyword beer M
} {4 5}

test 22 {select multiple or} {
    mk::select $S -glob {bar beer} *e*
} {0 1 2 3 4 5 8}

test 23 {select sort} {
    mk::select $S -sort beer
} {0 2 4 5 6 7 1 3 8}

test 24 {select rsort} {
    mk::select $S -rsort beer
} {8 3 1 7 6 5 4 2 0}

test 25 {select count} {
    mk::select $F -count 2 drinker norm
} {3 5}

test 26 {select first} {
    mk::select $F -first 2 drinker norm
} 7

test 27 {select glob and count} {
    mk::select $F -glob bar *e* -count 3
} {1 2 3}

test 28 {select multiple criteria} {
    mk::select $F bar lolas drinker norm
} 7

test 29 {select nothing} {
    mk::select $F bar maid
} {}

test 30 {select multiple criteria empty} {
    mk::select $F drinker woody bar joes
} {}

test 31 {list of open files} {
    mk::file open
} {db data/gtest.db}

test 32 {} {
    mk::file close db
} {}
    
test 33 {} {
    catch { mk::file close db }
} 1
    
test 34 {} {
    catch { mklite::file views db }
} 1
    
test 35 {load mk file} {
    mklite::file open db
    set fd [open data/gtest.db]
    mklite::file load db $fd
    close $fd
    mklite::file views db
} {frequents likes serves}

test 36 {} {
    mk::file close db
} {}
    
unset -nocomplain c r S F L fd

::tcltest::cleanupTests
vqcore/tests/mutable.test0000644000076500007650000002070710611154237015461 0ustar  jcwjcw00000000000000#!/usr/bin/env tclkit
# %renumber<^\s*test >%

source [file join [file dir [info script]] initests.tcl]

test 0 {} {
    package require vlerq
} $version

test 1 {} {
    vlerq set [vlerq def A {a b c}] 1 A XYZ
} {data {mdef A} {a XYZ c}}

test 2 {} {
    vlerq set [vlerq def A:B {d e f}] 1 A ABC
} {data {mdef A:B} {d ABC f}}

test 3 {} {
    vlerq set [vlerq def A:I {1 2 3}] 1 A 22
} {data {mdef A:I} {1 22 3}}

test 4 {} {
    vlerq set [vlerq def A:L {1 2 3}] 1 A 112233445566
} {data {mdef A:L} {1 112233445566 3}}

test 5 {} {
    vlerq set [vlerq def A:F {1.5 2.5 3.5}] 1 A 4.5
} {data {mdef A:F} {1.5 4.5 3.5}}

test 6 {} {
    vlerq set [vlerq def A:D {1.1 2.2 3.3}] 1 A 4.567890123
} {data {mdef A:D} {1.1 4.567890123 3.3}}

test 7 {} {
    set v [vlerq group [vlerq def {A B} {a A1 a A2 b B1 b B2}] A G]
} {data {mdef {A {G B}}} {a b} {{data {mdef B} {A1 A2}}\
                                  {data {mdef B} {B1 B2}}}}
test 8 {} {
    vlerq set $v 1 G [vlerq def B {1 2 3}]
} {data {mdef {A {G B}}} {a b} {{data {mdef B} {A1 A2}}\
                                  {data {mdef B} {1 2 3}}}}
test 9 {} {
    set v [vlerq def A {a b c d e}]
    vlerq size [vlerq delete $v 1 3]
} 2

test 10 {} {
    vlerq delete $v 1 3
} {data {mdef A} {a e}}

test 11 {} {
    vlerq mutinfo [vlerq delete $v 1 3]
} {{data {mdef A} {}} 0 0 {0 1 1 1 0} {0 0} {0 0} {}}

test 12 {} {
    vlerq delete $v 0 3
} {data {mdef A} {d e}}

test 13 {} {
    vlerq delete $v 2 3
} {data {mdef A} {a b}}

test 14 {} {
    vlerq replace $v 1 3 [vlerq def A {1 2 3}]
} {data {mdef A} {a 1 2 3 e}}

test 15 {} {
    vlerq mutinfo [vlerq replace $v 1 3 [vlerq def A {1 2 3}]]
} {{data {mdef A} {1 2 3}} 0 0 {0 1 1 1 0} {0 0} {0 1 1 1 0} {}}

test 16 {} {
    vlerq append $v [vlerq def A {1 2 3}]
} {data {mdef A} {a b c d e 1 2 3}}

test 17 {} {
    vlerq mutinfo [vlerq append $v [vlerq def A {1 2 3}]]
} {{data {mdef A} {1 2 3}} 0 0 {0 0 0 0 0} {0 0 0 0 0} {0 0 0 0 0 1 1 1} {}}

test 18 {} {
    set v [vlerq insert $v 2 [vlerq def A {1 2 3}]]
} {data {mdef A} {a b 1 2 3 c d e}}

test 19 {} {
    vlerq mutinfo $v
} {{data {mdef A} {1 2 3}} 0 0 {0 0 0 0 0} {0 0 0 0 0} {0 0 1 1 1 0 0 0} {}}

test 20 {} {
    vlerq set $v 3 A zz
} {data {mdef A} {a b 1 zz 3 c d e}}

set v [vlerq def {A B C} {1 2 3 11 22 33 111 222 333}]

test 21 {} {
    set w [vlerq set $v 1 B x22]
} {data {mdef {A B C}} {1 11 111} {2 x22 222} {3 33 333}}

test 22 {} {
    vlerq mutinfo $w
} {{data {mdef {A B C}} {} {} {}}\
     {data {mdef {A B C}} 11 x22 33}\
     {data {mdef {_:I _:I _:I}} 0 1 0} {0 0 0} {0 1 0} {0 0 0} 0}

test 23 {check row count is still 3} {
    vlerq size $w
} 3
    
test 24 {verify new contents} {
    vlerq get $w
} {1 2 3 11 x22 33 111 222 333}
    
test 25 {check v has not changed} {
    vlerq get $v
} {1 2 3 11 22 33 111 222 333}
    
test 26 {insert one row} {
    set w [vlerq insert $v 1 [vlerq def {A B C} {x y z}]]
} {data {mdef {A B C}} {1 x 11 111} {2 y 22 222} {3 z 33 333}}
    
test 27 {} {
    vlerq size $w
} 4
    
test 28 {verify new contents} {
    vlerq get $w
} {1 2 3 x y z 11 22 33 111 222 333}
    
test 29 {check v has not changed} {
    vlerq get $v
} {1 2 3 11 22 33 111 222 333}
    
test 30 {delete one row} {
    set w [vlerq delete $v 1 1]
} {data {mdef {A B C}} {1 111} {2 222} {3 333}}
    
test 31 {} {
    vlerq get $w #
} 2

test 32 {verify new contents} {
    vlerq get $w
} {1 2 3 111 222 333}
    
test 33 {check v has not changed} {
    vlerq get $v
} {1 2 3 11 22 33 111 222 333}

test 34 {} {
    set w [vlerq group $v A G]
    vlerq get $w 0 G
} {data {mdef {B C}} 2 3}

test 35 {set one item in subview} {
    vlerq set [vlerq get $w 0 G] 0 B bb
} {data {mdef {B C}} bb 3}

test 36 {set one item in subview} {
    set w [vlerq group [vlerq set $v 2 A 1] A G]
    vlerq set [vlerq get $w 0 G] 1 B bb
} {data {mdef {B C}} {2 bb} {3 333}}

test 37 {} {
    set v [vlerq def {A B C} {a b c aa bb cc aaa bbb ccc}]
    vlerq set $v 1 A x B y C z
} {data {mdef {A B C}} {a x aaa} {b y bbb} {c z ccc}}

test 38 {} {
    vlerq set [vlerq def {A B C} {a b c aa bb cc}] -1 A xx
} {data {mdef {A B C}} {a xx} {b bb} {c cc}}

test 39 {} {
    set v [vlerq insert [vlerq def A {1 2}] 1 [vlerq def A {a b}]]
} {data {mdef A} {1 a b 2}}

test 40 {} {
    set v [vlerq insert [vlerq def A {1 2}] 1 [vlerq def A {a b}]]
    vlerq append $v [vlerq def A {x y}]
} {data {mdef A} {1 a b 2 x y}}

test 41 {} {
    set v [vlerq insert [vlerq def A {1 2}] 1 [vlerq def A {a b}]]
    vlerq insert $v 0 [vlerq def A {x y}]
} {data {mdef A} {x y 1 a b 2}}

test 42 {} {
    set v [vlerq insert [vlerq def A {1 2}] 1 [vlerq def A {a b}]]
    vlerq insert $v 1 [vlerq def A {x y}]
} {data {mdef A} {1 x y a b 2}}

test 43 {} {
    set v [vlerq insert [vlerq def A {1 2}] 1 [vlerq def A {a b}]]
    vlerq insert $v 2 [vlerq def A {x y}]
} {data {mdef A} {1 a x y b 2}}

test 44 {} {
    set v [vlerq insert [vlerq def A {1 2}] 1 [vlerq def A {a b}]]
    vlerq insert $v 3 [vlerq def A {x y}]
} {data {mdef A} {1 a b x y 2}}

test 45 {} {
    set v [vlerq insert [vlerq def A {1 2}] 1 [vlerq def A {a b}]]
    vlerq insert $v 4 [vlerq def A {x y}]
} {data {mdef A} {1 a b 2 x y}}

test 46 {} {
    set v [vlerq insert [vlerq def A {1 2}] 1 [vlerq def A {a b}]]
    vlerq delete $v 0 1
} {data {mdef A} {a b 2}}

test 47 {} {
    set v [vlerq insert [vlerq def A {1 2}] 1 [vlerq def A {a b}]]
    vlerq delete $v 1 1
} {data {mdef A} {1 b 2}}

test 48 {} {
    set v [vlerq insert [vlerq def A {1 2}] 1 [vlerq def A {a b}]]
    vlerq delete $v 2 1
} {data {mdef A} {1 a 2}}

test 49 {} {
    set v [vlerq insert [vlerq def A {1 2}] 1 [vlerq def A {a b}]]
    vlerq delete $v 3 1
} {data {mdef A} {1 a b}}

test 50 {} {
    set v [vlerq insert [vlerq def A {1 2}] 1 [vlerq def A {a b}]]
    vlerq delete $v 0 2
} {data {mdef A} {b 2}}

test 51 {} {
    set v [vlerq insert [vlerq def A {1 2}] 1 [vlerq def A {a b}]]
    vlerq delete $v 1 2
} {data {mdef A} {1 2}}

test 52 {} {
    set v [vlerq insert [vlerq def A {1 2}] 1 [vlerq def A {a b}]]
    vlerq delete $v 2 2
} {data {mdef A} {1 a}}

test 53 {} {
    set v [vlerq insert [vlerq def A {1 2}] 1 [vlerq def A {a b}]]
    vlerq delete $v 0 3
} {data {mdef A} 2}

test 54 {} {
    set v [vlerq insert [vlerq def A {1 2}] 1 [vlerq def A {a b}]]
    vlerq delete $v 1 3
} {data {mdef A} 1}

test 55 {} {
    set v [vlerq insert [vlerq def A {1 2}] 1 [vlerq def A {a b}]]
    vlerq delete $v 0 4
} {data {mdef A} {}}

test 56 {insertion when there are no columns} {
    vlerq insert 3 0 5
} 8

test 57 {} {
    set v [vlerq def A {a b c d e f g h i j k l m n o p q r s t u v w x y z}]
    for {set i 1} {$i < 25} {incr i 2} {
      set v [vlerq set $v $i A $i]
    }
    set v
} {data {mdef A} {a 1 c 3 e 5 g 7 i 9 k 11 m 13 o 15 q 17 s 19 u 21 w 23 y z}}

test 58 {} {
    set v [vlerq def {A:I B} {11 a 22 bb 33 ccc}]
    set w [vlerq insert $v 2 [vlerq def {A:I B} {1 1 2 2}]]
} {data {mdef {A:I B}} {11 22 1 2 33} {a bb 1 2 ccc}}

test 59 {2nd insert before} {
    set w [vlerq insert $w 1 [vlerq def {A:I B} {3 3}]]
} {data {mdef {A:I B}} {11 3 22 1 2 33} {a 3 bb 1 2 ccc}}

test 60 {} {
    set v [vlerq def {A:I B} {11 a 22 bb 33 ccc}]
    set w [vlerq insert $v 1 [vlerq def {A:I B} {1 1 2 2}]]
} {data {mdef {A:I B}} {11 1 2 22 33} {a 1 2 bb ccc}}

test 61 {2nd insert after} {
    set w [vlerq insert $w 4 [vlerq def {A:I B} {3 3}]]
} {data {mdef {A:I B}} {11 1 2 22 3 33} {a 1 2 bb 3 ccc}}

test 62 {} {
    set v [vlerq def {A:I B} {11 a 22 bb}]
    set w [vlerq insert $v 1 [vlerq def {A:I B} {1 c 2 d 3 e}]]
} {data {mdef {A:I B}} {11 1 2 3 22} {a c d e bb}}

test 63 {delete inside insert} {
    set w [vlerq delete $w 2 1]
} {data {mdef {A:I B}} {11 1 3 22} {a c e bb}}

test 64 {} {
    vlerq mutinfo $w
} {{data {mdef {A:I B}} {1 3} {c e}} 0 0 {0 0} {0 0} {0 1 1 0} {}}

test 65 {} {
    set v [vlerq def {A:I B} {11 a 22 bb 33 ccc 44 dddd 55 eeeee}]
    set w [vlerq delete $v 1 1]
} {data {mdef {A:I B}} {11 33 44 55} {a ccc dddd eeeee}}

test 66 {two independent deletes} {
    vlerq delete $w 2 1
} {data {mdef {A:I B}} {11 33 55} {a ccc eeeee}}

test 67 {set high row, then low row} {
    set v [vlerq def {A B} {a A b B c C d D e E}]
    set w [vlerq set [vlerq set $v 3 A 3] 1 B 1]
} {data {mdef {A B}} {a b c 3 e} {A 1 C D E}}

test 68 {} {
    vlerq mutinfo $w
} {{data {mdef {A B}} {} {}}\
     {data {mdef {A B}} {b 3} {1 D}}\
     {data {mdef {_:I _:I}} {0 1} {1 0}}\
     {0 0 0 0 0} {0 1 0 1 0} {0 0 0 0 0} {1 0}}

test 69 {} {
    vlerq insert [vlerq def A {}] 0 [vlerq def A {1 2 3}]
} {data {mdef A} {1 2 3}}

unset -nocomplain v w i

::tcltest::cleanupTests
vqcore/tests/ops.test0000644000076500007650000002230510637717020014630 0ustar  jcwjcw00000000000000#!/usr/bin/env tclkit
# %renumber<^\s*test >%

source [file join [file dir [info script]] initests.tcl]

test 0 {load extension} {
    package require vlerq
} $version

test 1 {view of empty string} {
    vlerq viewconv {}
} {}

test 2 {view with no columns} {
    vlerq viewconv 5
} 5

test 3 {view type of empty meta view} {
    vlerq type [vlerq viewconv {}]
} view

test 4 {view type of no-column view} {
    vlerq type [vlerq viewconv 5]
} view

test 5 {refcount of empty meta view} {
    vlerq refs [vlerq viewconv {}]
} 1

test 6 {refcount of no-column view} {
    vlerq refs [vlerq viewconv 5]
} 1

test 7 {size of empty view} {
    vlerq size ""
} 0

test 8 {size of no-column view} {
    vlerq size 5
} 5

test 9 {width of empty view} {
    vlerq size [vlerq meta ""]
} 3

test 10 {width of no-column view} {
    vlerq size [vlerq meta 5]
} 0

test 11 {meta meta view} {
    set m [vlerq meta ""]
} {mdef {name type {subv {}}}}

test 12 {size of meta meta view} {
    vlerq size $m
} 3

test 13 {width of meta meta view} {
    vlerq size [vlerq meta $m]
} 3

test 14 {meta meta meta view} {
    vlerq meta $m
} {mdef {name type {subv {}}}}

test 15 {empty meta view} {
    set e [vlerq get $m 2 2]
} {}

test 16 {size of empty meta view} {
    vlerq size $e
} 0

test 17 {width of empty meta view} {
    vlerq size [vlerq meta $e]
} 3

test 18 {meta empty meta view} {
    vlerq meta $e
} {mdef {name type {subv {}}}}

test 19 {contents of meta meta view} {
    vlerq get $m
} {name S {} type S {} subv V {}}

test 20 {empty meta view from list} {
    # this could trigger a different code path, see updateViewStrRep
    set v [lreplace x 0 0]
    vlerq viewconv $v
} {}

test 21 {no-column view from list} {
    # this could trigger a different code path, see updateViewStrRep
    set v [list 7]
    vlerq viewconv $v
} 7

test 22 {to operator} {
    vlerq to 12 v
    vlerq size $v
} 12

test 23 {to operator result} {
    vlerq to 12 v
} 12

test 24 {to result use} {
    vlerq size @v
} 12

test 25 {to must set local var} -body {
    # bt: failed on 2006-12-02
    unset -nocomplain a
    proc a {} { vlerq to [vlerq def a {1 2 3 4}] a; set a }
    a
} -result {data {mdef a} {1 2 3 4}} -cleanup { rename a "" }

test 26 {data with meta view} {
    set v [vlerq data [vlerq meta ""] {A B} {S I} {"" ""}]
} {mdef {A B:I}}

test 27 {mdef operator} {
    vlerq mdef {A:S B:I}
} {mdef {A B:I}}

test 28 {mdesc operator} {
    vlerq mdesc {A,B:I,C[D:L,E:F],F:V}
} {mdef {A B:I {C {D:L E:F}} {F {}}}}

test 29 {data operator} {
    set v [vlerq data [vlerq mdef {A:S B:I}] {a b} {1 2}]
} {data {mdef {A B:I}} {a b} {1 2}}

test 30 {} {
    set v [vlerq data [vlerq mdef {A B}] {a b c} {d e f}]
    vlerq colmap $v {}
} 3

test 31 {} {
    vlerq colmap $v 1
} {data {mdef B} {d e f}}

test 32 {} {
    vlerq colmap $v {1 0}
} {data {mdef {B A}} {d e f} {a b c}}

test 33 {} {
    vlerq colmap $v {0 1 0}
} {data {mdef {A B A}} {a b c} {d e f} {a b c}}

test 34 {} {
    vlerq colmap $v B
} {data {mdef B} {d e f}}

test 35 {} {
    vlerq colmap $v {B A}
} {data {mdef {B A}} {d e f} {a b c}}

test 36 {} {
    vlerq colmap $v {A B A}
} {data {mdef {A B A}} {a b c} {d e f} {a b c}}

test 37 {} {
    vlerq colmap $v {-1 -2}
} {data {mdef {B A}} {d e f} {a b c}}

test 38 {} {
    vlerq repeat [vlerq def A {a b c}] 2
} {data {mdef A} {a b c a b c}}

test 39 {} {
    vlerq spread [vlerq def A {a b c}] 2
} {data {mdef A} {a a b b c c}}

test 40 {} {
    set v [vlerq data [vlerq mdef {A B}] {a b} {c d}]
    set w [vlerq data [vlerq mdef {C D}] {1 2} {3 4}]
    vlerq product $v $w
} {data {mdef {A B C D}} {a a b b} {c c d d} {1 2 1 2} {3 4 3 4}}

test 41 {} {
    vlerq clone [vlerq def A {a b c}]
} {data {mdef A} {}}

test 42 {} {
    vlerq reverse [vlerq def A {a b c}]
} {data {mdef A} {c b a}}

test 43 {} {
    vlerq first [vlerq def A {a b c}] 0
} {data {mdef A} {}}

test 44 {} {
    vlerq first [vlerq def A {a b c}] 2
} {data {mdef A} {a b}}

test 45 {} {
    vlerq first [vlerq def A {a b c}] 4
} {data {mdef A} {a b c}}

test 46 {} {
    vlerq last [vlerq def A {a b c}] 0
} {data {mdef A} {}}

test 47 {} {
    vlerq last [vlerq def A {a b c}] 2
} {data {mdef A} {b c}}

test 48 {} {
    vlerq last [vlerq def A {a b c}] 4
} {data {mdef A} {a b c}}

test 49 {} {
    vlerq slice [vlerq def A {a b c d e f g h i}] 1 2 3
} {data {mdef A} {b d f}}

test 50 {} {
    vlerq slice [vlerq def A {a b c d e f g h i}] 7 -2 3
} {data {mdef A} {h f d}}

test 51 {} {
    vlerq names ""
} {name type subv}
    
test 52 {} {
    vlerq names [vlerq meta ""]
} {name type subv}

test 53 {} {
    vlerq types ""
} {S S V}
    
test 54 {} {
    vlerq types [vlerq meta ""]
} {S S V}

test 55 {} {
    vlerq take [vlerq def A {a b c}] 2
} {data {mdef A} {a b}}

test 56 {} {
    vlerq take [vlerq def A {a b c}] 7
} {data {mdef A} {a b c a b c a}}

test 57 {} {
    vlerq take [vlerq def A {a b c}] -2
} {data {mdef A} {c b}}

test 58 {} {
    vlerq take [vlerq def A {a b c}] -7
} {data {mdef A} {c b a c b a c}}

test 59 {} {
    vlerq namecol ""
} {data {mdef name} {name type subv}}

test 60 {} {
    vlerq structure 123
} {}
    
test 61 {} {
    vlerq structure ""
} SSV
    
test 62 {} {
    vlerq structdesc 123
} {}
    
test 63 {} {
    vlerq structdesc ""
} {name:S,type:S,subv:V}
    
test 64 {} {
    vlerq compat 12 34
} 1
    
test 65 {} {
    vlerq compat "" ""
} 1
    
test 66 {} {
    vlerq compat 12 ""
} 0
    
test 67 {} {
    vlerq compat "" 34
} 0
    
test 68 {} {
    vlerq compat "" [vlerq meta ""]
} 1

test 69 {} {
    vlerq compat [vlerq def A {1 2 3}] [vlerq def B {1 2 3}]
} 1

test 70 {} {
    vlerq compat [vlerq def A {1 2 3}] [vlerq def A:I {1 2 3}]
} 0

test 71 {} {
    vlerq compat [vlerq def {{A {B C}}} {}] [vlerq def {{D {E F}}} {}]
} 1

test 72 {} {
    vlerq compat [vlerq def {{A {B C}}} {}] [vlerq def {{A {B C:I}}} {}]
} 0

test 73 {} {
    vlerq def A ""
} {data {mdef A} {}}
    
test 74 {} {
    vlerq def A {a b c}
} {data {mdef A} {a b c}}
    
test 75 {} {
    vlerq def {A B} ""
} {data {mdef {A B}} {} {}}
    
test 76 {} {
    vlerq def {A B} {a b c d}
} {data {mdef {A B}} {a c} {b d}}
    
test 77 {} {
    vlerq def {A B:I} {a 1 b 02 c -03}
} {data {mdef {A B:I}} {a b c} {1 2 -3}}

test 78 {} {
    vlerq tag 0 T
} {data {mdef T:I} {}}

test 79 {} {
    vlerq tag 5 T
} {data {mdef T:I} {0 1 2 3 4}}

test 80 {} {
    vlerq tag [vlerq def A {a b c}] T
} {data {mdef {A T:I}} {a b c} {0 1 2}}

test 81 {} {
    vlerq tag [vlerq def {A B} {a A b B c C}] T
} {data {mdef {A B T:I}} {a b c} {A B C} {0 1 2}}

test 82 {} {
    set v [vlerq def {A B C} {1 2 3 4 5 6 7 8 9}]
    vlerq rename $v {B X}
} {data {mdef {A X C}} {1 4 7} {2 5 8} {3 6 9}}

test 83 {} {
    vlerq rename $v {B X -1 Y}
} {data {mdef {A X Y}} {1 4 7} {2 5 8} {3 6 9}}

test 84 {} {
    vlerq rename $v {A B B C C A}
} {data {mdef {B C A}} {1 4 7} {2 5 8} {3 6 9}}

test 85 {omit} {
    set T [vlerq def {A B C D} {a b c d a b e f b c e f e d c d e d e f a b d e}]
    vlerq colomit $T {2 3} 
} {data {mdef {A B}} {a a b e e a} {b b c d d b}}

test 86 {omit reorder} {
    vlerq colomit $T {3 2} 
} {data {mdef {A B}} {a a b e e a} {b b c d d b}}

test 87 {omit named} {
    set T [vlerq def {A B C D} {a b c d a b e f b c e f e d c d e d e f a b d e}]
    vlerq colomit $T {C D} 
} {data {mdef {A B}} {a a b e e a} {b b c d d b}}

test 88 {omit named reorder} {
    vlerq colomit $T {D C} 
} {data {mdef {A B}} {a a b e e a} {b b c d d b}}

test 89 {} {
    set v [vlerq def {A B C} {1 2 3 4 5 6}]
    vlerq colomit $v {C B} 
} {data {mdef A} {1 4}}

test 90 {} {
    vlerq colomit $v {A A} 
} {data {mdef {B C}} {2 5} {3 6}}

test 91 {} {
    vlerq colomit $v {} 
} {data {mdef {A B C}} {1 4} {2 5} {3 6}}

test 92 {} {
    vlerq viewascol [vlerq def {A B:I C} {1 2 3 4 5 6 7 8 9}]
} {{1 4 7} {2 5 8} {3 6 9}}

test 93 {} {
    set v [vlerq def {A B} {1 2 3 4 1 2}]
    vlerq rowcmp $v 0 $v 1
} -1
    
test 94 {} {
    set v [vlerq def {A B} {1 2 3 4 1 2}]
    vlerq rowcmp $v 0 $v 2
} 0

test 95 {} {
    vlerq def {} {}
} 0

test 96 {} {
    set v [vlerq def {A B} {a b c d e f}]
    vlerq onecol $v A
} {data {mdef A} {a c e}}
    
test 97 {} {
    set v [vlerq def {A B} {a b c d e f}]
    vlerq onecol $v -1
} {data {mdef B} {b d f}}

test 98 {empty string col} {
    vlerq load [vlerq emit [vlerq def A {"" "" ""}]]
} {data {mdef A} {{} {} {}}}
     
test 99 {16-bit getter} {
    vlerq load [vlerq emit [vlerq def A:I {123 456 789}]]
} {data {mdef A:I} {123 456 789}}

test 100 {} {
    vlerq pair [vlerq def A {a b c}] [vlerq def B {1 2 3}]
} {data {mdef {A B}} {a b c} {1 2 3}}

test 101 {} {
    vlerq pair [vlerq def A {a b c}] 2
} {data {mdef A} {a b}}

test 102 {} {
    vlerq pair [vlerq def A {a b c}] 3
} {data {mdef A} {a b c}}

test 103 {} {
    vlerq pair [vlerq def A {a b c}] 4
} {data {mdef A} {a b c}}

test 104 {} {
    vlerq pair 2 [vlerq def A {a b c}]
} {data {mdef A} {a b}}

test 105 {} {
    vlerq pair 3 [vlerq def A {a b c}]
} {data {mdef A} {a b c}}

test 106 {} {
    vlerq pair 4 [vlerq def A {a b c}]
} {data {mdef A} {a b c}}

test 107 {} {
    # bt: crashed on 2007-02-10, see fff/139
    vlerq pair [vlerq def A {a b c}] [vlerq def B {1 2}]
} {data {mdef {A B}} {a b} {1 2}}

test 108 {} {
    vlerq pair [vlerq def A {a b}] [vlerq def B {1 2 3}]
} {data {mdef {A B}} {a b} {1 2}}

unset -nocomplain T e v w m
     
::tcltest::cleanupTests
vqcore/tests/ratcl.test0000644000076500007650000002025010633200335015121 0ustar  jcwjcw00000000000000#!/usr/bin/env tclkit
# %renumber<^\s*test >%

source [file join [file dir [info script]] initests.tcl]

test 0 {load ratcl package} {
    if {[file exists src_tcl/ratcl.tcl]} {
      source src_tcl/ratcl.tcl
    } else {
      source library/ratcl.tcl
    }
    package require ratcl
} 4

test 1 {} {
    view {A B} def {1 2 11 22 111 222} | reverse | get
} {111 222 11 22 1 2}

test 2 {} {
    view {A B} def {1 2 11 22 111 222} | reverse | dump
} { \
  A    B  
  ---  ---
  111  222
  11   22 
  1    2  }

test 3 {} {
    view 3 | dump
} {  (3 rows, no columns)}
    
test 4 {} {
    view "" | dump
} { \
  name  type  subv
  ----  ----  ----}

# tests copied from v3
set v [view {A B C} def {1 2 3 11 22 33 111 222 333}]

test 5 {} {
    view $v names
} {A B C}

test 6 {} {
    view $v types
} {S S S}
    
test 7 {} {
    view $v width
} 3

test 8 {} {
    vlerq get $v *
} {{1 2 3} {11 22 33} {111 222 333}}

test 9 {} {
    view $v first 2 | get *
} {{1 2 3} {11 22 33}}

test 10 {} {
    view $v last 2 | get *
} {{11 22 33} {111 222 333}}

test 11 {} {
    view $v reverse | get *
} {{111 222 333} {11 22 33} {1 2 3}}

test 12 {} {
    view $v repeat 2 | get *
} {{1 2 3} {11 22 33} {111 222 333} {1 2 3} {11 22 33} {111 222 333}}

test 13 {} {
    view $v spread 2 | get *
} {{1 2 3} {1 2 3} {11 22 33} {11 22 33} {111 222 333} {111 222 333}}

test 14 {} {
    view $v dump
} { \
  A    B    C  
  ---  ---  ---
  1    2    3  
  11   22   33 
  111  222  333}

test 15 {} -body {
    view $v html
} -match glob -result {


ABC


0123


1112233


2111222333



}

test 16 {} {
    namespace eval blah {
      namespace import ::ratcl::vopdef
      vopdef haha {v} { return abc }
    }
    view - haha
} {abc}

namespace forget blah

test 17 {transpose} {
    set v [view {A B C} def {1 2 3 4 5 6 7 8 9} | transpose]
    list [view $v names] [view $v structure] [view $v get]
} {{x0 x1 x2} SSS {1 4 7 2 5 8 3 6 9}}

test 18 {transpose ints} {
    set v [view {A:I B:I C:I} def {1 2 3 4 5 6 7 8 9} | transpose X:I]
    list [view $v names] [view $v structure] [view $v get]
} {{X0 X1 X2} III {1 4 7 2 5 8 3 6 9}}

test 19 {use vop} {
    view 1 use 2
} 2

test 20 {do vop} {
    set T [view {A B C D} def {a b c d a b e f b c e f e d c d e d e f a b d e}]
    view $T do {
      transpose 
      get 
    }
} {a a b e e a b b c d d b c e e c e d d f f d f e}

test 21 {debug vop} -body {
    set T [view {A B C D} def {a b c d a b e f b c e f e d c d e d e f a b d e}]
    view $T debug transpose | get
} -match glob -output {\
 rows-in  col  msec  view-operation
 -------  ---  ----  --------------
       6    4    ??  transpose
       4    6  ----  --------------
} -result {a a b e e a b b c d d b c e e c e d d f f d f e}

test 22 {use and debug vops} -body {
    view - debug {
      use {A B}
      def {1 2 3 4 5 6}
      transpose
      get
    }
} -result {1 3 5 2 4 6} -match glob -output {\
 rows-in  col  msec  view-operation
 -------  ---  ----  --------------
                 ??  use {A B}
                 ??  def {1 2 3 4 5 6}
       3    2    ??  transpose
       2    3    ??  get
 -------  ---  ----  --------------
}

test 23 {debug comments} -body {
    view $T debug {
      # start
      transpose
      # empty lines are not shown
      
      structure
      # end
    }
} -result SSSSSS -match glob -output {\
 rows-in  col  msec  view-operation
 -------  ---  ----  --------------
                     # start
       6    4    ??  transpose
                     # empty lines are not shown
       4    6    ??  structure
                     # end
 -------  ---  ----  --------------
}

test 24 {frequency table} {
    view A def {a b a b b c} | freq N | get
} {a 2 b 3 c 1}

test 25 {frequency table on unique values} {
    view A def {b a c} | freq N | get
} {b 1 a 1 c 1}

test 26 {frequency table on a single value} {
    view A def {a a a a} | freq N | get
} {a 4}

test 27 {} {
    view {1 2 3} asview A:I | structdesc
} A:I
    
test 28 {} {
    view {1 2 3} asview A | structdesc
} A:S

test 29 {} {
    view 10 asview len:I | get
} 10
    
test 30 {} {
    view [view 10 asview len:I] min len 50
} 10

test 31 {} {
    set v [vlerq def {A B} {1 a 1 b 1 b 2 c 3 c}]
    view $v project A | get
} {1 2 3}

test 32 {} {
    view $v project B | get
} {a b c}

test 33 {} {
    view $v project A B | get
} {1 a 1 b 2 c 3 c}

test 34 {} {
    view $v project | get
} {}

test 35 {} {
    view A:I def {1 2 3 4 5 6 9 10 11 12} | pick {1 1 0 1 1 0 0 1 1 0} | get
} {1 2 4 5 10 11}

test 36 {} {
    set v [vlerq def {A B} {1 2 3 4}]
    set w [vlerq reverse $v]
} {data {mdef {A B}} {3 1} {4 2}}
    
test 37 {} {
    set v [vlerq def {A B} {1 2 3 4}]
    set w [vlerq reverse $v]
    vlerq pair $v $w
} {data {mdef {A B A B}} {1 3} {2 4} {3 1} {4 2}}
    
test 38 {} {
    set v [vlerq def {A B} {1 2 3 4}]
    set w [vlerq reverse $v]
    view $v pair $w | get
} {1 2 3 4 3 4 1 2}
    
test 39 {} {
    set v [vlerq def {A B} {1 2 3 4}]
    set w [vlerq reverse $v]
    # 2006-12-08 failed because dump could not handle duplicate column names
    view $v pair $w | dump
} { \
  A  B  A  B
  -  -  -  -
  1  2  3  4
  3  4  1  2}

test 40 {} -body {
    set v [vlerq def {A B} {1 2 3 4}]
    set w [vlerq reverse $v]
    view $v pair $w | html
} -match glob -result {

ABAB


01234


13412



}

set T [vlerq def {X A B C D} {0 a b c d
                              1 e d f d
                              2 a b e f
                              3 b c e d
                              4 a b d e
                              5 e d c f}]
test 41 {} {
    view $T sorton A | get * X
} {0 2 4 3 1 5}

test 42 {} {
    view $T sorton - A | get * X
} {1 5 3 0 2 4}

test 43 {} {
    view $T sorton B | get * X
} {0 2 4 3 1 5}

test 44 {} {
    view $T sorton - B | get * X
} {1 5 3 0 2 4}

test 45 {} {
    view $T sorton C | get * X
} {0 5 4 2 3 1}

test 46 {} {
    view $T sorton - C | get * X
} {1 2 3 4 0 5}

test 47 {} {
    view $T sorton D | get * X
} {0 1 3 4 2 5}

test 48 {} {
    view $T sorton - D | get * X
} {2 5 4 0 1 3}

test 49 {} {
    view $T sorton D C | get * X
} {0 3 1 4 5 2}

test 50 {} {
    view $T sorton D - C | get * X
} {1 3 0 4 2 5}

test 51 {} {
    view $T sorton - D C | get * X
} {2 5 4 1 3 0}

test 52 {} {
    view $T sorton - D + C | get * X
} {5 2 4 0 3 1}

test 53 {} {
    # exercises view args > 8 and total vlerq args > 20
    view $T sorton - D + C - A + B - C + D - A + B - C + D | get * X
} {5 2 4 0 3 1}

test 54 {} {
    # failed, see F119
    set m [view {A,B:I} mdesc]
    set v [view $m data {a bb ccc} {1 22 333}]
    vlerq unique [vlerq colmap $v {B B}]
} {data {mdef {B:I B:I}} {1 22 333} {1 22 333}}

test 55 {} {
    vlerq unique [vlerq colmap $v {B A}]
} {data {mdef {B:I A}} {1 22 333} {a bb ccc}}

test 56 {read without hitting eof} {
    set fd [open data/gtest.db]
    set v [view $fd read]
    set r [eof $fd]
    close $fd
    set r
} 0

test 57 {} {
    vlerq meta $v
} {mdef {{frequents {drinker bar perweek:I}}\
           {likes {drinker beer perday:I}}\
           {serves {bar beer quantity:I}}}}
    
test 58 {read until eof} {
    set fd [open data/gtest.db]
    set w [view $fd read ########] ;# fake a non-header to force reading to eof
    set r [eof $fd]
    close $fd
    set r
} 1

test 59 {} {
    vlerq meta $w
} {mdef {{frequents {drinker bar perweek:I}}\
           {likes {drinker beer perday:I}}\
           {serves {bar beer quantity:I}}}}

test 60 {F146 - failed assertion, cannot reproduce} {
    view {} size; view {} do {use 5} | dump
} {  (5 rows, no columns)}

test 61 {as result} {
    view $T as tcmd
} tcmd

test 62 {as use} {
    tcmd size
} 6

rename tcmd ""
unset -nocomplain T r v w m fd

::tcltest::cleanupTests
vqcore/tests/ref.test0000644000076500007650000000527310611154237014605 0ustar  jcwjcw00000000000000#!/usr/bin/env tclkit
# %renumber<^\s*test >%

source [file join [file dir [info script]] initests.tcl]

test 0 {load extension} {
    package require vlerq
} $version

test 1 {ref command} {
    set v ""
    list [vlerq size @v] [vlerq width @v]
} {0 3}

test 2 {ref changed value} {
    set v [vlerq meta ""]
    list [vlerq size @v] [vlerq width @v]
} {3 3}

unset v

test 3 {} {
    proc foo {args} {
      puts [list got: $args]
      lindex $args 2
    }
    set v [vlerq def A {a b c}]
    set t {ref v foo bar}
    list [vlerq size $t] [vlerq size [vlerq meta $t]]
} {3 1}

test 4 {} -constraints x -body {
    vlerq set $t 1 A X
} -result {data {mdef A} {a X c}} \
    -output "got: bar {data {mdef A} {a b c}} set 1 A X\n"

test 5 {} {
    set v [vlerq def A {a b c}]
    vlerq load [vlerq emit @v]
} {data {mdef A} {a b c}}

test 6 {} {
    vlerq set @v 1 A xyz
} {data {mdef A} {a xyz c}}

test 7 {} {
    vlerq viewconv $v
} {data {mdef A} {a b c}}

test 8 {} x {
    vlerq viewconv @v
} {data {mdef A} {a xyz c}}

test 9 {} x {
    vlerq set $v 0 A abc
} {data {mdef A} {abc xyz c}}

test 10 {} x {
    vlerq set @v 2 A def
} {data {mdef A} {abc xyz def}}

test 11 {} {
    vlerq viewconv $v
} {data {mdef A} {a b c}}

test 12 {} x {
    vlerq viewconv @v
} {data {mdef A} {a xyz def}}

test 13 {} {
    set v [vlerq group [vlerq def {A B} {a 1 a 2 a 3}] A G]
    set v [vlerq load [vlerq emit $v]]
    vlerq load [vlerq emit @v]
} {data {mdef {A {G B}}} a {{data {mdef B} {1 2 3}}}}

test 14 {} {
    vlerq get @v 0 G
} {data {mdef B} {1 2 3}}

test 15 {} {
    vlerq set @v 0 A b
} {data {mdef {A {G B}}} b {{data {mdef B} {1 2 3}}}}

test 16 {} {
    vlerq set {get @v 0 G} 1 B xyz
} {data {mdef B} {1 xyz 3}}

test 17 {if this works then subviews are mutable} x {
    set v
} {data {mdef {A {G B}}} b {{data {mdef B} {1 xyz 3}}}}

#unset v
#vlerq debug 3

test 18 {} {
    set v [vlerq def A {5 3 2 1 4}]
    vlerq sort @v
} {data {mdef A} {1 2 3 4 5}}

test 19 {} {
    vlerq set $v 2 A 6
    vlerq sort @v
} {data {mdef A} {1 2 3 4 5}}

test 20 {} {
    set v [vlerq set $v 3 A 7]
    vlerq sort @v
} {data {mdef A} {2 3 4 5 7}}

test 21 {} {
    vlerq set @v 2 A 8
    set v
} {data {mdef A} {5 3 8 7 4}}

test 22 {} {
    vlerq sort @v
} {data {mdef A} {3 4 5 7 8}}

test 23 {} {
    set w {sort @v}
    vlerq viewconv $w
} {data {mdef A} {3 4 5 7 8}}

test 24 {} {
    vlerq set @v 2 A 0
} {data {mdef A} {5 3 0 7 4}}

test 25 {} {
    vlerq deps $v
} -

test 26 {} {
    set w [vlerq sort $v]
    vlerq size $w
} 5

test 27 {} x {
    vlerq deps $v
} {- {sort A 5}}

test 28 {} x {
    vlerq deps @v
} {}

test 29 {} x {
    vlerq viewconv $w
} {data {mdef A} {0 3 4 5 7}}

unset -nocomplain t v w

::tcltest::cleanupTests
vqcore/tests/sorted.test0000644000076500007650000001260510611154237015326 0ustar  jcwjcw00000000000000#!/usr/bin/env tclkit
# %renumber<^\s*test >%

source [file join [file dir [info script]] initests.tcl]

test 0 {} {
    package require vlerq
} $version

test 1 {} {
    vlerq roweq [vlerq meta ""] 0 [vlerq meta ""] 0
} 1

test 2 {} {
    vlerq roweq [vlerq meta ""] 0 [vlerq meta ""] 1
} 0

test 3 {} {
    vlerq roweq [vlerq def {L:L F:F D:D B:B} {1 2 3 4}] 0 \
                [vlerq def {L:L F:F D:D B:B} {1 2.0 3.0 4}] 0
} 1

test 4 {} {
    vlerq sortmap [vlerq def A:I {1 2 1 2 1 3}]
} {0 2 4 1 3 5}

test 5 {} {
    vlerq sortmap [vlerq def A {a b a b a c}]
} {0 2 4 1 3 5}

test 6 {} {
    vlerq sort [vlerq def A {a b a b a c}]
} {data {mdef A} {a a a b b c}}

test 7 {} {
    vlerq sort [vlerq def A {a b a c}]
} {data {mdef A} {a a b c}}

test 8 {} {
    vlerq compare "" ""
} 0
    
test 9 {} {
    vlerq compare 0 0
} 0
    
test 10 {} {
    vlerq compare 12 12
} 0
    
test 11 {} {
    vlerq compare 12 23
} -1
    
test 12 {} {
    vlerq compare "" 12
} 1
    
test 13 {} {
    vlerq compare "" [vlerq meta ""]
} -1
    
test 14 {} {
    vlerq compare [vlerq meta ""] [vlerq meta ""]
} 0
    
test 15 {} {
    vlerq compare [vlerq def A {}] [vlerq def A {}]
} 0
    
test 16 {} {
    vlerq compare [vlerq def A a] [vlerq def A a]
} 0
    
test 17 {} {
    vlerq compare [vlerq def A a] [vlerq def A b]
} -1
    
test 18 {} {
    vlerq compare [vlerq def A a] [vlerq def A {a b}]
} -1
    
test 19 {} {
    vlerq compare [vlerq def A {}] [vlerq def A a]
} -1
    
test 20 {} {
    vlerq compare [vlerq def A b] [vlerq def A {a b}]
} 1
    
test 21 {} {
    vlerq compare [vlerq def A {}] [vlerq def B {}]
} -1
    
test 22 {} {
    vlerq compare [vlerq def A b] [vlerq def B a]
} -1
    
test 23 {} {
    vlerq compare [vlerq def A {}] [vlerq def {A B} {}]
} -1
    
test 24 {} {
    vlerq compare [vlerq def {A B} {}] [vlerq def {A B} {}]
} 0
    
test 25 {} {
    vlerq compare [vlerq def {A B} {a b}] [vlerq def {A B} {a b}]
} 0
    
test 26 {} {
    vlerq compare [vlerq def {A B} {a b aa bb}] [vlerq def {A B} {a b aa bb}]
} 0
    
test 27 {} {
    vlerq compare [vlerq def {A B} {a b}] [vlerq def {A B} {a b aa bb}]
} -1
    
test 28 {} {
    vlerq compare [vlerq def {A B} {a b aa bb}] [vlerq def {A B} {a b}]
} 1
    
test 29 {} {
    vlerq compare [vlerq def {A B} {a b aa bb}] [vlerq def {A B} {a b aaa bb}]
} -1
    
test 30 {} {
    vlerq compare [vlerq def {A B} {a b aaa bb}] [vlerq def {A B} {a b aa bb}]
} 1
    
test 31 {} {
    vlerq compare [vlerq def {A B} {a b aa bb}] [vlerq def {A B} {a b aa bbb}]
} -1
    
test 32 {} {
    vlerq compare [vlerq def {A B} {a b aa bbb}] [vlerq def {A B} {a b aa bb}]
} 1
    
test 33 {} {
    vlerq compare [vlerq def A {}] [vlerq def A:I {}]
} 1
    
test 34 {} {
    vlerq compare [vlerq def A {}] [vlerq def A:I {}]
} 1
    
test 35 {} {
    vlerq compare [vlerq def A:I 1] [vlerq def A:I 01]
} 0
    
test 36 {} {
    vlerq compare [vlerq def A:I 01] [vlerq def A:I 1]
} 0

test 37 {} {
    vlerq compare [vlerq def A:I 19] [vlerq def A:I 2]
} 1
    
test 38 {} {
    vlerq compare [vlerq def A:I 2] [vlerq def A:I 19]
} -1
    
test 39 {} {
    vlerq compare [vlerq def A 19] [vlerq def A 2]
} -1
    
test 40 {} {
    vlerq compare [vlerq def A 2] [vlerq def A 19]
} 1

test 41 {} {
    vlerq compare [vlerq def {L:L F:F D:D B:B} {1 2 3 4}] \
                  [vlerq def {L:L F:F D:D B:B} {1 2.0 3.0 4}]
} 0

test 42 {} {
    vlerq max [vlerq def A {a b c}] 0
} c
    
test 43 {} {
    vlerq max [vlerq def A {a b c}] 0
} c
    
test 44 {} {
    vlerq max [vlerq def A {a b c}] 0
} c
    
test 45 {} {
    vlerq max [vlerq def A:I {1 2 3}] 0
} 3
    
test 46 {} {
    vlerq max [vlerq def A:I {1 2 3}] 0
} 3
    
test 47 {} {
    vlerq max [vlerq def A:I {1 2 3}] A
} 3
    
test 48 {} {
    vlerq min [vlerq def A {a b c}] 0 d
} a
    
test 49 {} {
    vlerq min [vlerq def A {a b c}] 0
} a
    
test 50 {} {
    vlerq min [vlerq def A {a b c}] 0
} a
    
test 51 {} {
    vlerq min [vlerq def A {a b c ""}] 0
} ""
    
test 52 {} {
    vlerq min [vlerq def A:I {1 2 3}] 0 4
} 1
    
test 53 {} {
    vlerq min [vlerq def A:I {1 2 3}] 0
} 1
    
test 54 {} {
    vlerq min [vlerq def A:I {1 2 3}] A
} 1
    
test 55 {} {
    vlerq sum [vlerq def A:I {}] 0
} 0
    
test 56 {} {
    vlerq sum [vlerq def A:I {1 2 3}] 0
} 6
    
test 57 {} {
    vlerq sum [vlerq def A:I {0 1 -2}] 0
} -1
    
test 58 {} {
    vlerq sum [vlerq def A:I {0 1 -2}] A
} -1
    
test 59 {} {
    vlerq sum [vlerq def A:L {10000000000 20000000000 30000000000}] 0
} 60000000000
    
test 60 {} {
    vlerq sum [vlerq def A:F {1000000000.1 2000000000.2 3000000000.3}] 0
} 6000000000.0
    
test 61 {} {
    vlerq sum [vlerq def A:D {1000000000.1 2000000000.2 3000000000.3}] 0
} 6000000000.6

test 62 {see F147, this works} {
    view {a b} def {1 a} | group a g | collect {[view $(g) get]}
} {a}

test 63 {F147 - this is ok} {
    view {a b} def {1 a} | group a g | structdesc
} {a:S,g[b:S]}

test 64 {F147 - so is this} {
    view {a b} def {1 a} | group a g | dump
} { \
  a  g 
  -  --
  1  #1}

test 65 {F147 - this throws an error} -constraints x -body {
    view {a b} def {1 a} | group a g | loop {puts [view $(g) sort | dump]}
} -output {?}

test 66 {F147 - this throws an assertion} -constraints x -body {
    view {a b} def {1 a} | group a g | loop {puts [view $(g) sort | freeze | get]}
} -output {?}

test 67 {F147 - and this crashes!} x {
    view {a b} def {1 a} | group a g | collect {[view $(g) sort | get]}
} {a}

::tcltest::cleanupTests
vqcore/tests/view.test0000644000076500007650000000127010611154237014774 0ustar  jcwjcw00000000000000#!/usr/bin/env tclkit
# %renumber<^\s*test >%

source [file join [file dir [info script]] initests.tcl]

test 0 {load extension} {
    package require vlerq
} $version

namespace eval ::vlerq {}

test 1 {indirect view operation} -body {
    proc ::vlerq::foo {n} { vlerq viewconv [expr {2*$n}] }
    vlerq size {foo 123}
} -result 246 -cleanup {
    rename ::vlerq::foo ""
}

test 2 {recursive indirect view operation} -body {
    proc ::vlerq::foo {n} { expr {3*$n} }
    vlerq size {foo 123}
} -result 369 -cleanup {
    rename ::vlerq::foo ""
}

test 3 {} {
    vlerq view [vlerq def A {a b c}] size
} 3

test 4 {} {
    vlerq view A def {a b c} | repeat 3 | size
} 9

::tcltest::cleanupTests
vqcore/vlerq.xcodeproj/0000755000076500007650000000000010607225673015114 5ustar  jcwjcw00000000000000vqcore/vlerq.xcodeproj/jcw.mode10000644000076500007650000011754410574647554016653 0ustar  jcwjcw00000000000000



	ActivePerspectiveName
	Project
	AllowedModules
	
		
			BundleLoadPath
			
			MaxInstances
			n
			Module
			PBXSmartGroupTreeModule
			Name
			Groups and Files Outline View
		
		
			BundleLoadPath
			
			MaxInstances
			n
			Module
			PBXNavigatorGroup
			Name
			Editor
		
		
			BundleLoadPath
			
			MaxInstances
			n
			Module
			XCTaskListModule
			Name
			Task List
		
		
			BundleLoadPath
			
			MaxInstances
			n
			Module
			XCDetailModule
			Name
			File and Smart Group Detail Viewer
		
		
			BundleLoadPath
			
			MaxInstances
			1
			Module
			PBXBuildResultsModule
			Name
			Detailed Build Results Viewer
		
		
			BundleLoadPath
			
			MaxInstances
			1
			Module
			PBXProjectFindModule
			Name
			Project Batch Find Tool
		
		
			BundleLoadPath
			
			MaxInstances
			n
			Module
			PBXRunSessionModule
			Name
			Run Log
		
		
			BundleLoadPath
			
			MaxInstances
			n
			Module
			PBXBookmarksModule
			Name
			Bookmarks Tool
		
		
			BundleLoadPath
			
			MaxInstances
			n
			Module
			PBXClassBrowserModule
			Name
			Class Browser
		
		
			BundleLoadPath
			
			MaxInstances
			n
			Module
			PBXCVSModule
			Name
			Source Code Control Tool
		
		
			BundleLoadPath
			
			MaxInstances
			n
			Module
			PBXDebugBreakpointsModule
			Name
			Debug Breakpoints Tool
		
		
			BundleLoadPath
			
			MaxInstances
			n
			Module
			XCDockableInspector
			Name
			Inspector
		
		
			BundleLoadPath
			
			MaxInstances
			n
			Module
			PBXOpenQuicklyModule
			Name
			Open Quickly Tool
		
		
			BundleLoadPath
			
			MaxInstances
			1
			Module
			PBXDebugSessionModule
			Name
			Debugger
		
		
			BundleLoadPath
			
			MaxInstances
			1
			Module
			PBXDebugCLIModule
			Name
			Debug Console
		
	
	Description
	DefaultDescriptionKey
	DockingSystemVisible
	
	Extension
	mode1
	FavBarConfig
	
		PBXProjectModuleGUID
		1153EB680AC7E06200BC5C12
		XCBarModuleItemNames
		
		XCBarModuleItems
		
	
	FirstTimeWindowDisplayed
	
	Identifier
	com.apple.perspectives.project.mode1
	MajorVersion
	31
	MinorVersion
	1
	Name
	Default
	Notifications
	
		
			XCObserverAutoDisconnectKey
			
			XCObserverDefintionKey
			
				PBXStatusErrorsKey
				0
			
			XCObserverFactoryKey
			XCPerspectivesSpecificationIdentifier
			XCObserverGUIDKey
			XCObserverProjectIdentifier
			XCObserverNotificationKey
			PBXStatusBuildStateMessageNotification
			XCObserverTargetKey
			XCMainBuildResultsModuleGUID
			XCObserverTriggerKey
			awakenModuleWithObserver:
			XCObserverValidationKey
			
				PBXStatusErrorsKey
				2
			
		
	
	OpenEditors
	
	PerspectiveWidths
	
		761
		300
	
	Perspectives
	
		
			ChosenToolbarItems
			
				XCToolbarPerspectiveControl
				NSToolbarSeparatorItem
				active-target-popup
				action
				NSToolbarFlexibleSpaceItem
				buildOrClean
				build-and-runOrDebug
				com.apple.ide.PBXToolbarStopButton
				get-info
				toggle-editor
				NSToolbarFlexibleSpaceItem
				com.apple.pbx.toolbar.searchfield
			
			ControllerClassBaseName
			
			IconName
			WindowOfProjectWithEditor
			Identifier
			perspective.project
			IsVertical
			
			Layout
			
				
					BecomeActive
					
					ContentConfiguration
					
						PBXBottomSmartGroupGIDs
						
							1C37FBAC04509CD000000102
							1C37FAAC04509CD000000102
							1C08E77C0454961000C914BD
							1C37FABC05509CD000000102
							1C37FABC05539CD112110102
							E2644B35053B69B200211256
							1C37FABC04509CD000100104
							1CC0EA4004350EF90044410B
							1CC0EA4004350EF90041110B
						
						PBXProjectModuleGUID
						1CE0B1FE06471DED0097A5F4
						PBXProjectModuleLabel
						Files
						PBXProjectStructureProvided
						yes
						PBXSmartGroupTreeModuleColumnData
						
							PBXSmartGroupTreeModuleColumnWidthsKey
							
								186
							
							PBXSmartGroupTreeModuleColumnsKey_v4
							
								MainColumn
							
						
						PBXSmartGroupTreeModuleOutlineStateKey_v7
						
							PBXSmartGroupTreeModuleOutlineStateExpansionKey
							
								1153EB220AC7DCA700BC5C12
								1153EB790AC7E0DA00BC5C12
								1153EB320AC7DCCF00BC5C12
								1C37FBAC04509CD000000102
								1C37FAAC04509CD000000102
								1C37FABC05509CD000000102
							
							PBXSmartGroupTreeModuleOutlineStateSelectionKey
							
								
									0
								
							
							PBXSmartGroupTreeModuleOutlineStateVisibleRectKey
							{{0, 0}, {186, 684}}
						
						PBXTopSmartGroupGIDs
						
						XCIncludePerspectivesSwitch
						
						XCSharingToken
						com.apple.Xcode.GFSharingToken
					
					GeometryConfiguration
					
						Frame
						{{0, 0}, {203, 702}}
						GroupTreeTableConfiguration
						
							MainColumn
							186
						
						RubberWindowFrame
						21 35 761 743 0 0 1280 778 
					
					Module
					PBXSmartGroupTreeModule
					Proportion
					203pt
				
				
					Dock
					
						
							ContentConfiguration
							
								PBXProjectModuleGUID
								1CE0B20306471E060097A5F4
								PBXProjectModuleLabel
								buffer.c
								PBXSplitModuleInNavigatorKey
								
									Split0
									
										PBXProjectModuleGUID
										1CE0B20406471E060097A5F4
										PBXProjectModuleLabel
										buffer.c
										_historyCapacity
										0
										bookmark
										11D3E0CB0B185B4600491D1C
										history
										
											11D3E0CA0B185B4600491D1C
										
									
									SplitCount
									1
								
								StatusBarVisibility
								
							
							GeometryConfiguration
							
								Frame
								{{0, 0}, {553, 697}}
								RubberWindowFrame
								21 35 761 743 0 0 1280 778 
							
							Module
							PBXNavigatorGroup
							Proportion
							697pt
						
						
							ContentConfiguration
							
								PBXProjectModuleGUID
								1CE0B20506471E060097A5F4
								PBXProjectModuleLabel
								Detail
							
							GeometryConfiguration
							
								Frame
								{{0, 702}, {553, 0}}
								RubberWindowFrame
								21 35 761 743 0 0 1280 778 
							
							Module
							XCDetailModule
							Proportion
							0pt
						
					
					Proportion
					553pt
				
			
			Name
			Project
			ServiceClasses
			
				XCModuleDock
				PBXSmartGroupTreeModule
				XCModuleDock
				PBXNavigatorGroup
				XCDetailModule
			
			TableOfContents
			
				11D3E0B30B18586500491D1C
				1CE0B1FE06471DED0097A5F4
				11D3E0B40B18586500491D1C
				1CE0B20306471E060097A5F4
				1CE0B20506471E060097A5F4
			
			ToolbarConfiguration
			xcode.toolbar.config.default
		
		
			ChosenToolbarItems
			
				XCToolbarPerspectiveControl
				NSToolbarSeparatorItem
				buildOrClean
				build-and-runOrDebug
				com.apple.ide.PBXToolbarStopButton
				NSToolbarFlexibleSpaceItem
				get-info
			
			ControllerClassBaseName
			
			IconName
			WindowOfProject
			Identifier
			perspective.morph
			IsVertical
			
			Layout
			
				
					ContentConfiguration
					
						PBXBottomSmartGroupGIDs
						
							1C37FBAC04509CD000000102
							1C37FAAC04509CD000000102
							1C08E77C0454961000C914BD
							1C37FABC05509CD000000102
							1C37FABC05539CD112110102
							E2644B35053B69B200211256
							1C37FABC04509CD000100104
							1CC0EA4004350EF90044410B
							1CC0EA4004350EF90041110B
						
						PBXProjectModuleGUID
						11E0B1FE06471DED0097A5F4
						PBXProjectModuleLabel
						Files
						PBXProjectStructureProvided
						yes
						PBXSmartGroupTreeModuleColumnData
						
							PBXSmartGroupTreeModuleColumnWidthsKey
							
								283
							
							PBXSmartGroupTreeModuleColumnsKey_v4
							
								MainColumn
							
						
						PBXSmartGroupTreeModuleOutlineStateKey_v7
						
							PBXSmartGroupTreeModuleOutlineStateExpansionKey
							
								1153EB220AC7DCA700BC5C12
								1153EB790AC7E0DA00BC5C12
								1153EB320AC7DCCF00BC5C12
								1C37FBAC04509CD000000102
								1C37FAAC04509CD000000102
								1C37FABC05509CD000000102
							
							PBXSmartGroupTreeModuleOutlineStateSelectionKey
							
								
									4
									3
									0
								
							
							PBXSmartGroupTreeModuleOutlineStateVisibleRectKey
							{{0, 0}, {283, 684}}
						
						PBXTopSmartGroupGIDs
						
						XCIncludePerspectivesSwitch
						
						XCSharingToken
						com.apple.Xcode.GFSharingToken
					
					GeometryConfiguration
					
						Frame
						{{0, 0}, {300, 702}}
						GroupTreeTableConfiguration
						
							MainColumn
							283
						
					
					Module
					PBXSmartGroupTreeModule
					Proportion
					300pt
				
			
			Name
			Morph
			PreferredWidth
			300
			ServiceClasses
			
				XCModuleDock
				PBXSmartGroupTreeModule
			
			TableOfContents
			
				11D3E0CC0B185B4600491D1C
				11E0B1FE06471DED0097A5F4
			
			ToolbarConfiguration
			xcode.toolbar.config.default.short
		
	
	PerspectivesBarVisible
	
	ShelfIsVisible
	
	SourceDescription
	file at '/System/Library/PrivateFrameworks/DevToolsInterface.framework/Versions/A/Resources/XCPerspectivesSpecificationMode1.xcperspec'
	StatusbarIsVisible
	
	TimeStamp
	186145606.46875
	ToolbarDisplayMode
	2
	ToolbarIsVisible
	
	ToolbarSizeMode
	2
	Type
	Perspectives
	UpdateMessage
	The Default Workspace in this version of Xcode now includes support to hide and show the detail view (what has been referred to as the "Metro-Morph" feature).  You must discard your current Default Workspace settings and update to the latest Default Workspace in order to gain this feature.  Do you wish to update to the latest Workspace defaults for project '%@'?
	WindowJustification
	5
	WindowOrderList
	
		11D3E0CD0B185B4600491D1C
		11D3E0CE0B185B4600491D1C
		1153EBC00AC7E20B00BC5C12
		1CD10A99069EF8BA00B06720
		11D3E0C80B185B0300491D1C
		1153EB5E0AC7E01600BC5C12
		/Users/jcw/w/vlerq/vlerq.xcodeproj
	
	WindowString
	21 35 761 743 0 0 1280 778 
	WindowTools
	
		
			FirstTimeWindowDisplayed
			
			Identifier
			windowTool.build
			IsVertical
			
			Layout
			
				
					Dock
					
						
							ContentConfiguration
							
								PBXProjectModuleGUID
								1CD0528F0623707200166675
								PBXProjectModuleLabel
								
								StatusBarVisibility
								
							
							GeometryConfiguration
							
								Frame
								{{0, 0}, {671, 266}}
								RubberWindowFrame
								539 149 671 548 0 0 1280 778 
							
							Module
							PBXNavigatorGroup
							Proportion
							266pt
						
						
							ContentConfiguration
							
								PBXProjectModuleGUID
								XCMainBuildResultsModuleGUID
								PBXProjectModuleLabel
								Build
								XCBuildResultsTrigger_Collapse
								1024
								XCBuildResultsTrigger_Open
								1012
							
							GeometryConfiguration
							
								Frame
								{{0, 271}, {671, 236}}
								RubberWindowFrame
								539 149 671 548 0 0 1280 778 
							
							Module
							PBXBuildResultsModule
							Proportion
							236pt
						
					
					Proportion
					507pt
				
			
			Name
			Build Results
			ServiceClasses
			
				PBXBuildResultsModule
			
			StatusbarIsVisible
			
			TableOfContents
			
				1153EB5E0AC7E01600BC5C12
				11D3E0BE0B185AF600491D1C
				1CD0528F0623707200166675
				XCMainBuildResultsModuleGUID
			
			ToolbarConfiguration
			xcode.toolbar.config.build
			WindowString
			539 149 671 548 0 0 1280 778 
			WindowToolGUID
			1153EB5E0AC7E01600BC5C12
			WindowToolIsVisible
			
		
		
			FirstTimeWindowDisplayed
			
			Identifier
			windowTool.debugger
			IsVertical
			
			Layout
			
				
					Dock
					
						
							ContentConfiguration
							
								Debugger
								
									HorizontalSplitView
									
										_collapsingFrameDimension
										0.0
										_indexOfCollapsedView
										0
										_percentageOfCollapsedView
										0.0
										isCollapsed
										yes
										sizes
										
											{{0, 0}, {313, 196}}
											{{313, 0}, {381, 196}}
										
									
									VerticalSplitView
									
										_collapsingFrameDimension
										0.0
										_indexOfCollapsedView
										0
										_percentageOfCollapsedView
										0.0
										isCollapsed
										yes
										sizes
										
											{{0, 0}, {694, 196}}
											{{0, 196}, {694, 185}}
										
									
								
								LauncherConfigVersion
								8
								PBXProjectModuleGUID
								1C162984064C10D400B95A72
								PBXProjectModuleLabel
								Debug - GLUTExamples (Underwater)
							
							GeometryConfiguration
							
								DebugConsoleDrawerSize
								{100, 120}
								DebugConsoleVisible
								None
								DebugConsoleWindowFrame
								{{200, 200}, {500, 300}}
								DebugSTDIOWindowFrame
								{{200, 200}, {500, 300}}
								Frame
								{{0, 0}, {694, 381}}
								RubberWindowFrame
								486 190 694 422 0 0 1280 778 
							
							Module
							PBXDebugSessionModule
							Proportion
							381pt
						
					
					Proportion
					381pt
				
			
			Name
			Debugger
			ServiceClasses
			
				PBXDebugSessionModule
			
			StatusbarIsVisible
			
			TableOfContents
			
				1CD10A99069EF8BA00B06720
				11D3E0C20B185B0300491D1C
				1C162984064C10D400B95A72
				11D3E0C30B185B0300491D1C
				11D3E0C40B185B0300491D1C
				11D3E0C50B185B0300491D1C
				11D3E0C60B185B0300491D1C
				11D3E0C70B185B0300491D1C
				11D3E0C80B185B0300491D1C
			
			ToolbarConfiguration
			xcode.toolbar.config.debug
			WindowString
			486 190 694 422 0 0 1280 778 
			WindowToolGUID
			1CD10A99069EF8BA00B06720
			WindowToolIsVisible
			
		
		
			Identifier
			windowTool.find
			Layout
			
				
					Dock
					
						
							Dock
							
								
									ContentConfiguration
									
										PBXProjectModuleGUID
										1CDD528C0622207200134675
										PBXProjectModuleLabel
										<No Editor>
										PBXSplitModuleInNavigatorKey
										
											Split0
											
												PBXProjectModuleGUID
												1CD0528D0623707200166675
											
											SplitCount
											1
										
										StatusBarVisibility
										1
									
									GeometryConfiguration
									
										Frame
										{{0, 0}, {781, 167}}
										RubberWindowFrame
										62 385 781 470 0 0 1440 878 
									
									Module
									PBXNavigatorGroup
									Proportion
									781pt
								
							
							Proportion
							50%
						
						
							BecomeActive
							1
							ContentConfiguration
							
								PBXProjectModuleGUID
								1CD0528E0623707200166675
								PBXProjectModuleLabel
								Project Find
							
							GeometryConfiguration
							
								Frame
								{{8, 0}, {773, 254}}
								RubberWindowFrame
								62 385 781 470 0 0 1440 878 
							
							Module
							PBXProjectFindModule
							Proportion
							50%
						
					
					Proportion
					428pt
				
			
			Name
			Project Find
			ServiceClasses
			
				PBXProjectFindModule
			
			StatusbarIsVisible
			1
			TableOfContents
			
				1C530D57069F1CE1000CFCEE
				1C530D58069F1CE1000CFCEE
				1C530D59069F1CE1000CFCEE
				1CDD528C0622207200134675
				1C530D5A069F1CE1000CFCEE
				1CE0B1FE06471DED0097A5F4
				1CD0528E0623707200166675
			
			WindowString
			62 385 781 470 0 0 1440 878 
			WindowToolGUID
			1C530D57069F1CE1000CFCEE
			WindowToolIsVisible
			0
		
		
			Identifier
			MENUSEPARATOR
		
		
			FirstTimeWindowDisplayed
			
			Identifier
			windowTool.debuggerConsole
			IsVertical
			
			Layout
			
				
					Dock
					
						
							ContentConfiguration
							
								PBXProjectModuleGUID
								1C78EAAC065D492600B07095
								PBXProjectModuleLabel
								Debugger Console
							
							GeometryConfiguration
							
								Frame
								{{0, 0}, {440, 358}}
								RubberWindowFrame
								349 289 440 400 0 0 1280 778 
							
							Module
							PBXDebugCLIModule
							Proportion
							358pt
						
					
					Proportion
					359pt
				
			
			Name
			Debugger Console
			ServiceClasses
			
				PBXDebugCLIModule
			
			StatusbarIsVisible
			
			TableOfContents
			
				1153EBC00AC7E20B00BC5C12
				11D3E0C90B185B0300491D1C
				1C78EAAC065D492600B07095
			
			WindowString
			349 289 440 400 0 0 1280 778 
			WindowToolGUID
			1153EBC00AC7E20B00BC5C12
			WindowToolIsVisible
			
		
		
			FirstTimeWindowDisplayed
			
			Identifier
			windowTool.run
			IsVertical
			
			Layout
			
				
					Dock
					
						
							ContentConfiguration
							
								LauncherConfigVersion
								3
								PBXProjectModuleGUID
								1CD0528B0623707200166675
								PBXProjectModuleLabel
								Run
								Runner
								
									HorizontalSplitView
									
										_collapsingFrameDimension
										0.0
										_indexOfCollapsedView
										0
										_percentageOfCollapsedView
										0.0
										isCollapsed
										yes
										sizes
										
											{{0, 0}, {493, 167}}
											{{0, 176}, {493, 267}}
										
									
									VerticalSplitView
									
										_collapsingFrameDimension
										0.0
										_indexOfCollapsedView
										0
										_percentageOfCollapsedView
										0.0
										isCollapsed
										yes
										sizes
										
											{{0, 0}, {405, 443}}
											{{414, 0}, {514, 443}}
										
									
								
							
							GeometryConfiguration
							
								Frame
								{{0, 0}, {549, 537}}
								RubberWindowFrame
								673 285 549 578 0 0 1440 878 
							
							Module
							PBXRunSessionModule
							Proportion
							537pt
						
					
					Proportion
					537pt
				
			
			Name
			Run Log
			ServiceClasses
			
				PBXRunSessionModule
			
			StatusbarIsVisible
			
			TableOfContents
			
				1C0AD2B3069F1EA900FABCE6
				11CCC5450AC7EBA30085654B
				1CD0528B0623707200166675
				11CCC5460AC7EBA30085654B
			
			ToolbarConfiguration
			xcode.toolbar.config.run
			WindowString
			673 285 549 578 0 0 1440 878 
			WindowToolGUID
			1C0AD2B3069F1EA900FABCE6
			WindowToolIsVisible
			
		
		
			Identifier
			windowTool.scm
			Layout
			
				
					Dock
					
						
							ContentConfiguration
							
								PBXProjectModuleGUID
								1C78EAB2065D492600B07095
								PBXProjectModuleLabel
								<No Editor>
								PBXSplitModuleInNavigatorKey
								
									Split0
									
										PBXProjectModuleGUID
										1C78EAB3065D492600B07095
									
									SplitCount
									1
								
								StatusBarVisibility
								1
							
							GeometryConfiguration
							
								Frame
								{{0, 0}, {452, 0}}
								RubberWindowFrame
								743 379 452 308 0 0 1280 1002 
							
							Module
							PBXNavigatorGroup
							Proportion
							0pt
						
						
							BecomeActive
							1
							ContentConfiguration
							
								PBXProjectModuleGUID
								1CD052920623707200166675
								PBXProjectModuleLabel
								SCM
							
							GeometryConfiguration
							
								ConsoleFrame
								{{0, 259}, {452, 0}}
								Frame
								{{0, 7}, {452, 259}}
								RubberWindowFrame
								743 379 452 308 0 0 1280 1002 
								TableConfiguration
								
									Status
									30
									FileName
									199
									Path
									197.09500122070312
								
								TableFrame
								{{0, 0}, {452, 250}}
							
							Module
							PBXCVSModule
							Proportion
							262pt
						
					
					Proportion
					266pt
				
			
			Name
			SCM
			ServiceClasses
			
				PBXCVSModule
			
			StatusbarIsVisible
			1
			TableOfContents
			
				1C78EAB4065D492600B07095
				1C78EAB5065D492600B07095
				1C78EAB2065D492600B07095
				1CD052920623707200166675
			
			ToolbarConfiguration
			xcode.toolbar.config.scm
			WindowString
			743 379 452 308 0 0 1280 1002 
		
		
			FirstTimeWindowDisplayed
			
			Identifier
			windowTool.breakpoints
			IsVertical
			
			Layout
			
				
					Dock
					
						
							ContentConfiguration
							
								PBXBottomSmartGroupGIDs
								
									1C77FABC04509CD000000102
								
								PBXProjectModuleGUID
								1CE0B1FE06471DED0097A5F4
								PBXProjectModuleLabel
								Files
								PBXProjectStructureProvided
								no
								PBXSmartGroupTreeModuleColumnData
								
									PBXSmartGroupTreeModuleColumnWidthsKey
									
										168
									
									PBXSmartGroupTreeModuleColumnsKey_v4
									
										MainColumn
									
								
								PBXSmartGroupTreeModuleOutlineStateKey_v7
								
									PBXSmartGroupTreeModuleOutlineStateExpansionKey
									
										1C77FABC04509CD000000102
									
									PBXSmartGroupTreeModuleOutlineStateSelectionKey
									
										
											0
										
									
									PBXSmartGroupTreeModuleOutlineStateVisibleRectKey
									{{0, 0}, {168, 350}}
								
								PBXTopSmartGroupGIDs
								
								XCIncludePerspectivesSwitch
								
							
							GeometryConfiguration
							
								Frame
								{{0, 0}, {185, 368}}
								GroupTreeTableConfiguration
								
									MainColumn
									168
								
								RubberWindowFrame
								394 379 744 409 0 0 1440 878 
							
							Module
							PBXSmartGroupTreeModule
							Proportion
							185pt
						
						
							BecomeActive
							
							ContentConfiguration
							
								PBXProjectModuleGUID
								1CA1AED706398EBD00589147
								PBXProjectModuleLabel
								Detail
							
							GeometryConfiguration
							
								Frame
								{{190, 0}, {554, 368}}
								RubberWindowFrame
								394 379 744 409 0 0 1440 878 
							
							Module
							XCDetailModule
							Proportion
							554pt
						
					
					Proportion
					368pt
				
			
			MajorVersion
			2
			MinorVersion
			0
			Name
			Breakpoints
			ServiceClasses
			
				PBXSmartGroupTreeModule
				XCDetailModule
			
			StatusbarIsVisible
			
			TableOfContents
			
				112131810AC7E75900D90B6D
				112131820AC7E75900D90B6D
				1CE0B1FE06471DED0097A5F4
				1CA1AED706398EBD00589147
			
			ToolbarConfiguration
			xcode.toolbar.config.breakpoints
			WindowString
			394 379 744 409 0 0 1440 878 
			WindowToolGUID
			112131810AC7E75900D90B6D
			WindowToolIsVisible
			
		
		
			Identifier
			windowTool.debugAnimator
			Layout
			
				
					Dock
					
						
							Module
							PBXNavigatorGroup
							Proportion
							100%
						
					
					Proportion
					100%
				
			
			Name
			Debug Visualizer
			ServiceClasses
			
				PBXNavigatorGroup
			
			StatusbarIsVisible
			1
			ToolbarConfiguration
			xcode.toolbar.config.debugAnimator
			WindowString
			100 100 700 500 0 0 1280 1002 
		
		
			Identifier
			windowTool.bookmarks
			Layout
			
				
					Dock
					
						
							Module
							PBXBookmarksModule
							Proportion
							100%
						
					
					Proportion
					100%
				
			
			Name
			Bookmarks
			ServiceClasses
			
				PBXBookmarksModule
			
			StatusbarIsVisible
			0
			WindowString
			538 42 401 187 0 0 1280 1002 
		
		
			Identifier
			windowTool.classBrowser
			Layout
			
				
					Dock
					
						
							BecomeActive
							1
							ContentConfiguration
							
								OptionsSetName
								Hierarchy, all classes
								PBXProjectModuleGUID
								1CA6456E063B45B4001379D8
								PBXProjectModuleLabel
								Class Browser - NSObject
							
							GeometryConfiguration
							
								ClassesFrame
								{{0, 0}, {374, 96}}
								ClassesTreeTableConfiguration
								
									PBXClassNameColumnIdentifier
									208
									PBXClassBookColumnIdentifier
									22
								
								Frame
								{{0, 0}, {630, 331}}
								MembersFrame
								{{0, 105}, {374, 395}}
								MembersTreeTableConfiguration
								
									PBXMemberTypeIconColumnIdentifier
									22
									PBXMemberNameColumnIdentifier
									216
									PBXMemberTypeColumnIdentifier
									97
									PBXMemberBookColumnIdentifier
									22
								
								PBXModuleWindowStatusBarHidden2
								1
								RubberWindowFrame
								385 179 630 352 0 0 1440 878 
							
							Module
							PBXClassBrowserModule
							Proportion
							332pt
						
					
					Proportion
					332pt
				
			
			Name
			Class Browser
			ServiceClasses
			
				PBXClassBrowserModule
			
			StatusbarIsVisible
			0
			TableOfContents
			
				1C0AD2AF069F1E9B00FABCE6
				1C0AD2B0069F1E9B00FABCE6
				1CA6456E063B45B4001379D8
			
			ToolbarConfiguration
			xcode.toolbar.config.classbrowser
			WindowString
			385 179 630 352 0 0 1440 878 
			WindowToolGUID
			1C0AD2AF069F1E9B00FABCE6
			WindowToolIsVisible
			0
		
	


vqcore/vlerq.xcodeproj/jcw.pbxuser0000644000076500007650000005061110607225673017314 0ustar  jcwjcw00000000000000// !$*UTF8*$!
{
	110391390BBEDF340095130E /* PBXTextBookmark */ = {
		isa = PBXTextBookmark;
		fRef = 11BD89130AD1136500BABE25 /* viewobj.c */;
		name = "viewobj.c: 561";
		rLen = 0;
		rLoc = 14300;
		rType = 0;
		vrLen = 898;
		vrLoc = 11549;
	};
	110391660BBEE3150095130E /* tclsh8.4 */ = {
		isa = PBXFileReference;
		explicitFileType = "compiled.mach-o.executable";
		name = tclsh8.4;
		path = "/Users/jcw/w/kitgen/8.4/base-sym/build/bin/tclsh8.4";
		sourceTree = "";
	};
	110F08FC0ACF4E1C00A4BC4B /* pkgIndex.tcl */ = {
		uiCtxt = {
			sepNavIntBoundsRect = "{{0, 0}, {497, 560}}";
			sepNavSelRange = "{301, 0}";
			sepNavVisRect = "{{0, 0}, {497, 560}}";
			sepNavWindowFrame = "{{329, 112}, {750, 558}}";
		};
	};
	110FA7100BC2488D002135D1 /* PBXTextBookmark */ = {
		isa = PBXTextBookmark;
		fRef = 1153EB890AC7E0DA00BC5C12 /* view.c */;
		name = "result = NewView(RemapSubview(V_Meta(view), mapcol, 0, cols));";
		rLen = 65;
		rLoc = 4301;
		rType = 0;
		vrLen = 422;
		vrLoc = 4049;
	};
	110FA71F0BC24CC5002135D1 /* PBXTextBookmark */ = {
		isa = PBXTextBookmark;
		fRef = 1153EB7A0AC7E0DA00BC5C12 /* column.c */;
		name = "column.c: 552";
		rLen = 0;
		rLoc = 13435;
		rType = 0;
		vrLen = 538;
		vrLoc = 13081;
	};
	110FA7200BC24CC5002135D1 /* PBXTextBookmark */ = {
		isa = PBXTextBookmark;
		fRef = 11BD89100AD1136500BABE25 /* ext_tcl.c */;
		name = "ext_tcl.c: 422";
		rLen = 0;
		rLoc = 10603;
		rType = 0;
		vrLen = 717;
		vrLoc = 8394;
	};
	110FA72A0BC24E43002135D1 /* PBXTextBookmark */ = {
		isa = PBXTextBookmark;
		fRef = 1121317C0AC7E6FE00D90B6D /* xcode-tests.tcl */;
		name = "xcode-tests.tcl: 8";
		rLen = 0;
		rLoc = 229;
		rType = 0;
		vrLen = 256;
		vrLoc = 0;
	};
	1121317C0AC7E6FE00D90B6D /* xcode-tests.tcl */ = {
		uiCtxt = {
			sepNavIntBoundsRect = "{{0, 0}, {477, 232}}";
			sepNavSelRange = "{229, 0}";
			sepNavVisRect = "{{0, 0}, {477, 232}}";
		};
	};
	113E77780BCD62C7001B68F6 /* PBXTextBookmark */ = {
		isa = PBXTextBookmark;
		fRef = 1121317C0AC7E6FE00D90B6D /* xcode-tests.tcl */;
		name = "xcode-tests.tcl: 8";
		rLen = 0;
		rLoc = 229;
		rType = 0;
		vrLen = 256;
		vrLoc = 0;
	};
	114E145A0AF65A08009A2605 /* emit.c */ = {
		uiCtxt = {
			sepNavIntBoundsRect = "{{0, 0}, {664, 5951}}";
			sepNavSelRange = "{7998, 0}";
			sepNavVisRect = "{{0, 3321}, {664, 233}}";
		};
	};
	1153EB240AC7DCA700BC5C12 /* Project object */ = {
		activeBuildConfigurationName = Debug;
		activeExecutable = 1153EB360AC7DD7000BC5C12 /* tclkit */;
		activeTarget = 1153EB300AC7DCCF00BC5C12 /* vlerq4 */;
		addToTargets = (
			1153EB300AC7DCCF00BC5C12 /* vlerq4 */,
		);
		breakpoints = (
		);
		breakpointsGroup = 1153EB770AC7E0B700BC5C12 /* XCBreakpointsBucket */;
		codeSenseManager = 1153EB290AC7DCA700BC5C12 /* Code sense */;
		executables = (
			1153EB360AC7DD7000BC5C12 /* tclkit */,
		);
		expressions = (
			"f_commands[cmdIndex]",
		);
		ignoreBreakpointsInProjectsDict = {
		};
		perUserDictionary = {
			"PBXConfiguration.PBXBreakpointsDataSource.v1:1CA1AED706398EBD00589147" = {
				PBXFileTableDataSourceColumnSortingDirectionKey = 1;
				PBXFileTableDataSourceColumnSortingKey = PBXBreakpointsDataSource_BreakpointID;
				PBXFileTableDataSourceColumnWidthsKey = (
					20,
					20,
					209,
					20,
					120,
					100,
					20,
				);
				PBXFileTableDataSourceColumnsKey = (
					PBXBreakpointsDataSource_ActionID,
					PBXBreakpointsDataSource_TypeID,
					PBXBreakpointsDataSource_BreakpointID,
					PBXBreakpointsDataSource_UseID,
					PBXBreakpointsDataSource_LocationID,
					PBXBreakpointsDataSource_ConditionID,
					PBXBreakpointsDataSource_ContinueID,
				);
			};
			"PBXConfiguration.PBXBreakpointsDataSource.v1:1CA23EDF0692099D00951B8B" = {
				PBXFileTableDataSourceColumnSortingDirectionKey = "-1";
				PBXFileTableDataSourceColumnSortingKey = PBXBreakpointsDataSource_BreakpointID;
				PBXFileTableDataSourceColumnWidthsKey = (
					20,
					20,
					204,
					20,
					104,
					105,
					20,
				);
				PBXFileTableDataSourceColumnsKey = (
					PBXBreakpointsDataSource_ActionID,
					PBXBreakpointsDataSource_TypeID,
					PBXBreakpointsDataSource_BreakpointID,
					PBXBreakpointsDataSource_UseID,
					PBXBreakpointsDataSource_LocationID,
					PBXBreakpointsDataSource_ConditionID,
					PBXBreakpointsDataSource_ContinueID,
				);
			};
			PBXConfiguration.PBXFileTableDataSource3.PBXBookmarksDataSource = {
				PBXFileTableDataSourceColumnSortingDirectionKey = "-1";
				PBXFileTableDataSourceColumnSortingKey = PBXBookmarksDataSource_NameID;
				PBXFileTableDataSourceColumnWidthsKey = (
					200,
					200,
					119,
				);
				PBXFileTableDataSourceColumnsKey = (
					PBXBookmarksDataSource_LocationID,
					PBXBookmarksDataSource_NameID,
					PBXBookmarksDataSource_CommentsID,
				);
			};
			PBXConfiguration.PBXFileTableDataSource3.PBXErrorsWarningsDataSource = {
				PBXFileTableDataSourceColumnSortingDirectionKey = "-1";
				PBXFileTableDataSourceColumnSortingKey = PBXErrorsWarningsDataSource_LocationID;
				PBXFileTableDataSourceColumnWidthsKey = (
					20,
					355,
					134,
				);
				PBXFileTableDataSourceColumnsKey = (
					PBXErrorsWarningsDataSource_TypeID,
					PBXErrorsWarningsDataSource_MessageID,
					PBXErrorsWarningsDataSource_LocationID,
				);
			};
			PBXConfiguration.PBXFileTableDataSource3.PBXExecutablesDataSource = {
				PBXFileTableDataSourceColumnSortingDirectionKey = "-1";
				PBXFileTableDataSourceColumnSortingKey = PBXExecutablesDataSource_NameID;
				PBXFileTableDataSourceColumnWidthsKey = (
					22,
					300,
					185,
				);
				PBXFileTableDataSourceColumnsKey = (
					PBXExecutablesDataSource_ActiveFlagID,
					PBXExecutablesDataSource_NameID,
					PBXExecutablesDataSource_CommentsID,
				);
			};
			PBXConfiguration.PBXFileTableDataSource3.PBXFileTableDataSource = {
				PBXFileTableDataSourceColumnSortingDirectionKey = "-1";
				PBXFileTableDataSourceColumnSortingKey = PBXFileDataSource_Filename_ColumnID;
				PBXFileTableDataSourceColumnWidthsKey = (
					20,
					315,
					20,
					48,
					43,
					43,
					20,
				);
				PBXFileTableDataSourceColumnsKey = (
					PBXFileDataSource_FiletypeID,
					PBXFileDataSource_Filename_ColumnID,
					PBXFileDataSource_Built_ColumnID,
					PBXFileDataSource_ObjectSize_ColumnID,
					PBXFileDataSource_Errors_ColumnID,
					PBXFileDataSource_Warnings_ColumnID,
					PBXFileDataSource_Target_ColumnID,
				);
			};
			PBXConfiguration.PBXFileTableDataSource3.PBXFindDataSource = {
				PBXFileTableDataSourceColumnSortingDirectionKey = "-1";
				PBXFileTableDataSourceColumnSortingKey = PBXFindDataSource_LocationID;
				PBXFileTableDataSourceColumnWidthsKey = (
					200,
					120,
				);
				PBXFileTableDataSourceColumnsKey = (
					PBXFindDataSource_MessageID,
					PBXFindDataSource_LocationID,
				);
			};
			PBXConfiguration.PBXFileTableDataSource3.PBXSymbolsDataSource = {
				PBXFileTableDataSourceColumnSortingDirectionKey = "-1";
				PBXFileTableDataSourceColumnSortingKey = PBXSymbolsDataSource_SymbolNameID;
				PBXFileTableDataSourceColumnWidthsKey = (
					16,
					200,
					60,
					237,
				);
				PBXFileTableDataSourceColumnsKey = (
					PBXSymbolsDataSource_SymbolTypeIconID,
					PBXSymbolsDataSource_SymbolNameID,
					PBXSymbolsDataSource_SymbolTypeID,
					PBXSymbolsDataSource_ReferenceNameID,
				);
			};
			PBXConfiguration.PBXFileTableDataSource3.XCSCMDataSource = {
				PBXFileTableDataSourceColumnSortingDirectionKey = "-1";
				PBXFileTableDataSourceColumnSortingKey = PBXFileDataSource_Filename_ColumnID;
				PBXFileTableDataSourceColumnWidthsKey = (
					20,
					20,
					285,
					20,
					48,
					43,
					43,
					20,
				);
				PBXFileTableDataSourceColumnsKey = (
					PBXFileDataSource_SCM_ColumnID,
					PBXFileDataSource_FiletypeID,
					PBXFileDataSource_Filename_ColumnID,
					PBXFileDataSource_Built_ColumnID,
					PBXFileDataSource_ObjectSize_ColumnID,
					PBXFileDataSource_Errors_ColumnID,
					PBXFileDataSource_Warnings_ColumnID,
					PBXFileDataSource_Target_ColumnID,
				);
			};
			PBXConfiguration.PBXTargetDataSource.PBXTargetDataSource = {
				PBXFileTableDataSourceColumnSortingDirectionKey = "-1";
				PBXFileTableDataSourceColumnSortingKey = PBXFileDataSource_Filename_ColumnID;
				PBXFileTableDataSourceColumnWidthsKey = (
					20,
					200,
					63,
					20,
					48,
					43,
					43,
				);
				PBXFileTableDataSourceColumnsKey = (
					PBXFileDataSource_FiletypeID,
					PBXFileDataSource_Filename_ColumnID,
					PBXTargetDataSource_PrimaryAttribute,
					PBXFileDataSource_Built_ColumnID,
					PBXFileDataSource_ObjectSize_ColumnID,
					PBXFileDataSource_Errors_ColumnID,
					PBXFileDataSource_Warnings_ColumnID,
				);
			};
			PBXPerProjectTemplateStateSaveDate = 198009030;
			PBXWorkspaceStateSaveDate = 198009030;
		};
		perUserProjectItems = {
			110391390BBEDF340095130E /* PBXTextBookmark */ = 110391390BBEDF340095130E /* PBXTextBookmark */;
			110FA7100BC2488D002135D1 /* PBXTextBookmark */ = 110FA7100BC2488D002135D1 /* PBXTextBookmark */;
			110FA71F0BC24CC5002135D1 /* PBXTextBookmark */ = 110FA71F0BC24CC5002135D1 /* PBXTextBookmark */;
			110FA7200BC24CC5002135D1 /* PBXTextBookmark */ = 110FA7200BC24CC5002135D1 /* PBXTextBookmark */;
			110FA72A0BC24E43002135D1 /* PBXTextBookmark */ = 110FA72A0BC24E43002135D1 /* PBXTextBookmark */;
			113E77780BCD62C7001B68F6 /* PBXTextBookmark */ = 113E77780BCD62C7001B68F6 /* PBXTextBookmark */;
			1167B55C0B6526F400AF5A85 /* PBXTextBookmark */ = 1167B55C0B6526F400AF5A85 /* PBXTextBookmark */;
			1167B5610B6526F400AF5A85 /* PBXTextBookmark */ = 1167B5610B6526F400AF5A85 /* PBXTextBookmark */;
			1167B56E0B6526F400AF5A85 /* PBXTextBookmark */ = 1167B56E0B6526F400AF5A85 /* PBXTextBookmark */;
			1167B5700B6526F400AF5A85 /* PBXTextBookmark */ = 1167B5700B6526F400AF5A85 /* PBXTextBookmark */;
			1167B5D40B65475A00AF5A85 /* PBXTextBookmark */ = 1167B5D40B65475A00AF5A85 /* PBXTextBookmark */;
			1167B5E00B65477200AF5A85 /* PBXTextBookmark */ = 1167B5E00B65477200AF5A85 /* PBXTextBookmark */;
			1167B5EB0B65497E00AF5A85 /* PBXTextBookmark */ = 1167B5EB0B65497E00AF5A85 /* PBXTextBookmark */;
			1167B5EE0B65497E00AF5A85 /* PBXTextBookmark */ = 1167B5EE0B65497E00AF5A85 /* PBXTextBookmark */;
			1167B5F60B65497E00AF5A85 /* PBXTextBookmark */ = 1167B5F60B65497E00AF5A85 /* PBXTextBookmark */;
			1167B60A0B65497E00AF5A85 /* PBXTextBookmark */ = 1167B60A0B65497E00AF5A85 /* PBXTextBookmark */;
			11EAEF900B6934F200A6B271 /* PBXTextBookmark */ = 11EAEF900B6934F200A6B271 /* PBXTextBookmark */;
			11EAEF930B6934F200A6B271 /* PBXTextBookmark */ = 11EAEF930B6934F200A6B271 /* PBXTextBookmark */;
			11F5E5DD0B9EF20B00805C17 /* PBXTextBookmark */ = 11F5E5DD0B9EF20B00805C17 /* PBXTextBookmark */;
			11F5E5DE0B9EF20B00805C17 /* PBXTextBookmark */ = 11F5E5DE0B9EF20B00805C17 /* PBXTextBookmark */;
			11F5E5FC0B9EF37100805C17 /* PBXTextBookmark */ = 11F5E5FC0B9EF37100805C17 /* PBXTextBookmark */;
			11F5E60B0B9EF56F00805C17 /* PBXTextBookmark */ = 11F5E60B0B9EF56F00805C17 /* PBXTextBookmark */;
			11F5E60E0B9EF56F00805C17 /* PBXTextBookmark */ = 11F5E60E0B9EF56F00805C17 /* PBXTextBookmark */;
		};
		sourceControlManager = 1153EB280AC7DCA700BC5C12 /* Source Control */;
		userBuildSettings = {
		};
	};
	1153EB280AC7DCA700BC5C12 /* Source Control */ = {
		isa = PBXSourceControlManager;
		fallbackIsa = XCSourceControlManager;
		isSCMEnabled = 0;
		scmConfiguration = {
		};
		scmType = "";
	};
	1153EB290AC7DCA700BC5C12 /* Code sense */ = {
		isa = PBXCodeSenseManager;
		indexTemplatePath = "";
	};
	1153EB300AC7DCCF00BC5C12 /* vlerq4 */ = {
		activeExec = 0;
	};
	1153EB360AC7DD7000BC5C12 /* tclkit */ = {
		isa = PBXExecutable;
		activeArgIndex = 0;
		activeArgIndices = (
			YES,
		);
		argumentStrings = (
			"../../etc/xcode-tests.tcl",
		);
		autoAttachOnCrash = 1;
		configStateDict = {
			"PBXLSLaunchAction-0" = {
				PBXLSLaunchAction = 0;
				PBXLSLaunchStartAction = 1;
				PBXLSLaunchStdioStyle = 2;
				PBXLSLaunchStyle = 0;
				class = PBXLSRunLaunchConfig;
				displayName = "Executable Runner";
				identifier = com.apple.Xcode.launch.runConfig;
				remoteHostInfo = "";
				startActionInfo = "";
			};
		};
		customDataFormattersEnabled = 1;
		debuggerPlugin = GDBDebugging;
		disassemblyDisplayState = 0;
		dylibVariantSuffix = "";
		enableDebugStr = 1;
		environmentEntries = (
		);
		executableSystemSymbolLevel = 0;
		executableUserSymbolLevel = 0;
		launchableReference = 110391660BBEE3150095130E /* tclsh8.4 */;
		libgmallocEnabled = 0;
		name = tclkit;
		savedGlobals = {
		};
		sourceDirectories = (
		);
		startupPath = "<>";
		variableFormatDictionary = {
			$cr = 1;
			$ctr = 1;
			$lr = 1;
			$mq = 1;
			$pc = 1;
			$ps = 1;
			$r0 = 1;
			$r1 = 1;
			$r10 = 1;
			$r11 = 1;
			$r12 = 1;
			$r13 = 1;
			$r14 = 1;
			$r15 = 1;
			$r16 = 1;
			$r17 = 1;
			$r18 = 1;
			$r19 = 1;
			$r2 = 1;
			$r20 = 1;
			$r21 = 1;
			$r22 = 1;
			$r23 = 1;
			$r24 = 1;
			$r25 = 1;
			$r26 = 1;
			$r27 = 1;
			$r28 = 1;
			$r29 = 1;
			$r3 = 1;
			$r30 = 1;
			$r31 = 1;
			$r4 = 1;
			$r5 = 1;
			$r6 = 1;
			$r7 = 1;
			$r8 = 1;
			$r9 = 1;
			$xer = 1;
		};
	};
	1153EB770AC7E0B700BC5C12 /* XCBreakpointsBucket */ = {
		isa = XCBreakpointsBucket;
		name = vlerq;
		objects = (
		);
	};
	1153EB7A0AC7E0DA00BC5C12 /* column.c */ = {
		uiCtxt = {
			sepNavIntBoundsRect = "{{0, 0}, {666, 6314}}";
			sepNavSelRange = "{13802, 0}";
			sepNavVisRect = "{{0, 4638}, {666, 313}}";
		};
	};
	1153EB7B0AC7E0DA00BC5C12 /* intern.h */ = {
		uiCtxt = {
			sepNavIntBoundsRect = "{{0, 0}, {496, 704}}";
			sepNavSelRange = "{1176, 0}";
			sepNavVisRect = "{{0, 360}, {496, 333}}";
			sepNavWindowFrame = "{{15, -5}, {617, 878}}";
		};
	};
	1153EB7C0AC7E0DA00BC5C12 /* getters.c */ = {
		uiCtxt = {
			sepNavIntBoundsRect = "{{0, 0}, {664, 2233}}";
			sepNavSelRange = "{4495, 0}";
			sepNavVisRect = "{{0, 2030}, {664, 203}}";
		};
	};
	1153EB7E0AC7E0DA00BC5C12 /* file.c */ = {
		uiCtxt = {
			sepNavIntBoundsRect = "{{0, 0}, {664, 6061}}";
			sepNavSelRange = "{14884, 0}";
			sepNavVisRect = "{{0, 2632}, {664, 203}}";
		};
	};
	1153EB800AC7E0DA00BC5C12 /* mutable.c */ = {
		uiCtxt = {
			sepNavIntBoundsRect = "{{0, 0}, {664, 6941}}";
			sepNavSelRange = "{7899, 0}";
			sepNavVisRect = "{{0, 3237}, {664, 243}}";
		};
	};
	1153EB890AC7E0DA00BC5C12 /* view.c */ = {
		uiCtxt = {
			sepNavIntBoundsRect = "{{0, 0}, {666, 5489}}";
			sepNavSelRange = "{4301, 65}";
			sepNavVisRect = "{{0, 1661}, {666, 325}}";
			sepNavWindowFrame = "{{15, 31}, {579, 842}}";
		};
	};
	1167B55C0B6526F400AF5A85 /* PBXTextBookmark */ = {
		isa = PBXTextBookmark;
		fRef = 1153EB800AC7E0DA00BC5C12 /* mutable.c */;
		name = "mutable.c: 357";
		rLen = 0;
		rLoc = 9136;
		rType = 0;
		vrLen = 626;
		vrLoc = 8961;
	};
	1167B5610B6526F400AF5A85 /* PBXTextBookmark */ = {
		isa = PBXTextBookmark;
		fRef = 11BD89130AD1136500BABE25 /* viewobj.c */;
		name = "viewobj.c: 387";
		rLen = 0;
		rLoc = 9555;
		rType = 0;
		vrLen = 586;
		vrLoc = 8967;
	};
	1167B56E0B6526F400AF5A85 /* PBXTextBookmark */ = {
		isa = PBXTextBookmark;
		fRef = 1153EB800AC7E0DA00BC5C12 /* mutable.c */;
		name = "mutable.c: 357";
		rLen = 0;
		rLoc = 9136;
		rType = 0;
		vrLen = 626;
		vrLoc = 8961;
	};
	1167B5700B6526F400AF5A85 /* PBXTextBookmark */ = {
		isa = PBXTextBookmark;
		fRef = 11BD89100AD1136500BABE25 /* ext_tcl.c */;
		name = "ext_tcl.c: 27";
		rLen = 0;
		rLoc = 498;
		rType = 0;
		vrLen = 507;
		vrLoc = 284;
	};
	1167B5D40B65475A00AF5A85 /* PBXTextBookmark */ = {
		isa = PBXTextBookmark;
		fRef = 1121317C0AC7E6FE00D90B6D /* xcode-tests.tcl */;
		name = "xcode-tests.tcl: 8";
		rLen = 0;
		rLoc = 229;
		rType = 0;
		vrLen = 256;
		vrLoc = 0;
	};
	1167B5E00B65477200AF5A85 /* PBXTextBookmark */ = {
		isa = PBXTextBookmark;
		fRef = 1153EB7A0AC7E0DA00BC5C12 /* column.c */;
		name = "column.c: 109";
		rLen = 0;
		rLoc = 2526;
		rType = 0;
		vrLen = 1150;
		vrLoc = 1890;
	};
	1167B5EB0B65497E00AF5A85 /* PBXTextBookmark */ = {
		isa = PBXTextBookmark;
		fRef = 11BD890E0AD1136500BABE25 /* colobj.c */;
		name = "colobj.c: 145";
		rLen = 0;
		rLoc = 3289;
		rType = 0;
		vrLen = 494;
		vrLoc = 3848;
	};
	1167B5EE0B65497E00AF5A85 /* PBXTextBookmark */ = {
		isa = PBXTextBookmark;
		fRef = 116AF8ED0AD494A700731737 /* indirect.c */;
		name = "indirect.c: 90";
		rLen = 0;
		rLoc = 2230;
		rType = 0;
		vrLen = 676;
		vrLoc = 1966;
	};
	1167B5F60B65497E00AF5A85 /* PBXTextBookmark */ = {
		isa = PBXTextBookmark;
		fRef = 11BD890E0AD1136500BABE25 /* colobj.c */;
		name = "colobj.c: 145";
		rLen = 0;
		rLoc = 3289;
		rType = 0;
		vrLen = 458;
		vrLoc = 3136;
	};
	1167B60A0B65497E00AF5A85 /* PBXTextBookmark */ = {
		isa = PBXTextBookmark;
		fRef = 116AF8ED0AD494A700731737 /* indirect.c */;
		name = "indirect.c: 17";
		rLen = 0;
		rLoc = 276;
		rType = 0;
		vrLen = 533;
		vrLoc = 276;
	};
	116AF8ED0AD494A700731737 /* indirect.c */ = {
		uiCtxt = {
			sepNavIntBoundsRect = "{{0, 0}, {666, 3729}}";
			sepNavSelRange = "{8667, 0}";
			sepNavVisRect = "{{0, 1804}, {666, 328}}";
		};
	};
	116AF9040AD50ED800731737 /* sorted.c */ = {
		uiCtxt = {
			sepNavIntBoundsRect = "{{0, 0}, {668, 3014}}";
			sepNavSelRange = "{5842, 0}";
			sepNavVisRect = "{{0, 2275}, {668, 279}}";
		};
	};
	1184F77F0B315B21008FD916 /* bits.c */ = {
		uiCtxt = {
			sepNavIntBoundsRect = "{{0, 0}, {497, 2508}}";
			sepNavSelRange = "{5300, 0}";
			sepNavVisRect = "{{0, 1963}, {497, 545}}";
		};
	};
	119D12D60AD7D32F00C9CC2B /* wrap_gen.c */ = {
		uiCtxt = {
			sepNavIntBoundsRect = "{{0, 0}, {666, 4785}}";
			sepNavSelRange = "{2857, 0}";
			sepNavVisRect = "{{0, 4308}, {666, 328}}";
		};
	};
	11A263350B01307500B9C2B3 /* cmds.c */ = {
		uiCtxt = {
			sepNavIntBoundsRect = "{{0, 0}, {666, 3168}}";
			sepNavSelRange = "{4071, 0}";
			sepNavVisRect = "{{0, 1177}, {666, 320}}";
		};
	};
	11BD890E0AD1136500BABE25 /* colobj.c */ = {
		uiCtxt = {
			sepNavIntBoundsRect = "{{0, 0}, {664, 2838}}";
			sepNavSelRange = "{2150, 0}";
			sepNavVisRect = "{{0, 808}, {664, 237}}";
			sepNavWindowFrame = "{{308, 99}, {750, 558}}";
		};
	};
	11BD890F0AD1136500BABE25 /* defs.h */ = {
		uiCtxt = {
			sepNavIntBoundsRect = "{{0, 0}, {499, 450}}";
			sepNavSelRange = "{111, 0}";
			sepNavVisRect = "{{0, 0}, {499, 450}}";
		};
	};
	11BD89100AD1136500BABE25 /* ext_tcl.c */ = {
		uiCtxt = {
			sepNavIntBoundsRect = "{{0, 0}, {666, 4642}}";
			sepNavSelRange = "{10603, 0}";
			sepNavVisRect = "{{0, 3670}, {666, 325}}";
			sepNavWindowFrame = "{{15, 0}, {579, 778}}";
		};
	};
	11BD89110AD1136500BABE25 /* ext_tcl.h */ = {
		uiCtxt = {
			sepNavIntBoundsRect = "{{0, 0}, {496, 517}}";
			sepNavSelRange = "{0, 0}";
			sepNavVisRect = "{{0, 0}, {496, 269}}";
		};
	};
	11BD89130AD1136500BABE25 /* viewobj.c */ = {
		uiCtxt = {
			sepNavIntBoundsRect = "{{0, 0}, {477, 6292}}";
			sepNavSelRange = "{14300, 0}";
			sepNavVisRect = "{{0, 5033}, {477, 396}}";
			sepNavWindowFrame = "{{15, 31}, {579, 842}}";
		};
	};
	11C713CC0AD3D714007782A0 /* buffer.c */ = {
		uiCtxt = {
			sepNavIntBoundsRect = "{{0, 0}, {664, 1375}}";
			sepNavSelRange = "{1319, 0}";
			sepNavVisRect = "{{0, 472}, {664, 233}}";
		};
	};
	11C713D00AD3D71F007782A0 /* hash.c */ = {
		uiCtxt = {
			sepNavIntBoundsRect = "{{0, 0}, {664, 6622}}";
			sepNavSelRange = "{2359, 0}";
			sepNavVisRect = "{{0, 802}, {664, 233}}";
		};
	};
	11EAEF900B6934F200A6B271 /* PBXTextBookmark */ = {
		isa = PBXTextBookmark;
		fRef = 110F08FC0ACF4E1C00A4BC4B /* pkgIndex.tcl */;
		name = "pkgIndex.tcl: 10";
		rLen = 0;
		rLoc = 301;
		rType = 0;
		vrLen = 301;
		vrLoc = 0;
	};
	11EAEF930B6934F200A6B271 /* PBXTextBookmark */ = {
		isa = PBXTextBookmark;
		fRef = 110F08FC0ACF4E1C00A4BC4B /* pkgIndex.tcl */;
		name = "pkgIndex.tcl: 10";
		rLen = 0;
		rLoc = 301;
		rType = 0;
		vrLen = 301;
		vrLoc = 0;
	};
	11F5E5DD0B9EF20B00805C17 /* PBXTextBookmark */ = {
		isa = PBXTextBookmark;
		fRef = 1153EB890AC7E0DA00BC5C12 /* view.c */;
		name = "view.c: 12";
		rLen = 0;
		rLoc = 158;
		rType = 0;
		vrLen = 613;
		vrLoc = 0;
	};
	11F5E5DE0B9EF20B00805C17 /* PBXTextBookmark */ = {
		isa = PBXTextBookmark;
		fRef = 11A263350B01307500B9C2B3 /* cmds.c */;
		name = "cmds.c: 21";
		rLen = 0;
		rLoc = 418;
		rType = 0;
		vrLen = 591;
		vrLoc = 84;
	};
	11F5E5FC0B9EF37100805C17 /* PBXTextBookmark */ = {
		isa = PBXTextBookmark;
		fRef = 11A263350B01307500B9C2B3 /* cmds.c */;
		name = "cmds.c: 21";
		rLen = 0;
		rLoc = 418;
		rType = 0;
		vrLen = 670;
		vrLoc = 57;
	};
	11F5E60B0B9EF56F00805C17 /* PBXTextBookmark */ = {
		isa = PBXTextBookmark;
		fRef = 119D12D60AD7D32F00C9CC2B /* wrap_gen.c */;
		name = "wrap_gen.c: 119";
		rLen = 0;
		rLoc = 2308;
		rType = 0;
		vrLen = 512;
		vrLoc = 2018;
	};
	11F5E60E0B9EF56F00805C17 /* PBXTextBookmark */ = {
		isa = PBXTextBookmark;
		fRef = 119D12D60AD7D32F00C9CC2B /* wrap_gen.c */;
		name = MdefCmd_O;
		rLen = 9;
		rLoc = 2285;
		rType = 0;
		vrLen = 508;
		vrLoc = 2059;
	};
}
vqcore/vlerq.xcodeproj/jcw.perspective0000644000076500007650000012666210607225673020167 0ustar  jcwjcw00000000000000



	ActivePerspectiveName
	Debug
	AllowedModules
	
		
			BundleLoadPath
			
			MaxInstances
			n
			Module
			PBXSmartGroupTreeModule
			Name
			Groups and Files Outline View
		
		
			BundleLoadPath
			
			MaxInstances
			n
			Module
			PBXNavigatorGroup
			Name
			Editor
		
		
			BundleLoadPath
			
			MaxInstances
			n
			Module
			XCTaskListModule
			Name
			Task List
		
		
			BundleLoadPath
			
			MaxInstances
			n
			Module
			XCDetailModule
			Name
			File and Smart Group Detail Viewer
		
		
			BundleLoadPath
			
			MaxInstances
			1
			Module
			PBXBuildResultsModule
			Name
			Detailed Build Results Viewer
		
		
			BundleLoadPath
			
			MaxInstances
			1
			Module
			PBXProjectFindModule
			Name
			Project Batch Find Tool
		
		
			BundleLoadPath
			
			MaxInstances
			n
			Module
			PBXRunSessionModule
			Name
			Run Log
		
		
			BundleLoadPath
			
			MaxInstances
			n
			Module
			PBXBookmarksModule
			Name
			Bookmarks Tool
		
		
			BundleLoadPath
			
			MaxInstances
			n
			Module
			PBXClassBrowserModule
			Name
			Class Browser
		
		
			BundleLoadPath
			
			MaxInstances
			n
			Module
			PBXCVSModule
			Name
			Source Code Control Tool
		
		
			BundleLoadPath
			
			MaxInstances
			n
			Module
			PBXDebugBreakpointsModule
			Name
			Debug Breakpoints Tool
		
		
			BundleLoadPath
			
			MaxInstances
			n
			Module
			XCDockableInspector
			Name
			Inspector
		
		
			BundleLoadPath
			
			MaxInstances
			n
			Module
			PBXOpenQuicklyModule
			Name
			Open Quickly Tool
		
		
			BundleLoadPath
			
			MaxInstances
			1
			Module
			PBXDebugSessionModule
			Name
			Debugger
		
		
			BundleLoadPath
			
			MaxInstances
			1
			Module
			PBXDebugCLIModule
			Name
			Debug Console
		
	
	Description
	AIODescriptionKey
	DockingSystemVisible
	
	Extension
	perspective
	FavBarConfig
	
		PBXProjectModuleGUID
		111D93F30B19228F00457299
		XCBarModuleItemNames
		
		XCBarModuleItems
		
	
	FirstTimeWindowDisplayed
	
	Identifier
	com.apple.perspectives.project.default
	MajorVersion
	33
	MinorVersion
	0
	Name
	All-In-One
	Notifications
	
		
			XCObserverAutoDisconnectKey
			
			XCObserverDefintionKey
			
				PBXStatusErrorsKey
				0
			
			XCObserverFactoryKey
			XCPerspectivesSpecificationIdentifier
			XCObserverGUIDKey
			XCObserverProjectIdentifier
			XCObserverNotificationKey
			PBXStatusBuildStateMessageNotification
			XCObserverTargetKey
			XCMainBuildResultsModuleGUID
			XCObserverTriggerKey
			awakenModuleWithObserver:
			XCObserverValidationKey
			
				PBXStatusErrorsKey
				2
			
		
	
	OpenEditors
	
	PerspectiveWidths
	
		713
		713
		713
	
	Perspectives
	
		
			ChosenToolbarItems
			
				XCToolbarPerspectiveControl
				NSToolbarSeparatorItem
				active-target-popup
				active-buildstyle-popup
				action
				NSToolbarFlexibleSpaceItem
				buildOrClean
				build-and-runOrDebug
				com.apple.ide.PBXToolbarStopButton
				get-info
				NSToolbarFlexibleSpaceItem
				com.apple.pbx.toolbar.searchfield
			
			ControllerClassBaseName
			
			IconName
			WindowOfProject
			Identifier
			perspective.project
			IsVertical
			
			Layout
			
				
					ContentConfiguration
					
						PBXBottomSmartGroupGIDs
						
							1C37FBAC04509CD000000102
							1C37FAAC04509CD000000102
							1C08E77C0454961000C914BD
							1C37FABC05509CD000000102
							1C37FABC05539CD112110102
							E2644B35053B69B200211256
							1C37FABC04509CD000100104
							1CC0EA4004350EF90044410B
							1CC0EA4004350EF90041110B
							1C77FABC04509CD000000102
						
						PBXProjectModuleGUID
						1CA23ED40692098700951B8B
						PBXProjectModuleLabel
						Files
						PBXProjectStructureProvided
						yes
						PBXSmartGroupTreeModuleColumnData
						
							PBXSmartGroupTreeModuleColumnWidthsKey
							
								145
							
							PBXSmartGroupTreeModuleColumnsKey_v4
							
								MainColumn
							
						
						PBXSmartGroupTreeModuleOutlineStateKey_v7
						
							PBXSmartGroupTreeModuleOutlineStateExpansionKey
							
								1153EB220AC7DCA700BC5C12
								110F09870ACF546A00A4BC4B
								1C37FBAC04509CD000000102
								1C37FAAC04509CD000000102
							
							PBXSmartGroupTreeModuleOutlineStateSelectionKey
							
								
									9
								
							
							PBXSmartGroupTreeModuleOutlineStateVisibleRectKey
							{{0, 0}, {145, 684}}
						
						PBXTopSmartGroupGIDs
						
						XCIncludePerspectivesSwitch
						
					
					GeometryConfiguration
					
						Frame
						{{0, 0}, {162, 702}}
						GroupTreeTableConfiguration
						
							MainColumn
							145
						
					
					Module
					PBXSmartGroupTreeModule
					Proportion
					162pt
				
				
					Dock
					
						
							ContentConfiguration
							
								PBXProjectModuleGUID
								111D93D70B19223300457299
								PBXProjectModuleLabel
								xcode-tests.tcl
								PBXSplitModuleInNavigatorKey
								
									Split0
									
										PBXProjectModuleGUID
										111D93D80B19223300457299
										PBXProjectModuleLabel
										xcode-tests.tcl
										_historyCapacity
										0
										bookmark
										110391700BBEFFD20095130E
										history
										
											1167B5EB0B65497E00AF5A85
											1167B5EE0B65497E00AF5A85
											11EAEF900B6934F200A6B271
											1167B55C0B6526F400AF5A85
											1167B55D0B6526F400AF5A85
											1120EFB90B6F83EF00697EA0
											11F5E5FC0B9EF37100805C17
											11F5E5FD0B9EF37100805C17
											11F5E60B0B9EF56F00805C17
											110391390BBEDF340095130E
											1103915B0BBEE0510095130E
										
										prevStack
										
											1167B5610B6526F400AF5A85
											1167B56E0B6526F400AF5A85
											1167B5700B6526F400AF5A85
											1167B5D40B65475A00AF5A85
											1167B5E00B65477200AF5A85
											1167B5F60B65497E00AF5A85
											1167B60A0B65497E00AF5A85
											11EAEF930B6934F200A6B271
											11F5E5DD0B9EF20B00805C17
											11F5E5DE0B9EF20B00805C17
											11F5E60E0B9EF56F00805C17
										
									
									SplitCount
									1
								
								StatusBarVisibility
								
								XCSharingToken
								com.apple.Xcode.CommonNavigatorGroupSharingToken
							
							GeometryConfiguration
							
								Frame
								{{0, 0}, {546, 577}}
							
							Module
							PBXNavigatorGroup
							Proportion
							577pt
						
						
							Proportion
							120pt
							Tabs
							
								
									ContentConfiguration
									
										PBXProjectModuleGUID
										1CA23EDF0692099D00951B8B
										PBXProjectModuleLabel
										Detail
									
									GeometryConfiguration
									
										Frame
										{{10, 27}, {546, 93}}
									
									Module
									XCDetailModule
								
								
									ContentConfiguration
									
										PBXProjectModuleGUID
										1CA23EE00692099D00951B8B
										PBXProjectModuleLabel
										Project Find
									
									GeometryConfiguration
									
										Frame
										{{10, 31}, {603, 297}}
									
									Module
									PBXProjectFindModule
								
								
									ContentConfiguration
									
										PBXProjectModuleGUID
										1CA23EE10692099D00951B8B
										PBXProjectModuleLabel
										SCM Results
									
									GeometryConfiguration
									
										Frame
										{{10, 31}, {603, 297}}
									
									Module
									PBXCVSModule
								
							
						
					
					Proportion
					546pt
				
			
			Name
			Project
			ServiceClasses
			
				XCModuleDock
				PBXSmartGroupTreeModule
				XCModuleDock
				PBXNavigatorGroup
				XCDockableTabModule
				XCDetailModule
				PBXProjectFindModule
				PBXCVSModule
			
			TableOfContents
			
				1103914F0BBEE00A0095130E
				1CA23ED40692098700951B8B
				110391500BBEE00A0095130E
				111D93D70B19223300457299
				110391510BBEE00A0095130E
				1CA23EDF0692099D00951B8B
				1CA23EE00692099D00951B8B
				1CA23EE10692099D00951B8B
			
			ToolbarConfiguration
			xcode.toolbar.config.default
		
		
			ChosenToolbarItems
			
				XCToolbarPerspectiveControl
				NSToolbarSeparatorItem
				active-target-popup
				active-buildstyle-popup
				active-executable-popup
				NSToolbarFlexibleSpaceItem
				build
				clean
				NSToolbarSeparatorItem
				run
				debug
			
			ControllerClassBaseName
			
			IconName
			BuildTabIcon
			Identifier
			perspective.build
			IsVertical
			
			Layout
			
				
					ContentConfiguration
					
						PBXBottomSmartGroupGIDs
						
						PBXProjectModuleGUID
						1CA23EE50692099D00951B8B
						PBXProjectModuleLabel
						Files
						PBXProjectStructureProvided
						yes
						PBXSmartGroupTreeModuleColumnData
						
							PBXSmartGroupTreeModuleColumnWidthsKey
							
								167
							
							PBXSmartGroupTreeModuleColumnsKey_v4
							
								MainColumn
							
						
						PBXSmartGroupTreeModuleOutlineStateKey_v7
						
							PBXSmartGroupTreeModuleOutlineStateExpansionKey
							
								1153EB220AC7DCA700BC5C12
								110F09870ACF546A00A4BC4B
								116AF90E0AD50F8100731737
								1153EB790AC7E0DA00BC5C12
								1153EB320AC7DCCF00BC5C12
							
							PBXSmartGroupTreeModuleOutlineStateSelectionKey
							
								
									3
									1
									0
								
							
							PBXSmartGroupTreeModuleOutlineStateVisibleRectKey
							{{0, 0}, {167, 684}}
						
						PBXTopSmartGroupGIDs
						
						XCIncludePerspectivesSwitch
						
					
					GeometryConfiguration
					
						Frame
						{{0, 0}, {184, 702}}
						GroupTreeTableConfiguration
						
							MainColumn
							167
						
					
					Module
					PBXSmartGroupTreeModule
					Proportion
					184pt
				
				
					Dock
					
						
							ContentConfiguration
							
								PBXProjectModuleGUID
								111D93D70B19223300457299
								PBXProjectModuleLabel
								xcode-tests.tcl
								PBXSplitModuleInNavigatorKey
								
									Split0
									
										PBXProjectModuleGUID
										111D93D80B19223300457299
										PBXProjectModuleLabel
										xcode-tests.tcl
										_historyCapacity
										0
										bookmark
										113E77780BCD62C7001B68F6
										history
										
											1167B55C0B6526F400AF5A85
											1167B5EB0B65497E00AF5A85
											1167B5EE0B65497E00AF5A85
											11EAEF900B6934F200A6B271
											11F5E5FC0B9EF37100805C17
											11F5E60B0B9EF56F00805C17
											110391390BBEDF340095130E
											110FA7100BC2488D002135D1
											110FA71F0BC24CC5002135D1
											110FA7200BC24CC5002135D1
											110FA72A0BC24E43002135D1
										
										prevStack
										
											1167B5610B6526F400AF5A85
											1167B56E0B6526F400AF5A85
											1167B5700B6526F400AF5A85
											1167B5E00B65477200AF5A85
											1167B5F60B65497E00AF5A85
											1167B60A0B65497E00AF5A85
											11EAEF930B6934F200A6B271
											11F5E5DD0B9EF20B00805C17
											11F5E5DE0B9EF20B00805C17
											11F5E60E0B9EF56F00805C17
											1167B5D40B65475A00AF5A85
										
									
									SplitCount
									1
								
								StatusBarVisibility
								
								XCSharingToken
								com.apple.Xcode.CommonNavigatorGroupSharingToken
							
							GeometryConfiguration
							
								Frame
								{{0, 0}, {524, 249}}
							
							Module
							PBXNavigatorGroup
							Proportion
							249pt
						
						
							Proportion
							448pt
							Tabs
							
								
									ContentConfiguration
									
										PBXProjectModuleGUID
										XCMainBuildResultsModuleGUID
										PBXProjectModuleLabel
										Build
										XCBuildResultsTrigger_Collapse
										1024
										XCBuildResultsTrigger_Open
										1012
									
									GeometryConfiguration
									
										Frame
										{{10, 27}, {524, 421}}
									
									Module
									PBXBuildResultsModule
								
								
									ContentConfiguration
									
										LauncherConfigVersion
										3
										PBXProjectModuleGUID
										1CA23EE80692099D00951B8B
										PBXProjectModuleLabel
										Run
										Runner
										
											HorizontalSplitView
											
												_collapsingFrameDimension
												0.0
												_indexOfCollapsedView
												0
												_percentageOfCollapsedView
												0.0
												isCollapsed
												yes
												sizes
												
													{{0, 0}, {365, 167}}
													{{0, 176}, {365, 267}}
												
											
											VerticalSplitView
											
												_collapsingFrameDimension
												0.0
												_indexOfCollapsedView
												0
												_percentageOfCollapsedView
												0.0
												isCollapsed
												yes
												sizes
												
													{{0, 0}, {405, 443}}
													{{414, 0}, {514, 443}}
												
											
										
									
									GeometryConfiguration
									
										Frame
										{{10, 27}, {524, 421}}
									
									Module
									PBXRunSessionModule
								
							
						
					
					Proportion
					524pt
				
			
			Name
			Build
			ServiceClasses
			
				XCModuleDock
				PBXSmartGroupTreeModule
				XCModuleDock
				PBXNavigatorGroup
				XCDockableTabModule
				PBXBuildResultsModule
				PBXRunSessionModule
				XCConsole
			
			TableOfContents
			
				113E776C0BCD6297001B68F6
				1CA23EE50692099D00951B8B
				113E776D0BCD6297001B68F6
				111D93D70B19223300457299
				113E776E0BCD6297001B68F6
				XCMainBuildResultsModuleGUID
				1CA23EE80692099D00951B8B
				113E776F0BCD6297001B68F6
			
			ToolbarConfiguration
			xcode.toolbar.config.buildAndRun
		
		
			ChosenToolbarItems
			
				XCToolbarPerspectiveControl
				NSToolbarSeparatorItem
				build-and-debug
				debug
				NSToolbarFlexibleSpaceItem
				debugger-fix-and-continue
				debugger-restart-executable
				debugger-pause
				debugger-continue
				debugger-step-over
				debugger-step-into
				debugger-step-out
				debugger-step-instruction
				NSToolbarFlexibleSpaceItem
			
			ControllerClassBaseName
			PBXDebugSessionModule
			IconName
			DebugTabIcon
			Identifier
			perspective.debug
			IsVertical
			
			Layout
			
				
					ContentConfiguration
					
						PBXProjectModuleGUID
						1CCC7628064C1048000F2A68
						PBXProjectModuleLabel
						Debugger Console
					
					GeometryConfiguration
					
						Frame
						{{0, 0}, {713, 201}}
						RubberWindowFrame
						13 35 713 743 0 0 1280 778 
					
					Module
					PBXDebugCLIModule
					Proportion
					201pt
				
				
					ContentConfiguration
					
						Debugger
						
							HorizontalSplitView
							
								_collapsingFrameDimension
								0.0
								_indexOfCollapsedView
								0
								_percentageOfCollapsedView
								0.0
								isCollapsed
								yes
								sizes
								
									{{0, 0}, {315, 151}}
									{{315, 0}, {398, 151}}
								
							
							VerticalSplitView
							
								_collapsingFrameDimension
								0.0
								_indexOfCollapsedView
								0
								_percentageOfCollapsedView
								0.0
								isCollapsed
								yes
								sizes
								
									{{0, 0}, {713, 151}}
									{{0, 151}, {713, 345}}
								
							
						
						LauncherConfigVersion
						8
						PBXProjectModuleGUID
						1CCC7629064C1048000F2A68
						PBXProjectModuleLabel
						Debug
					
					GeometryConfiguration
					
						DebugConsoleDrawerSize
						{100, 120}
						DebugConsoleVisible
						None
						DebugConsoleWindowFrame
						{{200, 200}, {500, 300}}
						DebugSTDIOWindowFrame
						{{200, 200}, {500, 300}}
						Frame
						{{0, 206}, {713, 496}}
						RubberWindowFrame
						13 35 713 743 0 0 1280 778 
					
					Module
					PBXDebugSessionModule
					Proportion
					496pt
				
			
			Name
			Debug
			ServiceClasses
			
				XCModuleDock
				PBXDebugCLIModule
				PBXDebugSessionModule
				PBXDebugProcessAndThreadModule
				PBXDebugProcessViewModule
				PBXDebugThreadViewModule
				PBXDebugStackFrameViewModule
				PBXNavigatorGroup
				XCConsole
			
			TableOfContents
			
				113E77700BCD6297001B68F6
				1CCC7628064C1048000F2A68
				1CCC7629064C1048000F2A68
				113E77710BCD6297001B68F6
				113E77720BCD6297001B68F6
				113E77730BCD6297001B68F6
				113E77740BCD6297001B68F6
				113E77600BCD60CF001B68F6
				113E77750BCD6297001B68F6
			
			ToolbarConfiguration
			xcode.toolbar.config.debug
		
	
	PerspectivesBarVisible
	
	ShelfIsVisible
	
	SourceDescription
	file at '/System/Library/PrivateFrameworks/DevToolsInterface.framework/Versions/A/Resources/XCPerspectivesSpecification.xcperspec'
	StatusbarIsVisible
	
	TimeStamp
	198009543.16321999
	ToolbarDisplayMode
	2
	ToolbarIsVisible
	
	ToolbarSizeMode
	2
	Type
	Perspectives
	UpdateMessage
	
	WindowJustification
	5
	WindowOrderList
	
		113E77760BCD6297001B68F6
		113E77770BCD6297001B68F6
		113E77750BCD6297001B68F6
		/Users/jcw/w/svn/vlerq/core/vlerq.xcodeproj
	
	WindowString
	13 35 713 743 0 0 1280 778 
	WindowTools
	
		
			Identifier
			windowTool.find
			Layout
			
				
					Dock
					
						
							Dock
							
								
									ContentConfiguration
									
										PBXProjectModuleGUID
										1CDD528C0622207200134675
										PBXProjectModuleLabel
										<No Editor>
										PBXSplitModuleInNavigatorKey
										
											Split0
											
												PBXProjectModuleGUID
												1CD0528D0623707200166675
											
											SplitCount
											1
										
										StatusBarVisibility
										1
									
									GeometryConfiguration
									
										Frame
										{{0, 0}, {781, 167}}
										RubberWindowFrame
										62 385 781 470 0 0 1440 878 
									
									Module
									PBXNavigatorGroup
									Proportion
									781pt
								
							
							Proportion
							50%
						
						
							BecomeActive
							1
							ContentConfiguration
							
								PBXProjectModuleGUID
								1CD0528E0623707200166675
								PBXProjectModuleLabel
								Project Find
							
							GeometryConfiguration
							
								Frame
								{{8, 0}, {773, 254}}
								RubberWindowFrame
								62 385 781 470 0 0 1440 878 
							
							Module
							PBXProjectFindModule
							Proportion
							50%
						
					
					Proportion
					428pt
				
			
			Name
			Project Find
			ServiceClasses
			
				PBXProjectFindModule
			
			StatusbarIsVisible
			1
			TableOfContents
			
				1C530D57069F1CE1000CFCEE
				1C530D58069F1CE1000CFCEE
				1C530D59069F1CE1000CFCEE
				1CDD528C0622207200134675
				1C530D5A069F1CE1000CFCEE
				1CE0B1FE06471DED0097A5F4
				1CD0528E0623707200166675
			
			WindowString
			62 385 781 470 0 0 1440 878 
			WindowToolGUID
			1C530D57069F1CE1000CFCEE
			WindowToolIsVisible
			0
		
		
			Identifier
			windowTool.run
			Layout
			
				
					Dock
					
						
							ContentConfiguration
							
								LauncherConfigVersion
								3
								PBXProjectModuleGUID
								1CD0528B0623707200166675
								PBXProjectModuleLabel
								Run - cocoapp112 - cocoapp112
								Runner
								
									HorizontalSplitView
									
										_collapsingFrameDimension
										0.0
										_indexOfCollapsedView
										0
										_percentageOfCollapsedView
										0.0
										isCollapsed
										yes
										sizes
										
											{{0, 0}, {365, 167}}
											{{0, 176}, {365, 267}}
										
									
									VerticalSplitView
									
										_collapsingFrameDimension
										0.0
										_indexOfCollapsedView
										0
										_percentageOfCollapsedView
										0.0
										isCollapsed
										yes
										sizes
										
											{{0, 0}, {405, 443}}
											{{414, 0}, {514, 443}}
										
									
								
							
							GeometryConfiguration
							
								Frame
								{{0, 0}, {456, 192}}
								RubberWindowFrame
								741 130 456 234 0 0 1280 1002 
							
							Module
							PBXRunSessionModule
							Proportion
							192pt
						
					
					Proportion
					192pt
				
			
			Name
			Run Log
			ServiceClasses
			
				PBXRunSessionModule
			
			StatusbarIsVisible
			1
			TableOfContents
			
				1C78EAAF065D492600B07095
				1C78EAB0065D492600B07095
				1CD0528B0623707200166675
				1C78EAB1065D492600B07095
			
			ToolbarConfiguration
			xcode.toolbar.config.run
			WindowString
			741 130 456 234 0 0 1280 1002 
		
		
			Identifier
			windowTool.scm
			Layout
			
				
					Dock
					
						
							ContentConfiguration
							
								PBXProjectModuleGUID
								1C78EAB2065D492600B07095
								PBXProjectModuleLabel
								<No Editor>
								PBXSplitModuleInNavigatorKey
								
									Split0
									
										PBXProjectModuleGUID
										1C78EAB3065D492600B07095
									
									SplitCount
									1
								
								StatusBarVisibility
								1
							
							GeometryConfiguration
							
								Frame
								{{0, 0}, {452, 0}}
								RubberWindowFrame
								743 379 452 308 0 0 1280 1002 
							
							Module
							PBXNavigatorGroup
							Proportion
							0pt
						
						
							BecomeActive
							1
							ContentConfiguration
							
								PBXProjectModuleGUID
								1CD052920623707200166675
								PBXProjectModuleLabel
								SCM
							
							GeometryConfiguration
							
								ConsoleFrame
								{{0, 259}, {452, 0}}
								Frame
								{{0, 7}, {452, 259}}
								RubberWindowFrame
								743 379 452 308 0 0 1280 1002 
								TableConfiguration
								
									Status
									30
									FileName
									199
									Path
									197.09500122070312
								
								TableFrame
								{{0, 0}, {452, 250}}
							
							Module
							PBXCVSModule
							Proportion
							262pt
						
					
					Proportion
					266pt
				
			
			Name
			SCM
			ServiceClasses
			
				PBXCVSModule
			
			StatusbarIsVisible
			1
			TableOfContents
			
				1C78EAB4065D492600B07095
				1C78EAB5065D492600B07095
				1C78EAB2065D492600B07095
				1CD052920623707200166675
			
			ToolbarConfiguration
			xcode.toolbar.config.scm
			WindowString
			743 379 452 308 0 0 1280 1002 
		
		
			FirstTimeWindowDisplayed
			
			Identifier
			windowTool.breakpoints
			IsVertical
			
			Layout
			
				
					Dock
					
						
							ContentConfiguration
							
								PBXBottomSmartGroupGIDs
								
									1C77FABC04509CD000000102
								
								PBXProjectModuleGUID
								1CE0B1FE06471DED0097A5F4
								PBXProjectModuleLabel
								Files
								PBXProjectStructureProvided
								no
								PBXSmartGroupTreeModuleColumnData
								
									PBXSmartGroupTreeModuleColumnWidthsKey
									
										168
									
									PBXSmartGroupTreeModuleColumnsKey_v4
									
										MainColumn
									
								
								PBXSmartGroupTreeModuleOutlineStateKey_v7
								
									PBXSmartGroupTreeModuleOutlineStateExpansionKey
									
										1C77FABC04509CD000000102
									
									PBXSmartGroupTreeModuleOutlineStateSelectionKey
									
										
											0
										
									
									PBXSmartGroupTreeModuleOutlineStateVisibleRectKey
									{{0, 0}, {168, 350}}
								
								PBXTopSmartGroupGIDs
								
								XCIncludePerspectivesSwitch
								
							
							GeometryConfiguration
							
								Frame
								{{0, 0}, {185, 368}}
								GroupTreeTableConfiguration
								
									MainColumn
									168
								
								RubberWindowFrame
								25 746 744 409 0 0 1920 1178 
							
							Module
							PBXSmartGroupTreeModule
							Proportion
							185pt
						
						
							BecomeActive
							
							ContentConfiguration
							
								PBXProjectModuleGUID
								1CA1AED706398EBD00589147
								PBXProjectModuleLabel
								Detail
							
							GeometryConfiguration
							
								Frame
								{{190, 0}, {554, 368}}
								RubberWindowFrame
								25 746 744 409 0 0 1920 1178 
							
							Module
							XCDetailModule
							Proportion
							554pt
						
					
					Proportion
					368pt
				
			
			MajorVersion
			2
			MinorVersion
			0
			Name
			Breakpoints
			ServiceClasses
			
				PBXSmartGroupTreeModule
				XCDetailModule
			
			StatusbarIsVisible
			
			TableOfContents
			
				110FA6F60BC24815002135D1
				110FA6F70BC24815002135D1
				1CE0B1FE06471DED0097A5F4
				1CA1AED706398EBD00589147
			
			ToolbarConfiguration
			xcode.toolbar.config.breakpoints
			WindowString
			25 746 744 409 0 0 1920 1178 
			WindowToolGUID
			110FA6F60BC24815002135D1
			WindowToolIsVisible
			
		
		
			Identifier
			windowTool.debugAnimator
			Layout
			
				
					Dock
					
						
							Module
							PBXNavigatorGroup
							Proportion
							100%
						
					
					Proportion
					100%
				
			
			Name
			Debug Visualizer
			ServiceClasses
			
				PBXNavigatorGroup
			
			StatusbarIsVisible
			1
			ToolbarConfiguration
			xcode.toolbar.config.debugAnimator
			WindowString
			100 100 700 500 0 0 1280 1002 
		
		
			Identifier
			windowTool.bookmarks
			Layout
			
				
					Dock
					
						
							Module
							PBXBookmarksModule
							Proportion
							166pt
						
					
					Proportion
					166pt
				
			
			Name
			Bookmarks
			ServiceClasses
			
				PBXBookmarksModule
			
			StatusbarIsVisible
			0
			WindowString
			538 42 401 187 0 0 1280 1002 
		
		
			Identifier
			windowTool.classBrowser
			Layout
			
				
					Dock
					
						
							BecomeActive
							1
							ContentConfiguration
							
								OptionsSetName
								Hierarchy, all classes
								PBXProjectModuleGUID
								1CA6456E063B45B4001379D8
								PBXProjectModuleLabel
								Class Browser - NSObject
							
							GeometryConfiguration
							
								ClassesFrame
								{{0, 0}, {369, 96}}
								ClassesTreeTableConfiguration
								
									PBXClassNameColumnIdentifier
									208
									PBXClassBookColumnIdentifier
									22
								
								Frame
								{{0, 0}, {616, 353}}
								MembersFrame
								{{0, 105}, {369, 395}}
								MembersTreeTableConfiguration
								
									PBXMemberTypeIconColumnIdentifier
									22
									PBXMemberNameColumnIdentifier
									216
									PBXMemberTypeColumnIdentifier
									94
									PBXMemberBookColumnIdentifier
									22
								
								PBXModuleWindowStatusBarHidden2
								1
								RubberWindowFrame
								597 125 616 374 0 0 1280 1002 
							
							Module
							PBXClassBrowserModule
							Proportion
							354pt
						
					
					Proportion
					354pt
				
			
			Name
			Class Browser
			ServiceClasses
			
				PBXClassBrowserModule
			
			StatusbarIsVisible
			0
			TableOfContents
			
				1C78EABA065D492600B07095
				1C78EABB065D492600B07095
				1CA6456E063B45B4001379D8
			
			ToolbarConfiguration
			xcode.toolbar.config.classbrowser
			WindowString
			597 125 616 374 0 0 1280 1002 
		
	


vqcore/vlerq.xcodeproj/project.pbxproj0000644000076500007650000003722010574647554020205 0ustar  jcwjcw00000000000000// !$*UTF8*$!
{
	archiveVersion = 1;
	classes = {
	};
	objectVersion = 42;
	objects = {

/* Begin PBXBuildFile section */
		110F08FF0ACF4E4300A4BC4B /* pkgIndex.tcl in CopyFiles */ = {isa = PBXBuildFile; fileRef = 110F08FC0ACF4E1C00A4BC4B /* pkgIndex.tcl */; };
		114E145B0AF65A08009A2605 /* emit.c in Sources */ = {isa = PBXBuildFile; fileRef = 114E145A0AF65A08009A2605 /* emit.c */; };
		1153EB8B0AC7E0DA00BC5C12 /* column.c in Sources */ = {isa = PBXBuildFile; fileRef = 1153EB7A0AC7E0DA00BC5C12 /* column.c */; };
		1153EB8C0AC7E0DA00BC5C12 /* intern.h in Headers */ = {isa = PBXBuildFile; fileRef = 1153EB7B0AC7E0DA00BC5C12 /* intern.h */; };
		1153EB8D0AC7E0DA00BC5C12 /* getters.c in Sources */ = {isa = PBXBuildFile; fileRef = 1153EB7C0AC7E0DA00BC5C12 /* getters.c */; };
		1153EB8F0AC7E0DA00BC5C12 /* file.c in Sources */ = {isa = PBXBuildFile; fileRef = 1153EB7E0AC7E0DA00BC5C12 /* file.c */; };
		1153EB910AC7E0DA00BC5C12 /* mutable.c in Sources */ = {isa = PBXBuildFile; fileRef = 1153EB800AC7E0DA00BC5C12 /* mutable.c */; };
		1153EB990AC7E0DA00BC5C12 /* view.c in Sources */ = {isa = PBXBuildFile; fileRef = 1153EB890AC7E0DA00BC5C12 /* view.c */; };
		116AF8EF0AD494A700731737 /* indirect.c in Sources */ = {isa = PBXBuildFile; fileRef = 116AF8ED0AD494A700731737 /* indirect.c */; };
		116AF9060AD50ED800731737 /* sorted.c in Sources */ = {isa = PBXBuildFile; fileRef = 116AF9040AD50ED800731737 /* sorted.c */; };
		1184F7800B315B21008FD916 /* bits.c in Sources */ = {isa = PBXBuildFile; fileRef = 1184F77F0B315B21008FD916 /* bits.c */; };
		119D12D80AD7D32F00C9CC2B /* wrap_gen.c in Sources */ = {isa = PBXBuildFile; fileRef = 119D12D60AD7D32F00C9CC2B /* wrap_gen.c */; };
		119D12D90AD7D32F00C9CC2B /* wrap_gen.h in Headers */ = {isa = PBXBuildFile; fileRef = 119D12D70AD7D32F00C9CC2B /* wrap_gen.h */; };
		119D12DB0AD7D35900C9CC2B /* opdefs_gen.h in Headers */ = {isa = PBXBuildFile; fileRef = 119D12DA0AD7D35900C9CC2B /* opdefs_gen.h */; };
		11A263370B01307500B9C2B3 /* cmds.c in Sources */ = {isa = PBXBuildFile; fileRef = 11A263350B01307500B9C2B3 /* cmds.c */; };
		11A263380B01307500B9C2B3 /* loop.c in Sources */ = {isa = PBXBuildFile; fileRef = 11A263360B01307500B9C2B3 /* loop.c */; };
		11BD89140AD1136500BABE25 /* colobj.c in Sources */ = {isa = PBXBuildFile; fileRef = 11BD890E0AD1136500BABE25 /* colobj.c */; };
		11BD89150AD1136500BABE25 /* defs.h in Headers */ = {isa = PBXBuildFile; fileRef = 11BD890F0AD1136500BABE25 /* defs.h */; };
		11BD89160AD1136500BABE25 /* ext_tcl.c in Sources */ = {isa = PBXBuildFile; fileRef = 11BD89100AD1136500BABE25 /* ext_tcl.c */; };
		11BD89170AD1136500BABE25 /* ext_tcl.h in Headers */ = {isa = PBXBuildFile; fileRef = 11BD89110AD1136500BABE25 /* ext_tcl.h */; };
		11BD89180AD1136500BABE25 /* stubs.h in Headers */ = {isa = PBXBuildFile; fileRef = 11BD89120AD1136500BABE25 /* stubs.h */; };
		11BD89190AD1136500BABE25 /* viewobj.c in Sources */ = {isa = PBXBuildFile; fileRef = 11BD89130AD1136500BABE25 /* viewobj.c */; };
		11C713CE0AD3D714007782A0 /* buffer.c in Sources */ = {isa = PBXBuildFile; fileRef = 11C713CC0AD3D714007782A0 /* buffer.c */; };
		11C713D20AD3D71F007782A0 /* hash.c in Sources */ = {isa = PBXBuildFile; fileRef = 11C713D00AD3D71F007782A0 /* hash.c */; };
/* End PBXBuildFile section */

/* Begin PBXCopyFilesBuildPhase section */
		110F08FD0ACF4E2A00A4BC4B /* CopyFiles */ = {
			isa = PBXCopyFilesBuildPhase;
			buildActionMask = 2147483647;
			dstPath = "";
			dstSubfolderSpec = 16;
			files = (
				110F08FF0ACF4E4300A4BC4B /* pkgIndex.tcl in CopyFiles */,
			);
			runOnlyForDeploymentPostprocessing = 0;
		};
/* End PBXCopyFilesBuildPhase section */

/* Begin PBXFileReference section */
		110F08FC0ACF4E1C00A4BC4B /* pkgIndex.tcl */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = text; path = pkgIndex.tcl; sourceTree = SOURCE_ROOT; };
		1121317C0AC7E6FE00D90B6D /* xcode-tests.tcl */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = text; name = "xcode-tests.tcl"; path = "etc/xcode-tests.tcl"; sourceTree = SOURCE_ROOT; };
		114E145A0AF65A08009A2605 /* emit.c */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.c; path = emit.c; sourceTree = ""; };
		1153EB310AC7DCCF00BC5C12 /* libvlerq4.dylib */ = {isa = PBXFileReference; explicitFileType = "compiled.mach-o.dylib"; includeInIndex = 0; path = libvlerq4.dylib; sourceTree = BUILT_PRODUCTS_DIR; };
		1153EB7A0AC7E0DA00BC5C12 /* column.c */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.c; name = column.c; path = src/column.c; sourceTree = SOURCE_ROOT; wrapsLines = 0; };
		1153EB7B0AC7E0DA00BC5C12 /* intern.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; name = intern.h; path = src/intern.h; sourceTree = ""; };
		1153EB7C0AC7E0DA00BC5C12 /* getters.c */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.c; name = getters.c; path = src/getters.c; sourceTree = SOURCE_ROOT; };
		1153EB7E0AC7E0DA00BC5C12 /* file.c */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.c; name = file.c; path = src/file.c; sourceTree = SOURCE_ROOT; };
		1153EB800AC7E0DA00BC5C12 /* mutable.c */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.c; name = mutable.c; path = src/mutable.c; sourceTree = SOURCE_ROOT; };
		1153EB890AC7E0DA00BC5C12 /* view.c */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.c; name = view.c; path = src/view.c; sourceTree = SOURCE_ROOT; };
		116AF8ED0AD494A700731737 /* indirect.c */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.c; name = indirect.c; path = src/indirect.c; sourceTree = SOURCE_ROOT; };
		116AF9040AD50ED800731737 /* sorted.c */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.c; name = sorted.c; path = src/sorted.c; sourceTree = SOURCE_ROOT; };
		1184F77F0B315B21008FD916 /* bits.c */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.c; path = bits.c; sourceTree = ""; };
		119D12D60AD7D32F00C9CC2B /* wrap_gen.c */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.c; path = wrap_gen.c; sourceTree = ""; };
		119D12D70AD7D32F00C9CC2B /* wrap_gen.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; name = wrap_gen.h; path = src/wrap_gen.h; sourceTree = ""; };
		119D12DA0AD7D35900C9CC2B /* opdefs_gen.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; name = opdefs_gen.h; path = src_tcl/opdefs_gen.h; sourceTree = ""; };
		11A263350B01307500B9C2B3 /* cmds.c */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.c; name = cmds.c; path = ../src_tcl/cmds.c; sourceTree = ""; };
		11A263360B01307500B9C2B3 /* loop.c */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.c; name = loop.c; path = ../src_tcl/loop.c; sourceTree = ""; };
		11BD890E0AD1136500BABE25 /* colobj.c */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.c; name = colobj.c; path = src_tcl/colobj.c; sourceTree = SOURCE_ROOT; };
		11BD890F0AD1136500BABE25 /* defs.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; name = defs.h; path = src_tcl/defs.h; sourceTree = SOURCE_ROOT; };
		11BD89100AD1136500BABE25 /* ext_tcl.c */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.c; name = ext_tcl.c; path = src_tcl/ext_tcl.c; sourceTree = SOURCE_ROOT; };
		11BD89110AD1136500BABE25 /* ext_tcl.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; name = ext_tcl.h; path = src_tcl/ext_tcl.h; sourceTree = SOURCE_ROOT; };
		11BD89120AD1136500BABE25 /* stubs.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; name = stubs.h; path = src_tcl/stubs.h; sourceTree = SOURCE_ROOT; };
		11BD89130AD1136500BABE25 /* viewobj.c */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.c; name = viewobj.c; path = src_tcl/viewobj.c; sourceTree = SOURCE_ROOT; };
		11C713CC0AD3D714007782A0 /* buffer.c */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.c; name = buffer.c; path = src/buffer.c; sourceTree = SOURCE_ROOT; };
		11C713D00AD3D71F007782A0 /* hash.c */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.c; name = hash.c; path = src/hash.c; sourceTree = SOURCE_ROOT; };
/* End PBXFileReference section */

/* Begin PBXFrameworksBuildPhase section */
		1153EB2F0AC7DCCF00BC5C12 /* Frameworks */ = {
			isa = PBXFrameworksBuildPhase;
			buildActionMask = 2147483647;
			files = (
			);
			runOnlyForDeploymentPostprocessing = 0;
		};
/* End PBXFrameworksBuildPhase section */

/* Begin PBXGroup section */
		110F09870ACF546A00A4BC4B /* scripts */ = {
			isa = PBXGroup;
			children = (
				110F08FC0ACF4E1C00A4BC4B /* pkgIndex.tcl */,
				1121317C0AC7E6FE00D90B6D /* xcode-tests.tcl */,
			);
			name = scripts;
			sourceTree = SOURCE_ROOT;
		};
		1153EB220AC7DCA700BC5C12 = {
			isa = PBXGroup;
			children = (
				110F09870ACF546A00A4BC4B /* scripts */,
				116AF90E0AD50F8100731737 /* headers */,
				1153EB790AC7E0DA00BC5C12 /* src */,
				1153EB320AC7DCCF00BC5C12 /* Products */,
			);
			sourceTree = "";
		};
		1153EB320AC7DCCF00BC5C12 /* Products */ = {
			isa = PBXGroup;
			children = (
				1153EB310AC7DCCF00BC5C12 /* libvlerq4.dylib */,
			);
			name = Products;
			sourceTree = "";
		};
		1153EB790AC7E0DA00BC5C12 /* src */ = {
			isa = PBXGroup;
			children = (
				1184F77F0B315B21008FD916 /* bits.c */,
				11C713CC0AD3D714007782A0 /* buffer.c */,
				11A263350B01307500B9C2B3 /* cmds.c */,
				11BD890E0AD1136500BABE25 /* colobj.c */,
				1153EB7A0AC7E0DA00BC5C12 /* column.c */,
				114E145A0AF65A08009A2605 /* emit.c */,
				11BD89100AD1136500BABE25 /* ext_tcl.c */,
				1153EB7E0AC7E0DA00BC5C12 /* file.c */,
				1153EB7C0AC7E0DA00BC5C12 /* getters.c */,
				11C713D00AD3D71F007782A0 /* hash.c */,
				116AF8ED0AD494A700731737 /* indirect.c */,
				11A263360B01307500B9C2B3 /* loop.c */,
				1153EB800AC7E0DA00BC5C12 /* mutable.c */,
				116AF9040AD50ED800731737 /* sorted.c */,
				1153EB890AC7E0DA00BC5C12 /* view.c */,
				11BD89130AD1136500BABE25 /* viewobj.c */,
				119D12D60AD7D32F00C9CC2B /* wrap_gen.c */,
			);
			path = src;
			sourceTree = "";
		};
		116AF90E0AD50F8100731737 /* headers */ = {
			isa = PBXGroup;
			children = (
				11BD890F0AD1136500BABE25 /* defs.h */,
				11BD89110AD1136500BABE25 /* ext_tcl.h */,
				1153EB7B0AC7E0DA00BC5C12 /* intern.h */,
				119D12DA0AD7D35900C9CC2B /* opdefs_gen.h */,
				11BD89120AD1136500BABE25 /* stubs.h */,
				119D12D70AD7D32F00C9CC2B /* wrap_gen.h */,
			);
			name = headers;
			sourceTree = SOURCE_ROOT;
		};
/* End PBXGroup section */

/* Begin PBXHeadersBuildPhase section */
		1153EB2D0AC7DCCF00BC5C12 /* Headers */ = {
			isa = PBXHeadersBuildPhase;
			buildActionMask = 2147483647;
			files = (
				1153EB8C0AC7E0DA00BC5C12 /* intern.h in Headers */,
				11BD89150AD1136500BABE25 /* defs.h in Headers */,
				11BD89170AD1136500BABE25 /* ext_tcl.h in Headers */,
				11BD89180AD1136500BABE25 /* stubs.h in Headers */,
				119D12D90AD7D32F00C9CC2B /* wrap_gen.h in Headers */,
				119D12DB0AD7D35900C9CC2B /* opdefs_gen.h in Headers */,
			);
			runOnlyForDeploymentPostprocessing = 0;
		};
/* End PBXHeadersBuildPhase section */

/* Begin PBXNativeTarget section */
		1153EB300AC7DCCF00BC5C12 /* vlerq4 */ = {
			isa = PBXNativeTarget;
			buildConfigurationList = 1153EB330AC7DCCF00BC5C12 /* Build configuration list for PBXNativeTarget "vlerq4" */;
			buildPhases = (
				1153EB2D0AC7DCCF00BC5C12 /* Headers */,
				1153EB2E0AC7DCCF00BC5C12 /* Sources */,
				1153EB2F0AC7DCCF00BC5C12 /* Frameworks */,
				110F08FD0ACF4E2A00A4BC4B /* CopyFiles */,
			);
			buildRules = (
			);
			dependencies = (
			);
			name = vlerq4;
			productName = vlerq4;
			productReference = 1153EB310AC7DCCF00BC5C12 /* libvlerq4.dylib */;
			productType = "com.apple.product-type.library.dynamic";
		};
/* End PBXNativeTarget section */

/* Begin PBXProject section */
		1153EB240AC7DCA700BC5C12 /* Project object */ = {
			isa = PBXProject;
			buildConfigurationList = 1153EB250AC7DCA700BC5C12 /* Build configuration list for PBXProject "vlerq" */;
			hasScannedForEncodings = 0;
			mainGroup = 1153EB220AC7DCA700BC5C12;
			productRefGroup = 1153EB320AC7DCCF00BC5C12 /* Products */;
			projectDirPath = "";
			targets = (
				1153EB300AC7DCCF00BC5C12 /* vlerq4 */,
			);
		};
/* End PBXProject section */

/* Begin PBXSourcesBuildPhase section */
		1153EB2E0AC7DCCF00BC5C12 /* Sources */ = {
			isa = PBXSourcesBuildPhase;
			buildActionMask = 2147483647;
			files = (
				1153EB8B0AC7E0DA00BC5C12 /* column.c in Sources */,
				1153EB8D0AC7E0DA00BC5C12 /* getters.c in Sources */,
				1153EB8F0AC7E0DA00BC5C12 /* file.c in Sources */,
				1153EB910AC7E0DA00BC5C12 /* mutable.c in Sources */,
				1153EB990AC7E0DA00BC5C12 /* view.c in Sources */,
				11BD89140AD1136500BABE25 /* colobj.c in Sources */,
				11BD89160AD1136500BABE25 /* ext_tcl.c in Sources */,
				11BD89190AD1136500BABE25 /* viewobj.c in Sources */,
				11C713CE0AD3D714007782A0 /* buffer.c in Sources */,
				11C713D20AD3D71F007782A0 /* hash.c in Sources */,
				116AF8EF0AD494A700731737 /* indirect.c in Sources */,
				116AF9060AD50ED800731737 /* sorted.c in Sources */,
				119D12D80AD7D32F00C9CC2B /* wrap_gen.c in Sources */,
				114E145B0AF65A08009A2605 /* emit.c in Sources */,
				11A263370B01307500B9C2B3 /* cmds.c in Sources */,
				11A263380B01307500B9C2B3 /* loop.c in Sources */,
				1184F7800B315B21008FD916 /* bits.c in Sources */,
			);
			runOnlyForDeploymentPostprocessing = 0;
		};
/* End PBXSourcesBuildPhase section */

/* Begin XCBuildConfiguration section */
		1153EB260AC7DCA700BC5C12 /* Debug */ = {
			isa = XCBuildConfiguration;
			buildSettings = {
				ALWAYS_SEARCH_USER_PATHS = NO;
				GCC_OPTIMIZATION_LEVEL = 0;
				GCC_PREPROCESSOR_DEFINITIONS = DEBUG;
				PREBINDING = NO;
				SDKROOT = /Developer/SDKs/MacOSX10.4u.sdk;
				USER_HEADER_SEARCH_PATHS = src_tcl;
			};
			name = Debug;
		};
		1153EB270AC7DCA700BC5C12 /* Release */ = {
			isa = XCBuildConfiguration;
			buildSettings = {
				ALWAYS_SEARCH_USER_PATHS = NO;
				ARCHS = (
					ppc,
					ppc64,
					i386,
					x86_64,
				);
				DEPLOYMENT_POSTPROCESSING = YES;
				GCC_AUTO_VECTORIZATION = YES;
				GCC_GENERATE_DEBUGGING_SYMBOLS = NO;
				GCC_OPTIMIZATION_LEVEL = s;
				GCC_WARN_PEDANTIC = YES;
				PREBINDING = NO;
				SDKROOT = /Developer/SDKs/MacOSX10.4u.sdk;
				USER_HEADER_SEARCH_PATHS = src_tcl;
			};
			name = Release;
		};
		1153EB340AC7DCCF00BC5C12 /* Debug */ = {
			isa = XCBuildConfiguration;
			buildSettings = {
				PRODUCT_NAME = libvlerq4;
			};
			name = Debug;
		};
		1153EB350AC7DCCF00BC5C12 /* Release */ = {
			isa = XCBuildConfiguration;
			buildSettings = {
				EXPORTED_SYMBOLS_FILE = make.syms;
				PRODUCT_NAME = libvlerq4;
			};
			name = Release;
		};
/* End XCBuildConfiguration section */

/* Begin XCConfigurationList section */
		1153EB250AC7DCA700BC5C12 /* Build configuration list for PBXProject "vlerq" */ = {
			isa = XCConfigurationList;
			buildConfigurations = (
				1153EB260AC7DCA700BC5C12 /* Debug */,
				1153EB270AC7DCA700BC5C12 /* Release */,
			);
			defaultConfigurationIsVisible = 0;
			defaultConfigurationName = Debug;
		};
		1153EB330AC7DCCF00BC5C12 /* Build configuration list for PBXNativeTarget "vlerq4" */ = {
			isa = XCConfigurationList;
			buildConfigurations = (
				1153EB340AC7DCCF00BC5C12 /* Debug */,
				1153EB350AC7DCCF00BC5C12 /* Release */,
			);
			defaultConfigurationIsVisible = 0;
			defaultConfigurationName = Debug;
		};
/* End XCConfigurationList section */
	};
	rootObject = 1153EB240AC7DCA700BC5C12 /* Project object */;
}