ref: 54bac038f411c10a596adf84c06df32f8c7c4c53
dir: /appl/lib/tcl_core.b/
implement Tcl_Core; # these are the outside modules, self explanatory.. include "sys.m"; sys: Sys; include "draw.m"; draw: Draw; include "bufio.m"; bufmod : Bufio; Iobuf : import bufmod; include "string.m"; str : String; include "tk.m"; tk: Tk; include "wmlib.m"; wmlib: Wmlib; # these are stand alone Tcl libraries, for Tcl pieces that # are "big" enough to be called their own. include "tcl.m"; include "tcllib.m"; include "utils.m"; htab: Str_Hashtab; mhtab : Mod_Hashtab; shtab : Sym_Hashtab; stack : Tcl_Stack; utils : Tcl_Utils; Hash: import htab; MHash : import mhtab; SHash : import shtab; # global error flag and message. One day, this will be stack based.. errmsg : string; error, mypid : int; sproc : adt { name : string; args : string; script : string; }; TCL_UNKNOWN, TCL_SIMPLE, TCL_ARRAY : con iota; # Global vars. Simple variables, and associative arrays. libmods : ref MHash; proctab := array[100] of sproc; retfl : int; symtab : ref SHash; nvtab : ref Hash; avtab : array of (ref Hash,string); tclmod : TclData; core_commands:=array[] of { "append" , "array", "break" , "continue" , "catch", "dumpstack", "exit" , "expr" , "eval" , "for" , "foreach" , "global" , "if" , "incr" , "info", "lappend" , "level" , "load" , "proc" , "return" , "set" , "source" ,"switch" , "time" , "unset" , "uplevel", "upvar", "while" , "#" }; about() : array of string { return core_commands; } init(ctxt: ref Draw->Context, argv: list of string) { sys = load Sys Sys->PATH; draw = load Draw Draw->PATH; bufmod = load Bufio Bufio->PATH; htab = load Str_Hashtab Str_Hashtab->PATH; mhtab = load Mod_Hashtab Mod_Hashtab->PATH; shtab = load Sym_Hashtab Sym_Hashtab->PATH; stack = load Tcl_Stack Tcl_Stack->PATH; str = load String String->PATH; utils = load Tcl_Utils Tcl_Utils->PATH; tk = load Tk Tk->PATH; wmlib= load Wmlib Wmlib->PATH; if (bufmod == nil || htab == nil || stack == nil || str == nil || utils == nil || tk == nil || wmlib==nil || mhtab == nil || shtab == nil){ sys->print("can't load initial modules %r\n"); exit; } # get a new stack frame. stack->init(); (nvtab,avtab,symtab)=stack->newframe(); libmods=mhtab->alloc(101); # grab my pid, and set a new group to make me easy to kill. mypid=sys->pctl(sys->NEWPGRP, nil); # no default top window. tclmod.top=nil; tclmod.context=ctxt; tclmod.debug=0; # set up library modules. args:=array[] of {"do_load","io"}; do_load(args); args=array[] of {"do_load","string"}; do_load(args); args=array[] of {"do_load","calc"}; do_load(args); args=array[] of {"do_load","list"}; do_load(args); args=array[] of {"do_load","tk"}; do_load(args); arr:=about(); for(i:=0;i<len arr;i++) libmods.insert(arr[i],nil); # cmd line args... if (argv != nil) argv = tl argv; while (argv != nil) { loadfile(hd argv); argv = tl argv; } } set_top(win:ref Tk->Toplevel){ tclmod.top=win; } clear_error(){ error=0; errmsg=""; } notify(num : int,s : string) : string { error=1; case num{ 1 => errmsg=sys->sprint( "wrong # args: should be \"%s\"",s); * => errmsg= s; } return errmsg; } grab_lines(new_inp,unfin: string ,lines : chan of string){ error=0; tclmod.lines=lines; input,line : string; if (new_inp==nil) new_inp = "tcl%"; if (unfin==nil) unfin = "tcl>"; sys->print("%s ", new_inp); iob := bufmod->fopen(sys->fildes(0),bufmod->OREAD); if (iob==nil){ sys->print("cannot open stdin for reading.\n"); return; } while((input=iob.gets('\n'))!=nil){ line+=input; if (!finished(line,0)) sys->print("%s ", unfin); else{ lines <- = line; line=nil; } } } # this is the main function. Its input is a complete (i.e. matching # brackets etc) tcl script, and its output is a message - if there # is one. evalcmd(s: string, termchar: int) : string { msg : string; i:=0; retfl=0; if (tclmod.debug==2) sys->print("Entered evalcmd, s=%s, termchar=%c\n",s,termchar); # strip null statements.. while((i<len s) && (s[i]=='\n' || s[i]==';')) i++; if (i==len s) return nil; # parse the script statement by statement for(;s!=nil;i++){ # wait till we have a complete statement if (i==len s || ((s[i]==termchar || s[i]==';' || s[i]=='\n') && finished(s[0:i],termchar))){ # throw it away if its a comment... if (s[0]!='#') argv := parsecmd(s[0:i],termchar,0); msg = nil; if (tclmod.debug==2) for(k:=0;k<len argv;k++) sys->print("argv[%d]: (%s)\n",k,argv[k]); # argv is now a completely parsed array of arguments # for the Tcl command.. # find the module that the command is in and # execute it. if (len argv != 0){ mod:=lookup(argv[0]); if (mod!=nil){ (error,msg)= mod->exec(ref tclmod,argv); if (error) errmsg=msg; } else { if (argv[0]!=nil && argv[0][0]=='.') msg=do_tk(argv); else msg=exec(argv); } } # was there an error? if (error) { if (len argv > 0 && argv[0]!=""){ stat : string; stat = "In function "+argv[0]; if (len argv >1 && argv[1]!=""){ stat[len stat]=' '; stat+=argv[1]; } stat+=".....\n\t"; errmsg=stat+errmsg; } msg=errmsg; } # we stop parsing if we hit a break, continue, return, # error, termchar or end of string. if (msg=="break" || msg=="continue" || error || retfl==1 || len s <= i || (len s > i && s[i]==termchar)) return msg; # otherwise eat up the parsed statement and continue s=s[i+1:]; i=-1; } } return msg; } # returns 1 if the line has matching braces, brackets and # double-quotes and does not end in "\\\n" finished(s : string, termchar : int) : int { cb:=0; dq:=0; sb:=0; if (s==nil) return 1; if (termchar=='}') cb++; if (termchar==']') sb++; if (len s > 1 && s[len s -2]=='\\') return 0; if (s[0]=='{') cb++; if (s[0]=='}' && cb>0) cb--; if (s[0]=='[') sb++; if (s[0]==']' && sb>0) sb--; if (s[0]=='"') dq=1-dq; for(i:=1;i<len s;i++){ if (s[i]=='{' && s[i-1]!='\\') cb++; if (s[i]=='}' && s[i-1]!='\\' && cb>0) cb--; if (s[i]=='[' && s[i-1]!='\\') sb++; if (s[i]==']' && s[i-1]!='\\' && sb>0) sb--; if (s[i]=='"' && s[i-1]!='\\') dq=1-dq; } return (cb==0 && sb==0 && dq==0); } # counts the offset till the next matching ']' strip_to_match(s : string, ptr: int) : int { j :=0; nb:=0; while(j<len s){ if (s[j]=='{') while (j < len s && s[j]!='}') j++; if (s[j]=='[') nb++; if (s[j]==']'){ nb--; if (nb==-1) return ptr+j; } j++; } return ptr+j; } # returns the type of variable represented by the string s, which is # a name. isa(s: string) : (int,int,string) { found,val : int; name,al : string; curlev:=stack->level(); if (tclmod.debug==2) sys->print("Called isa with %s, current stack level is %d\n",s,curlev); (found,nil)=nvtab.find(s); if (found) return (TCL_SIMPLE,curlev,s); for (i:=0;i<len avtab;i++){ (nil,name)=avtab[i]; if (name==s) return (TCL_ARRAY,curlev,s); } if (symtab==nil) return (TCL_UNKNOWN,curlev,s); (found,val,al)=symtab.find(s); if (!found) return (TCL_UNKNOWN,curlev,s); (tnv,tav,nil):=stack->examine(val); if (tclmod.debug==2) sys->print("have a level %d for %s\n",val,al); if (tnv!=nil){ (found,nil)=tnv.find(al); if (found) return (TCL_SIMPLE,val,al); } if (tav!=nil){ for (i=0;i<len tav;i++){ (nil,name)=tav[i]; if (name==al) return (TCL_ARRAY,val,al); } } if (tclmod.debug==2) sys->print("%s not found, creating at stack level %d\n",al,val); return (TCL_UNKNOWN,val,al); } # This function only works if the string is already parsed! # takes a var_name and returns the hash table for it and the # name to look up. This is one of two things: # for simple variables: # findvar(foo) ---> (nvtab,foo) # for associative arrays: # findvar(foo(bar)) -----> (avtab[i],bar) # where avtab[i].name==foo # if create is 1, then an associative array is created upon first # reference. # returns (nil,error message) if there is a problem. find_var(s : string,create : int) : (ref Hash,string) { rest,name,index : string; retval,tnv : ref Hash; tav : array of (ref Hash,string); i,tag,lev: int; (name,index)=str->splitl(s,"("); if (index!=nil){ (index,rest)=str->splitl(index[1:],")"); if (rest!=")") return (nil,"bad variable name"); } (tag,lev,name) = isa(name); case tag { TCL_SIMPLE => if (index!=nil) return (nil,"variable isn't array"); (tnv,nil,nil)=stack->examine(lev); return (tnv,name); TCL_ARRAY => if (index==nil) return (nil,"variable is array"); (nil,tav,nil)=stack->examine(lev); for(i=0;i<len tav;i++){ (retval,rest)=tav[i]; if (rest==name) return (retval,index); } return (nil,"find_var: impossible!!"); # if we get here, the variable needs to be # created. TCL_UNKNOWN => if (!create) return (nil,"no such variable"); (tnv,tav,nil)=stack->examine(lev); if (index==nil) return (tnv,name); } # if we get here, we are creating an associative variable in the # tav array. for(i=0;i<len tav;i++){ (retval,rest)=tav[i]; if (rest==nil){ retval=htab->alloc(101); tav[i]=(retval,name); return (retval,index); } } return (nil,"associative array table full!"); } # the main parsing function, a la ousterhouts man pages. Takes a # string that is meant to be a tcl statement and parses it, # reevaluating and quoting upto the termchar character. If disable # is true, then whitespace is not ignored. parsecmd(s: string, termchar,disable: int) : array of string { argv:= array[200] of string; buf,nm,id: string; argc := 0; nc := 0; c :=0; tab : ref Hash; if (disable && (termchar=='\n' || termchar==';')) termchar=0; outer: for (i := 0; i<len s ;) { if ((i>0 &&s[i-1]!='\\' &&s[i]==termchar)||(s[0]==termchar)) break; case int s[i] { ' ' or '\t' or '\n' => if (!disable){ if (nc > 0) { # end of a word? argv[argc++] = buf; buf = nil; nc = 0; } i++; } else buf[nc++]=s[i++]; '$' => if (i>0 && s[i-1]=='\\') buf[nc++]=s[i++]; else { (nm,id) = parsename(s[i+1:], termchar); if (id!=nil) nm=nm+"("+id+")"; (tab,nm)=find_var(nm,0); #don't create var! if (len nm > 0 && tab!=nil) { (found, val) := tab.find(nm); buf += val; nc += len val; #sys->print("Here s[i:] is (%s)\n",s[i:]); if(nm==id) while(s[i]!=')') i++; else if (s[i+1]=='{') while(s[i]!='}') i++; else i += len nm; if (nc==0 && (i==len s-1 || s[i+1]==' ' || s[i+1]=='\t'|| s[i+1]==termchar)) argv[argc++]=buf; } else { buf[nc++] = '$'; } i++; } '{' => if (i>0 && s[i-1]=='\\') buf[nc++]=s[i++]; else if (s[i+1]=='}'){ argv[argc++] = nil; buf = nil; nc = 0; i+=2; } else { nbra := 1; for (i++; i < len s; i++) { if (s[i] == '{') nbra++; else if (s[i] == '}') { nbra--; if (nbra == 0) { i++; continue outer; } } buf[nc++] = s[i]; } } '[' => if (i>0 && s[i-1]=='\\') buf[nc++]=s[i++]; else{ a:=evalcmd(s[i+1:],']'); if (error) return nil; if (nc>0){ buf+=a; nc += len a; } else { argv[argc++] = a; buf = nil; nc = 0; } i++; i=strip_to_match(s[i:],i); i++; } '"' => if (i>0 && s[i-1]!='\\' && nc==0){ ans:=parsecmd(s[i+1:],'"',1); #sys->print("len ans is %d\n",len ans); if (len ans!=0){ for(;;){ i++; if(s[i]=='"' && s[i-1]!='\\') break; } i++; argv[argc++] = ans[0]; } else { argv[argc++] = nil; i+=2; } buf = nil; nc = 0; } else buf[nc++] = s[i++]; * => if (s[i]=='\\'){ c=unesc(s[i:]); if (c!=0){ buf[nc++] = c; i+=2; } else { if (i+1 < len s && !(s[i+1]=='"' || s[i+1]=='$' || s[i+1]=='{' || s[i+1]=='[')) buf[nc++]=s[i]; i++; } c=0; } else buf[nc++]=s[i++]; } } if (nc > 0) # fix up last word if present argv[argc++] = buf; ret := array[argc] of string; ret[0:] = argv[0:argc]; return ret; } # parses a name by Tcl rules, a valid name is either $foo, $foo(bar) # or ${foo}. parsename(s: string, termchar: int) : (string,string) { ret,arr,rest: string; rets : array of string; if (len s == 0) return (nil,nil); if (s[0]=='{'){ (ret,nil)=str->splitl(s,"}"); #sys->print("returning [%s]\n",ret[1:]); return (ret[1:],nil); } loop: for (i := 0; i < len s && s[i] != termchar; i++) { case (s[i]) { 'a' to 'z' or 'A' to 'Z' or '0' to '9' or '_' => ret[i] = s[i]; * => break loop; '(' => arr=ret[0:i]; rest=s[i+1:]; rets=parsecmd(rest,')',0); # should always be len 1? if (len rets >1) sys->print("len rets>1 in parsename!\n"); return (arr,rets[0]); } } return (ret,nil); } loadfile(file :string) : string { iob : ref Iobuf; msg,input,line : string; if (file==nil) return nil; iob = bufmod->open(file,bufmod->OREAD); if (iob==nil) return notify(0,sys->sprint( "couldn't read file \"%s\":%r",file)); while((input=iob.gets('\n'))!=nil){ line+=input; if (finished(line,0)){ # put in a return catch here... line = prepass(line); msg=evalcmd(line,0); if (error) return errmsg; line=nil; } } return msg; } #unescapes a string. Can do better..... unesc(s: string) : int { c: int; if (len s == 1) return 0; case s[1] { 'a'=> c = '\a'; 'n'=> c = '\n'; 't'=> c = '\t'; 'r'=> c = '\r'; 'b'=> c = '\b'; '\\'=> c = '\\'; '}' => c = '}'; ']' => c=']'; # do hex and octal. * => c = 0; } return c; } # prepass a string and replace "\\n[ \t]*" with ' ' prepass(s : string) : string { for(i := 0; i < len s; i++) { if(s[i] != '\\') continue; j:=i; if (s[i+1] == '\n') { s[j]=' '; i++; while(i<len s && (s[i]==' ' || s[i]=='\t')) i++; if (i==len s) s = s[0:j]; else s=s[0:j]+s[i+1:]; i=j; } } return s; } exec(argv : array of string) : string { msg : string; if (argv[0]=="") return nil; case (argv[0]) { "append" => msg= do_append(argv); "array" => msg= do_array(argv); "break" or "continue" => return argv[0]; "catch" => msg=do_catch(argv); "debug" => msg=do_debug(argv); "dumpstack" => msg=do_dumpstack(argv); "exit" => do_exit(); "expr" => msg = do_expr(argv); "eval" => msg = do_eval(argv); "for" => msg = do_for(argv); "foreach" => msg = do_foreach(argv); "format" => msg = do_string(argv); "global" => msg = do_global(argv); "if" => msg = do_if(argv); "incr" => msg = do_incr(argv); "info" => msg = do_info(argv); "lappend" => msg = do_lappend(argv); "level" => msg=sys->sprint("Current Stack "+ "level is %d", stack->level()); "load" => msg=do_load(argv); "proc" => msg=do_proc(argv); "return" => msg=do_return(argv); retfl =1; "set" => msg = do_set(argv); "source" => msg = do_source(argv); "string" => msg = do_string(argv); "switch" => msg = do_switch(argv); "time" => msg=do_time(argv); "unset" => msg = do_unset(argv); "uplevel" => msg=do_uplevel(argv); "upvar" => msg=do_upvar(argv); "while" => msg = do_while(argv); "#" => msg=nil; * => msg = uproc(argv); } return msg; } # from here on is the list of commands, alpahabetised, we hope. do_append(argv :array of string) : string { tab : ref Hash; if (len argv==1 || len argv==2) return notify(1, "append varName value ?value ...?"); name := argv[1]; (tab,name)=find_var(name,1); if (tab==nil) return notify(0,name); (found, val) := tab.find(name); for (i:=2;i<len argv;i++) val+=argv[i]; tab.insert(name,val); return val; } do_array(argv : array of string) : string { tab : ref Hash; name : string; flag : int; if (len argv!=3) return notify(1,"array [names, size] name"); case argv[1] { "names" => flag=1; "size" => flag=0; * => return notify(0,"expexted names or size, got "+argv[1]); } (tag,lev,al) := isa(argv[2]); if (tag!=TCL_ARRAY) return notify(0,argv[2]+" isn't an array"); (nil,tav,nil):=stack->examine(lev); for (i:=0;i<len tav;i++){ (tab,name)=tav[i]; if (name==al) break; } if (flag==0) return string tab.lsize; return tab.dump(); } do_catch(argv : array of string) : string { if (len argv==1 || len argv > 3) return notify(1,"catch command ?varName?"); msg:=evalcmd(argv[1],0); if (len argv==3 && error){ (tab,name):=find_var(argv[2],1); if (tab==nil) return notify(0,name); tab.insert(name, msg); } ret:=string error; error=0; return ret; } do_debug(argv : array of string) : string { add : string; if (len argv!=2) return notify(1,"debug"); (i,rest):=str->toint(argv[1],10); if (rest!=nil) return notify(0,"Expected integer and got "+argv[1]); tclmod.debug=i; if (tclmod.debug==0) add="off"; else add="on"; return "debugging is now "+add+" at level"+ string i; } do_dumpstack(argv : array of string) : string { if (len argv!=1) return notify(1,"dumpstack"); stack->dump(); return nil; } do_eval(argv : array of string) : string { eval_str : string; for(i:=1;i<len argv;i++){ eval_str += argv[i]; eval_str[len eval_str]=' '; } return evalcmd(eval_str[0:len eval_str -1],0); } do_exit(){ kfd := sys->open("#p/"+string mypid+"/ctl", sys->OWRITE); if(kfd == nil) sys->print("error opening pid %d (%r)\n",mypid); sys->fprint(kfd, "killgrp"); exit; } do_expr(argv : array of string) : string { retval : string; for (i:=1;i<len argv;i++){ retval+=argv[i]; retval[len retval]=' '; } retval=retval[0: len retval -1]; argv=parsecmd(retval,0,0); cal:=lookup("calc"); (err,ret):= cal->exec(ref tclmod,argv); if (err) return notify(0,ret); return ret; } do_for(argv : array of string) : string { if (len argv!=5) return notify(1,"for start test next command"); test := array[] of {"expr",argv[2]}; evalcmd(argv[1],0); for(;;){ msg:=do_expr(test); if (msg=="Error!") return notify(0,sys->sprint( "syntax error in expression \"%s\"", argv[2])); if (msg=="0") return nil; msg=evalcmd(argv[4],0); if (msg=="break") return nil; if (msg=="continue"); #do nothing! evalcmd(argv[3],0); if (error) return errmsg; } } do_foreach(argv: array of string) : string{ tab : ref Hash; if (len argv!=4) return notify(1,"foreach varName list command"); name := argv[1]; (tab,name)=find_var(name,1); if (tab==nil) return notify(0,name); arr:=utils->break_it(argv[2]); for(i:=0;i<len arr;i++){ tab.insert(name,arr[i]); evalcmd(argv[3],0); } return nil; } do_global(argv : array of string) : string { if (len argv==1) return notify(1,"global varName ?varName ...?"); if (symtab==nil) return nil; for (i:=1 ; i < len argv;i++) symtab.insert(argv[i],argv[i],0); return nil; } do_if(argv : array of string) : string { if (len argv==1) return notify(1,"no expression after \"if\" argument"); expr1 := array[] of {"expr",argv[1]}; msg:=do_expr(expr1); if (msg=="Error!") return notify(0,sys->sprint( "syntax error in expression \"%s\"", argv[1])); if (len argv==2) return notify(1,sys->sprint( "no script following \""+ "%s\" argument",msg)); if (msg=="0"){ if (len argv>3){ if (argv[3]=="else"){ if (len argv==4) return notify(1, "no script"+ " following \"else\" argument"); return evalcmd(argv[4],0); } if (argv[3]=="elseif"){ argv[3]="if"; return do_if(argv[3:]); } } return nil; } return evalcmd(argv[2],0); } do_incr(argv :array of string) : string { num,xtra : int; rest :string; tab : ref Hash; if (len argv==1) return notify(1,"incr varName ?increment?"); name := argv[1]; (tab,name)=find_var(name,0); #doesn't create!! if (tab==nil) return notify(0,name); (found, val) := tab.find(name); if (!found) return notify(0,sys->sprint("can't read \"%s\": " +"no such variable",name)); (num,rest)=str->toint(val,10); if (rest!=nil) return notify(0,sys->sprint( "expected integer but got \"%s\"",val)); if (len argv == 2){ num+=1; tab.insert(name,string num); } if (len argv == 3) { val = argv[2]; (xtra,rest)=str->toint(val,10); if (rest!=nil) return notify(0,sys->sprint( "expected integer but got \"%s\"" ,val)); num+=xtra; tab.insert(name, string num); } return string num; } do_info(argv : array of string) : string { if (len argv==1) return notify(1,"info option ?arg arg ...?"); case argv[1] { "args" => return do_info_args(argv,0); "body" => return do_info_args(argv,1); "commands" => return do_info_commands(argv); "exists" => return do_info_exists(argv); "procs" => return do_info_procs(argv); } return sys->sprint( "bad option \"%s\": should be args, body, commands, exists, procs", argv[1]); } do_info_args(argv : array of string,body :int) : string { name: string; s : sproc; if (body) name="body"; else name="args"; if (len argv!=3) return notify(1,"info "+name+" procname"); for(i:=0;i<len proctab;i++){ s=proctab[i]; if (s.name==argv[2]) break; } if (i==len proctab) return notify(0,argv[2]+" isn't a procedure."); if (body) return s.script; return s.args; } do_info_commands(argv : array of string) : string { if (len argv==1 || len argv>3) return notify(1,"info commands [pattern]"); return libmods.dump(); } do_info_exists(argv : array of string) : string { name, index : string; tab : ref Hash; if (len argv!=3) return notify(1,"info exists varName"); (name,index)=parsename(argv[2],0); (i,nil,nil):=isa(name); if (i==TCL_UNKNOWN) return "0"; if (index==nil) return "1"; (tab,name)=find_var(argv[2],0); if (tab==nil) return "0"; (found, val) := tab.find(name); if (!found) return "0"; return "1"; } do_info_procs(argv : array of string) : string { if (len argv==1 || len argv>3) return notify(1,"info procs [pattern]"); retval : string; for(i:=0;i<len proctab;i++){ s:=proctab[i]; if (s.name!=nil){ retval+=s.name; retval[len retval]=' '; } } return retval; } do_lappend(argv : array of string) : string{ tab : ref Hash; retval :string; retval=nil; if (len argv==1 || len argv==2) return notify(1, "lappend varName value ?value ...?"); name := argv[1]; (tab,name)=find_var(name,1); if (tab==nil) return notify(0,name); (found, val) := tab.find(name); for(i:=2;i<len argv;i++){ flag:=0; if (spaces(argv[i])) flag=1; if (flag) retval[len retval]='{'; retval += argv[i]; if (flag) retval[len retval]='}'; retval[len retval]=' '; } if (retval!=nil) retval=retval[0:len retval-1]; if (val!=nil) retval=val+" "+retval; tab.insert(name,retval); return retval; } spaces(s : string) : int{ if (s==nil) return 1; for(i:=0;i<len s;i++) if (s[i]==' ' || s[i]=='\t') return 1; return 0; } do_load(argv : array of string) : string { # look for a dis library to load up, then # add to library array. if (len argv!=2) return notify(1,"load libname"); fname:="/dis/lib/tcl_"+argv[1]+".dis"; mod:= load TclLib fname; if (mod==nil) return notify(0, sys->sprint("Cannot load %s",fname)); arr:=mod->about(); for(i:=0;i<len arr;i++) libmods.insert(arr[i],mod); return nil; } do_proc(argv : array of string) : string { if (len argv != 4) return notify(1,"proc name args body"); for(i:=0;i<len proctab;i++) if (proctab[i].name==nil || proctab[i].name==argv[1]) break; if (i==len proctab) return notify(0,"procedure table full!"); proctab[i].name=argv[1]; proctab[i].args=argv[2]; proctab[i].script=argv[3]; return nil; } do_return(argv : array of string) : string { if (len argv==1) return nil; # put in options here..... return argv[1]; } do_set(argv : array of string) : string { tab : ref Hash; if (len argv == 1 || len argv > 3) return notify(1,"set varName ?newValue?"); name := argv[1]; (tab,name)=find_var(name,1); if (tab==nil) return notify(0,name); (found, val) := tab.find(name); if (len argv == 2) if (!found) val = notify(0,sys->sprint( "can't read \"%s\": " +"no such variable",name)); if (len argv == 3) { val = argv[2]; tab.insert(name, val); } return val; } do_source(argv : array of string) : string { if (len argv !=2) return notify(1,"source fileName"); return loadfile(argv[1]); } do_string(argv : array of string) : string { stringmod := lookup("string"); if (stringmod==nil) return notify(0,sys->sprint( "String Package not loaded (%r)")); (err,retval):= stringmod->exec(ref tclmod,argv); if (err) return notify(0,retval); return retval; } do_switch(argv : array of string) : string { i:=0; arr : array of string; if (len argv < 3) return notify(1,"switch " +"?switches? string pattern body ... "+ "?default body?\""); if (len argv == 3) arr=utils->break_it(argv[2]); else arr=argv[2:]; if (len arr % 2 !=0) return notify(0, "extra switch pattern with no body"); for (i=0;i<len arr;i+=2) if (argv[1]==arr[i]) break; if (i==len arr){ if (arr[i-2]=="default") return evalcmd(arr[i-1],0); else return nil; } while (i<len arr && arr[i+1]=="-") i+=2; return evalcmd(arr[i+1],0); } do_time(argv : array of string) : string { rest : string; end,start,times : int; if (len argv==1 || len argv>3) return notify(1,"time command ?count?"); if (len argv==2) times=1; else{ (times,rest)=str->toint(argv[2],10); if (rest!=nil) return notify(0,sys->sprint( "expected integer but got \"%s\"",argv[2])); } start=sys->millisec(); for(i:=0;i<times;i++) evalcmd(argv[1],0); end=sys->millisec(); r:= (real end - real start) / real times; return sys->sprint("%g milliseconds per iteration", r); } do_unset(argv : array of string) : string { tab : ref Hash; name: string; if (len argv == 1) return notify(1,"unset "+ "varName ?varName ...?"); for(i:=1;i<len argv;i++){ name = argv[i]; (tab,name)=find_var(name,0); if (tab==nil) return notify(0,sys->sprint("can't unset \"%s\": no such" + " variable",name)); tab.delete(name); } return nil; } do_uplevel(argv : array of string) : string { level: int; rest,scr : string; scr=nil; exact:=0; i:=1; if (len argv==1) return notify(1,"uplevel ?level? command ?arg ...?"); if (len argv==2) level=-1; else { lev:=argv[1]; if (lev[0]=='#'){ exact=1; lev=lev[1:]; } (level,rest)=str->toint(lev,10); if (rest!=nil){ i=2; level =-1; } } oldlev:=stack->level(); if (!exact) level+=oldlev; (tnv,tav,sym):=stack->examine(level); if (tnv==nil && tav==nil) return notify(0,"bad level "+argv[1]); if (tclmod.debug==2) sys->print("In uplevel, current level is %d, moving to level %d\n", oldlev,level); stack->move(level); oldav:=avtab; oldnv:=nvtab; oldsym:=symtab; avtab=tav; nvtab=tnv; symtab=sym; for(;i<len argv;i++) scr=scr+argv[i]+" "; msg:=evalcmd(scr[0:len scr-1],0); avtab=oldav; nvtab=oldnv; symtab=oldsym; ok:=stack->move(oldlev); if (tclmod.debug==2) sys->print("Leaving uplevel, current level is %d, moving back to"+ " level %d,move was %d\n", level,oldlev,ok); return msg; } do_upvar(argv : array of string) : string { level:int; rest:string; i:=1; exact:=0; if (len argv<3 || len argv>4) return notify(1,"upvar ?level? ThisVar OtherVar"); if (len argv==3) level=-1; else { lev:=argv[1]; if (lev[0]=='#'){ exact=1; lev=lev[1:]; } (level,rest)=str->toint(lev,10); if (rest!=nil){ i=2; level =-1; } } if (!exact) level+=stack->level(); symtab.insert(argv[i],argv[i+1],level); return nil; } do_while(argv : array of string) : string { if (len argv!=3) return notify(1,"while test command"); for(;;){ expr1 := array[] of {"expr",argv[1]}; msg:=do_expr(expr1); if (msg=="Error!") return notify(0,sys->sprint( "syntax error in expression \"%s\"", argv[1])); if (msg=="0") return nil; evalcmd(argv[2],0); if (error) return errmsg; } } uproc(argv : array of string) : string { cmd,add : string; for(i:=0;i< len proctab;i++) if (proctab[i].name==argv[0]) break; if (i==len proctab) return notify(0,sys->sprint("invalid command name \"%s\"", argv[0])); # save tables # push a newframe # bind args to arguments # do cmd # pop frame # return msg # globals are supported, but upvar and uplevel are not! arg_arr:=utils->break_it(proctab[i].args); j:=len arg_arr; if (len argv < j+1 && arg_arr[j-1]!="args"){ j=len argv-1; return notify(0,sys->sprint( "no value given for"+ " parameter \"%s\" to \"%s\"", arg_arr[j],proctab[i].name)); } if ((len argv > j+1) && arg_arr[j-1]!="args") return notify(0,"called "+proctab[i].name+ " with too many arguments"); oldavtab:=avtab; oldnvtab:=nvtab; oldsymtab:=symtab; (nvtab,avtab,symtab)=stack->newframe(); for (j=0;j< len arg_arr-1;j++){ cmd="set "+arg_arr[j]+" {"+argv[j+1]+"}"; evalcmd(cmd,0); } if (len arg_arr>j && arg_arr[j] != "args") { cmd="set "+arg_arr[j]+" {"+argv[j+1]+"}"; evalcmd(cmd,0); } else { if (len arg_arr > j) { if (j+1==len argv) add=""; else add=argv[j+1]; cmd="set "+arg_arr[j]+" "; arglist:="{"+add+" "; j++; while(j<len argv-1) { arglist+=argv[j+1]; arglist[len arglist]=' '; j++; } arglist[len arglist]='}'; cmd+=arglist; evalcmd(cmd,0); } } msg:=evalcmd(proctab[i].script,0); stack->pop(); avtab=oldavtab; nvtab=oldnvtab; symtab=oldsymtab; #sys->print("Error is %d, msg is %s\n",error,msg); return msg; } do_tk(argv : array of string) : string { tkpack:=lookup("button"); (err,retval):= tkpack->exec(ref tclmod,argv); if (err) return notify(0,retval); return retval; } lookup(s : string) : TclLib { (found,mod):=libmods.find(s); if (!found) return nil; return mod; }