;+ ; Procedure: evaluator_routines ; ; Purpose: When called this routine compiles a library of helper routines ; for the evaluator of the mini_language ; ; $LastChangedBy: egrimes $ ; $LastChangedDate: 2013-10-28 09:23:38 -0700 (Mon, 28 Oct 2013) $ ; $LastChangedRevision: 13411 $ ; $URL: svn+ssh://thmsvn@ambrosia.ssl.berkeley.edu/repos/spdsoft/trunk/general/mini/evaluator_routines.pro $ ;- ;constructs a tvar data struct for mini_routines used in evaluation function make_tvar_data,name,data,limits,dlimits compile_opt hidden if in_set('x',strlowcase(tag_names(data))) then begin x = data.x endif else begin x = '' endelse if in_set('y',strlowcase(tag_names(data))) then begin y = data.y endif else begin message,'Y component of tplot variable missing. Name: ' + name endelse if in_set('v',strlowcase(tag_names(data))) then begin v = data.v endif else begin v = '' endelse if is_equal(limits,0) then begin l = '' endif else begin l = limits endelse if is_equal(dlimits,0) then begin dl = '' endif else begin dl = dlimits endelse return,{type:'tvar_data',name:name,times:x,data:y,yvalues:v,limits:l,dlimits:dl} end ;constructs a var data struct for mini_routines used in evaluation function make_var_data,name,data compile_opt hidden return,{type:'var_data',name:name,data:data} end ;list is optional function make_arg_list,arg,list compile_opt hidden if ~keyword_set(list) then begin return,{type:'arg_list',data:arg,length:1,next:''} endif return,{type:'arg_list',data:arg,length:(list.length+1),next:list} end ;turns a tvar data type from evaluation into a data component for use with store_data function make_data_type,tvar_type compile_opt hidden if ~is_tvar_data(tvar_type) || (is_equal(tvar_type.yvalues,'') && is_equal(tvar_type.times,'')) then begin return,{y:tvar_type.data} endif else if is_equal(tvar_type.yvalues,'') then begin return,{x:tvar_type.times,y:tvar_type.data} endif else if is_equal(tvar_type.times,'') then begin return,{y:tvar_type.data,v:tvar_type.yvalues} endif else begin return,{x:tvar_type.times,y:tvar_type.data,v:tvar_type.yvalues} endelse end ;turns a tvar data type from evaluation into a limits component for use with store_data function make_limits_type,tvar_type compile_opt hidden if ~is_tvar_data(tvar_type) || is_equal(tvar_type.limits,'') then begin return,0 endif else begin return,tvar_type.limits endelse end ;turns a tvar data type from evaluation into a dlimits component for use with store_data function make_dlimits_type,tvar_type compile_opt hidden if ~is_tvar_data(tvar_type) || is_equal(tvar_type.dlimits,'') then begin return,0 endif else begin return,tvar_type.dlimits endelse end ;replaces the data component of variable or tplot variable ;This is for use in cases where the new data compnent may have ;different dimensions function replace_data,var,data compile_opt hidden if is_var_data(var) then begin return,make_var_data(var.name,data) endif else begin return,{type:var.type, $ name:var.name, $ times:var.times, $ data:data,$ yvalues:var.yvalues,$ limits:var.limits,$ dlimits:var.dlimits} endelse end ;performs a dimensional correction so ;that operations that would collapse the leading ;dimension transform from MxN to 1xN, this ;makes handling elsewhere more consistent function dim_correct_data,data,xdim,opdim compile_opt hidden if opdim eq 1 && xdim gt 1 then begin return,reform(data,[1,dimen(data)]) endif else begin return,data endelse end ;Certain operations will result in fewer dimensions. ;If there are associated times, these must ;have a corresponding reduction for the quantity to remain ;well-formed function reduce_times,var,dim compile_opt hidden if is_tvar_data(var) && ~is_equal(var.times,'') && $ (~keyword_set(dim) || dim.data eq 0 || dim.data eq 1) then begin return,{type:var.type, $ name:var.name, $ times:ndimen(var.times)?median(var.times,/even):median([var.times],/even), $ data:var.data,$ yvalues:var.yvalues,$ limits:var.limits,$ dlimits:var.dlimits} endif else begin return,var endelse end ;Certain operations will result in fewer dimensions. ;If there are associated yvalues, these must ;have a corresponding reduction for the quantity to remain ;well-formed function reduce_yvalues,var,dim compile_opt hidden if is_tvar_data(var) && ~is_equal(var.yvalues,'') then begin if ~keyword_set(dim) || dim.data eq 0 then begin return,{type:var.type, $ name:var.name, $ times:var.times, $ data:var.data,$ yvalues:ndimen(var.yvalues)?median(var.yvalues,/even):median([var.yvalues],/even),$ limits:var.limits,$ dlimits:var.dlimits} endif else if dim.data eq 1 then begin if ndimen(var.yvalues) ge 2 then begin return,{type:var.type, $ name:var.name, $ times:var.times, $ data:var.data,$ yvalues:dim_correct_data(median(var.yvalues,dim=1,/even),ndimen(var.yvalues),1),$ limits:var.limits,$ dlimits:var.dlimits} endif endif else if dim.data eq 2 then begin if ndimen(var.yvalues) ge 2 then begin return,{type:var.type, $ name:var.name, $ times:var.times, $ data:var.data,$ yvalues:median(var.yvalues,dim=2,/even),$ limits:var.limits,$ dlimits:var.dlimits} endif else begin return,{type:var.type, $ name:var.name, $ times:var.times, $ data:var.data,$ yvalues:ndimen(var.yvalues)?median(var.yvalues,/even):median([var.yvalues],/even),$ limits:var.limits,$ dlimits:var.dlimits} endelse endif endif return,var end ;Certain operations will result in fewer dimensions. ;If there are associated limits/dlimits, this ;will reduce the labels/colors function reduce_dlimits,var,label,dim if ~keyword_set(dim) || dim.data ne 2 then return,var ; only applies if totaling over dim 2 var_out = var dlimits = make_dlimits_type(var) if keyword_set(dlimits) then begin if in_set(strlowcase(tag_names(dlimits)),'dlimits') then begin dl = dlimits.dlimits endif else begin dl = dlimits endelse if in_set(strlowcase(tag_names(dl)),'colors') && n_elements(dl.colors) gt 1 then begin str_element,dl,'colors',0,/add endif if in_set(strlowcase(tag_names(dl)),'labels') && n_elements(dl.labels) gt 1 then begin str_element,dl,'labels',label,/add endif if in_set(strlowcase(tag_names(dlimits)),'dlimits') then begin str_element,dlimits,'dlimits',dl,/add endif else begin dlimits = dl endelse str_element,var_out,'dlimits',dlimits,/add endif limits = make_limits_type(var) if keyword_set(limits) then begin if in_set(strlowcase(tag_names(limits)),'colors') && n_elements(limits.colors) gt 1 then begin str_element,limits,'colors',0,/add endif if in_set(strlowcase(tag_names(limits)),'labels') && n_elements(limits.labels) gt 1 then begin str_element,limits,'labels',label,/add endif str_element,var_out,'limits',limits,/add endif return,var_out end ;abstraction routine determines whether its input is a tvar type or not ; this is different from a tvar data type 1=yes 0=no function is_tvar_type,in compile_opt idl2,hidden mini_predicates if is_string_type(in) then begin return,1 endif else begin return,0 endelse end ;abstraction routine determines whether its input is a var type or not ;this is different from a var data type 1=yes 0=no function is_var_type,in compile_opt idl2,hidden mini_predicates if is_identifier_type(in) then begin return,1 endif else begin return,0 endelse end ;abstracts the data storage process pro store_var_data,name,value compile_opt hidden if is_tvar_type(name) then begin overwrite_selection = '' overwrite_count = (*!mini_globals.replay_struct).overwrite_count gui_prompt_obj = (*!mini_globals.replay_struct).calc_prompt_obj ; correctly handle 'yes to all' and 'no to all' selections if (*!mini_globals.replay_struct).replay ne 1 then begin ; not replaying a document, check the user's previous selection. If the user selected '*toall', it *should* be stored as the last selection previous_selection = (*!mini_globals.replay_struct).overwrite_selections[n_elements((*!mini_globals.replay_struct).overwrite_selections)-1] endif else begin ; Need to check if the user selected yestoall or notoall in the saved document to correctly handle the ; case where a user selects 'no' followed by 'yestoall', or 'yes' followed by 'notoall' ; we need to check where the 'yes/notoall' is in the array relative to where we are in replaying the calc operations whereyestoall = where((*!mini_globals.replay_struct).overwrite_selections eq 'yestoall', yestoallcount) wherenotoall = where((*!mini_globals.replay_struct).overwrite_selections eq 'notoall', notoallcount) if yestoallcount then if (*!mini_globals.replay_struct).overwrite_count ge whereyestoall[0] then overwrite_selection = 'yestoall' if notoallcount then if (*!mini_globals.replay_struct).overwrite_count ge wherenotoall[0] then overwrite_selection = 'notoall' previous_selection = '' endelse if previous_selection eq 'notoall' then overwrite_selection = 'notoall' if previous_selection eq 'yestoall' then overwrite_selection = 'yestoall' ; check if we're storing tplot data in the TDAS GUI ; if so, check if the variable exists in the loadedData object ; if it exists, prompt the user to overwrite it if obj_valid(!mini_globals.gui_data_obj) then begin names = !mini_globals.gui_data_obj->getall() wherenames = where(name.value eq names, wherecount) if wherecount gt 0 then begin ; new variable already exists if overwrite_selection ne 'yestoall' then begin if overwrite_selection eq 'notoall' then return overwrite_selection = '' if (*!mini_globals.replay_struct).replay ne 0 then begin if overwrite_count gt n_elements((*!mini_globals.replay_struct).overwrite_selections) then begin hwin = (*!mini_globals.replay_struct).historywin sbar = (*!mini_globals.replay_struct).statusbar if obj_valid(hwin) then hwin->update,"ERROR:Discrepancy in themis document, may have lead to a document load error" if obj_valid(sbar) then sbar->update,"ERROR:Discrepancy in themis document, may have lead to a document load error" overwrite_selection = "yestoall" endif else begin overwrite_selection = ((*!mini_globals.replay_struct).overwrite_selections)[overwrite_count] endelse endif else begin prompt = 'Do you want to overwrite '+name.value+' with the new data?' if obj_valid(gui_prompt_obj) then begin overwrite_selection = gui_prompt_obj->sendtoScreen(prompt, 'Overwrite Existing Data?', gui_id = (*!mini_globals.replay_struct).gui_id) endif else begin dprint,dlevel=0,'Error in store_var_data, no valid GUI prompt object' endelse newarray = array_concat_wrapper(overwrite_selection,(*!mini_globals.replay_struct).overwrite_selections) str_element, *!mini_globals.replay_struct, 'overwrite_selections', newarray, /add_rep endelse ; increase the count by one (*!mini_globals.replay_struct).overwrite_count = (*!mini_globals.replay_struct).overwrite_count + 1 if overwrite_selection eq 'no' || overwrite_selection eq 'notoall' then begin return endif endif endif data = make_data_type(value) limits = make_limits_type(value) tmp_limits = make_dlimits_type(value) dlimits = tmp_limits.dlimits obj = tmp_limits.object obj->setProperty,name=name.value store_data,name.value,data=data,limits=limits,dlimits=dlimits,error=e if e then begin message,'store_data error' endif if ~!mini_globals.gui_data_obj->addTvarObject(obj) then begin message,'loaded_data error' endif endif else begin limits = make_limits_type(value) dlimits = make_dlimits_type(value) ;unset inherited parameters str_element,limits,'ytitle',/delete str_element,dlimits,'ytitle',/delete str_element,limits,'ysubtitle',/delete str_element,dlimits,'ysubtitle',/delete str_element,limits,'yrange',/delete str_element,dlimits,'yrange',/delete str_element,limits,'ztitle',/delete str_element,dlimits,'ztitle',/delete str_element,limits,'zsubtitle',/delete str_element,dlimits,'zsubtitle',/delete str_element,limits,'zrange',/delete str_element,dlimits,'zrange',/delete ;log scaling still inherited store_data,name.value,data=make_data_type(value),limits=limits,dlimit=dlimits,error=e if e then begin message,'store_data error' endif endelse ; dprint,setdebug=g endif else if is_var_type(name) then begin (scope_varfetch(name.value,/enter,level=!mini_globals.scope_level)) = value.data endif else begin message,'Wrong type in store_var_data' endelse end ;determines whether an entry in the parse table is an error or not function is_error_code,in compile_opt idl2,hidden if is_equal(in,'') then begin return,1 endif else begin return,0 endelse end ;determines whether an entry in the parse table is a shift code or not function is_shift_code,in compile_opt idl2,hidden if strlen(in) gt 1 && strmid(in,0,1) eq 's' then begin return,1 endif else begin return,0 endelse end ;gets the shift code from a parse table entry function get_shift_num,in compile_opt idl2,hidden if strlen(in) lt 2 then begin return,-1 endif else begin return,long(strmid(in,1)) endelse end ;determines whether an entry in the parse table is a reduce code or not function is_reduce_code,in compile_opt idl2,hidden if strlen(in) gt 1 && strmid(in,0,1) eq 'r' then begin return,1 endif else begin return,0 endelse end ;determines if binary operator arguments are compatible function is_valid_bop_arg,arg1,arg2,arg3 compile_opt idl2,hidden dim1 = dimen(arg1.data) dim2 = dimen(arg3.data) ndim1 = ndimen(arg1.data) ndim2 = ndimen(arg3.data) ;scalar exemption if product(dim1) eq 1 || product(dim2) eq 1 then return,1 ;matrix multiplication rules type 1 if arg2.name eq '#' then begin if ndim1 eq 1 && ndim2 eq 1 then return,1 if ndim1 eq 1 && ndim2 eq 2 && $ dim1[0] eq dim2[0] then return,1 if ((ndim1 eq 2 && ndim2 eq 1) || $ (ndim1 eq 2 && ndim2 eq 2)) && $ dim1[1] eq dim2[0] then return,1 ;matrix multiplication rules type 2 endif else if arg2.name eq '##' then begin if ndim1 eq 1 && ndim2 eq 1 then return,1 if ndim1 eq 2 && ndim2 eq 1 && $ dim1[0] eq dim2[0] then return,1 if ((ndim1 eq 1 && ndim2 eq 2) || $ (ndim1 eq 2 && ndim2 eq 2)) && $ dim1[0] eq dim2[1] then return,1 ;other operation rules endif else begin if array_equal(dim1,dim2) then return,1 endelse return,0 end ;gets the reduce code from a parse table entry function get_reduce_num,in compile_opt idl2,hidden if strlen(in) lt 2 then begin return,-1 endif else begin return,long(strmid(in,1)) endelse end ;evaluates each token passed to it. ;the most important aspect of this function ;is to translate tokens from the lexer into a format that ;the evaluator can read. This entails making sure the name component of ;the output structure is a terminal from the language grammar function eval_token,token,previous,grammar compile_opt idl2,hidden mini_predicates mini_routines if is_function_type(token) then begin tk = get_function(token) if ~is_struct(tk) then begin return, {type:'error',name:'function lookup error',value:token.name,position:n} endif else begin tk.name = 'func' ev = tk endelse endif else if is_var_type(token) then begin ev = {type:token.type,name:'var',value:token.name,index:0} endif else if is_tvar_type(token) then begin ev = {type:token.type,name:'tvar',value:strmid(token.name,1,strlen(token.name)-2),index:0} endif else if is_operator_type(token) then begin ev = token if token.name eq '-' then begin if is_unary_minus(token,previous) then begin ev.name = 'u-' endif else begin ev.name = 'b-' endelse ev.value = token.name endif else if token.name eq '+' then begin if is_unary_plus(token,previous) then begin ev.name = 'u+' endif else begin ev.name = 'b+' endelse ev.value = token.name endif else if token.name eq '/' then begin if is_keyword_slash(token,previous) then begin ev.name = 'k/' endif else begin ev.name = 'b/' endelse ev.value = ev.name endif endif else if is_assignment_type(token) then begin ev = token if strlen(token.value) gt 1 then begin ev.value = strmid(token.value,0,1) endif if ev.value eq '-' then begin ev.value = 'b-' endif else if ev.value eq '+' then begin ev.value = 'b+' endif endif else if is_numerical_type(token) then begin if strpos(token.name,'u') ne -1 then begin unsigned = 1 endif else begin unsigned = 0 endelse if strpos(token.name,'b') ne -1 then begin ev = {type:token.type,name:'number',value:byte(token.name),index:0} endif else if strpos(token.name,'s') ne -1 then begin if unsigned then begin ev = {type:token.type,name:'number',value:uint(token.name),index:0} endif else begin ev = {type:token.type,name:'number',value:fix(token.name),index:0} endelse endif else if strpos(token.name,'d') ne -1 then begin ev = {type:token.type,name:'number',value:double(token.name),index:0} endif else if strpos(token.name,'e') ne -1 || $ strpos(token.name,'.') ne -1 then begin ev = {type:token.type,name:'number',value:float(token.name),index:0} endif else if strpos(token.name,'ll') ne -1 then begin if unsigned then begin ev = {type:token.type,name:'number',value:ulong64(token.name),index:0} endif else begin ev = {type:token.type,name:'number',value:long64(token.name),index:0} endelse endif else if strpos(token.name,'l') ne -1 then begin if unsigned then begin ev = {type:token.type,name:'number',value:ulong(token.name),index:0} endif else begin ev = {type:token.type,name:'number',value:long(token.name),index:0} endelse endif else begin ev = {type:token.type,name:'number',value:float(token.name),index:0} endelse endif else begin ev = {type:token.type,name:token.name,value:token.name,index:0} endelse idx = where(ev.name eq grammar.terminals) if idx[0] eq -1 then begin message,'token should always evaluate to a terminal in language' endif ev.index = idx return,ev end ;validates arguments for mini functions ;No return value, throws error on fail(using message) ;required_args: The number of required positional arguments ;optional_args: The number of optional arguments ;keyword_list: The list of accepted keywords list of strings('' or 0 if none) ;arg_list: The list of arguments to be validated ;Checks: ; Number of args matches required ; No more than requested # of optional args ; No illegal keywords (keyword arguments that match no valid keywords) ; No ambiguous keywords (partial keyword arguments that match multiple valid keywords) pro validate_mini_func_args,required_args,optional_args,keyword_list,arg_list compile_opt hidden,strictarr arg_count = 0 keyword_count = lonarr(n_elements(keyword_list)) arg_iter = arg_list while keyword_set(arg_iter) do begin ;next will be undefined or '' or 0 in base case if ~is_keyword_type(arg_iter.data) then begin arg_count++ endif else begin ;no keywords accepted if ~keyword_set(keyword_list) then message,'Illegal keyword: ' + arg_iter.data.value keyword_matches = stregex(keyword_list,'^'+arg_iter.data.value,/boolean,/fold_case) idx = where(keyword_matches ne 0,c) if c eq 0 then message,'Illegal keyword: ' + arg_iter.data.value keyword_count += keyword_matches idx = where(keyword_count gt 1,c) if c gt 0 then message,'Ambiguous keyword: ' + arg_iter.data.value endelse arg_iter = arg_iter.next endwhile if arg_count lt required_args then message,'Missing required argument(s)' if arg_count gt optional_args+required_args then message,'Too many arguments' end ;Checks linked list arg-struct structure to ;determine if the keyword is set. ;Argument validation is done elsewhere(ambiguous keywords,illegal keywords) ;Returns true, on first partial match function is_mini_keyword_set,arg_list,keyword compile_opt hidden,strictarr if ~keyword_set(arg_list) then return,0 ; could be 0 or '' or undefined if is_keyword_type(arg_list.data) && $ stregex(keyword,'^'+arg_list.data.value,/boolean,/fold_case) then return,1 ;recursive call if arg_list.length gt 1 then return,is_mini_keyword_set(arg_list.next,keyword) return,0 ; matches = stregex(keyword_list,'^'+arg_struct.value,/boolean,/fold_case) ; idx = where(matches,c) ; ; if c eq 0 then begin ; message,'Illegal keyword: ' + arg_struct.value ; endif else if c gt 1 then begin ; message,'Ambiguous keyword: ' + arg_struct.value ; endif end ;Checks linked list arg-structure to ; find the nth positional argument. (counting from 0) ; keyword arguments are skipped function get_positional_arg,arg_list,n compile_opt hidden,strictarr if ~keyword_set(arg_list) then return,0 if is_keyword_type(arg_list.data) then begin if arg_list.length eq 1 then begin ;keyword and no more elements return, 0 ;element not found endif else begin ;keyword and more elements return, get_positional_arg(arg_list.next,n) ;check next element endelse endif if n eq 0 then return, arg_list.data ;not keyword and 0th requested(found it!) if arg_list.length eq 1 then return,0 ;not keyword and gt 0th requested(not enough elements) return, get_positional_arg(arg_list.next,n-1) ;otherwise, skip this position, and decrement positional arg ;cases covered above ;length == 1, type==keyword, return 0 ;length == 1, type!=keyword, n == 0, return type ;length > 1, type==keyword, return recursive(next,n) ;length > 1, type!=keyword, n==0, return type ;length > 1, type!=keyword, n>0, return recursive(next,n-1) end ;this routine just compiles all the routines in this file pro evaluator_routines end