Changeset: 65818a7ebbb2 for MonetDB
URL: http://dev.monetdb.org/hg/MonetDB?cmd=changeset;node=65818a7ebbb2
Modified Files:
        MonetDB5/src/modules/mal/Tests/inspect05.stable.out
        MonetDB5/src/modules/mal/Tests/inspect05.stable.out.Debian
        MonetDB5/src/modules/mal/Tests/inspect05.stable.out.Windows
Branch: default
Log Message:

(re-)approved output for plain MonetDB5, i.e., without sql & geom present


diffs (truncated from 1176 to 300 lines):

diff -r e33136f66a3f -r 65818a7ebbb2 
MonetDB5/src/modules/mal/Tests/inspect05.stable.out
--- a/MonetDB5/src/modules/mal/Tests/inspect05.stable.out       Wed Oct 06 
09:25:51 2010 +0200
+++ b/MonetDB5/src/modules/mal/Tests/inspect05.stable.out       Wed Oct 06 
09:33:49 2010 +0200
@@ -28,81 +28,6 @@
 # str                          str             str             str             
                                                                                
                                        str                                     
                  # type
 
#-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------#
 [ "main",                        "function",     "user",         "():void;",   
                                                                                
                                          "nil"                                 
                  ]
-[ "epiloque",                    "command",      "vault",        "():void ",   
                                                                                
                                          "VLTepilogue;"                        
                  ]
-[ "ftpget",                      "command",      "vault",        
"(src:str,trg:str):void ",                                                      
                                                        "VLTftpget;"            
                                ]
-[ "getdirectory",                "command",      "vault",        "():str ",    
                                                                                
                                          "VLTgetDirectory;"                    
                  ]
-[ "prelude",                     "pattern",      "vault",        "():void ",   
                                                                                
                                          "VLTprelude;"                         
                  ]
-[ "refresh",                     "command",      "vault",        
"(id:int):void ",                                                               
                                                        "VLTrefreshObject;"     
                                ]
-[ "refresh",                     "command",      "vault",        
"(id:str):void ",                                                               
                                                        "VLTrefresh;"           
                                ]
-[ "Area",                        "command",      "geom",         "(g:wkb):dbl 
",                                                                              
                                           "wkbArea;"                           
                   ]
-[ "AsText",                      "command",      "geom",         "(w:wkb):str 
",                                                                              
                                           "wkbAsText;"                         
                   ]
-[ "Buffer",                      "command",      "geom",         
"(a:wkb,distance:dbl):wkb ",                                                    
                                                        "wkbBuffer;"            
                                ]
-[ "Boundary",                    "command",      "geom",         "(w:wkb):wkb 
",                                                                              
                                           "wkbBoundary;"                       
                   ]
-[ "ConvexHull",                          "command",      "geom",         
"(a:wkb):wkb ",                                                                 
                                                        "wkbConvexHull;"        
                                ]
-[ "Contains",                    "command",      "geom",         
"(a:wkb,b:wkb):bit ",                                                           
                                                        "wkbContains;"          
                                ]
-[ "Crosses",                     "command",      "geom",         
"(a:wkb,b:wkb):bit ",                                                           
                                                        "wkbCrosses;"           
                                ]
-[ "CurveFromText",               "function",     "geom",         
"(wkt:str,srid:sht):wkb;",                                                      
                                                        "nil"                   
                                ]
-[ "Difference",                          "command",      "geom",         
"(a:wkb,b:wkb):wkb ",                                                           
                                                        "wkbDifference;"        
                                ]
-[ "Distance",                    "command",      "geom",         
"(a:wkb,b:wkb):dbl ",                                                           
                                                        "wkbDistance;"          
                                ]
-[ "Disjoint",                    "command",      "geom",         
"(a:wkb,b:wkb):bit ",                                                           
                                                        "wkbDisjoint;"          
                                ]
-[ "Dimension",                   "command",      "geom",         "(w:wkb):int 
",                                                                              
                                           "wkbDimension;"                      
                   ]
-[ "Equals",                      "command",      "geom",         
"(a:wkb,b:wkb):bit ",                                                           
                                                        "wkbEquals;"            
                                ]
-[ "Envelope",                    "command",      "geom",         "(w:wkb):wkb 
",                                                                              
                                           "wkbEnvelope;"                       
                   ]
-[ "GeometryTypeId",              "command",      "geom",         "(w:wkb):int 
",                                                                              
                                           "wkbGeometryTypeId;"                 
                   ]
-[ "GeomCollectionFromText",      "function",     "geom",         
"(wkt:str,srid:sht):wkb;",                                                      
                                                        "nil"                   
                                ]
-[ "GeomFromText",                "function",     "geom",         
"(wkt:str,srid:sht):wkb;",                                                      
                                                        "nil"                   
                                ]
-[ "Intersection",                "command",      "geom",         
"(a:wkb,b:wkb):wkb ",                                                           
                                                        "wkbIntersection;"      
                                ]
-[ "Intersect",                   "command",      "geom",         
"(a:wkb,b:wkb):bit ",                                                           
                                                        "wkbIntersect;"         
                                ]
-[ "IsSimple",                    "command",      "geom",         "(w:wkb):bit 
",                                                                              
                                           "wkbIsSimple;"                       
                   ]
-[ "IsEmpty",                     "command",      "geom",         "(w:wkb):bit 
",                                                                              
                                           "wkbIsEmpty;"                        
                   ]
-[ "Length",                      "command",      "geom",         "(g:wkb):dbl 
",                                                                              
                                           "wkbLength;"                         
                   ]
-[ "LineFromText",                "function",     "geom",         
"(wkt:str,srid:sht):wkb;",                                                      
                                                        "nil"                   
                                ]
-[ "MultiPolyFromText",           "function",     "geom",         
"(wkt:str,srid:sht):wkb;",                                                      
                                                        "nil"                   
                                ]
-[ "MultiSurfaceFromText",        "function",     "geom",         
"(wkt:str,srid:sht):wkb;",                                                      
                                                        "nil"                   
                                ]
-[ "MultiLineFromText",           "function",     "geom",         
"(wkt:str,srid:sht):wkb;",                                                      
                                                        "nil"                   
                                ]
-[ "MultiCurveFromText",                  "function",     "geom",         
"(wkt:str,srid:sht):wkb;",                                                      
                                                        "nil"                   
                                ]
-[ "MultiPointFromText",                  "function",     "geom",         
"(wkt:str,srid:sht):wkb;",                                                      
                                                        "nil"                   
                                ]
-[ "Overlaps",                    "command",      "geom",         
"(a:wkb,b:wkb):bit ",                                                           
                                                        "wkbOverlaps;"          
                                ]
-[ "PolyFromText",                "function",     "geom",         
"(wkt:str,srid:sht):wkb;",                                                      
                                                        "nil"                   
                                ]
-[ "PointFromText",               "function",     "geom",         
"(wkt:str,srid:sht):wkb;",                                                      
                                                        "nil"                   
                                ]
-[ "Relate",                      "command",      "geom",         
"(a:wkb,b:wkb,intersectionPatternMatrix:str):bit ",                             
                                                        "wkbRelate;"            
                                ]
-[ "SymDifference",               "command",      "geom",         
"(a:wkb,b:wkb):wkb ",                                                           
                                                        "wkbSymDifference;"     
                                ]
-[ "SRID",                        "command",      "geom",         "(w:wkb):int 
",                                                                              
                                           "wkbSRID;"                           
                   ]
-[ "SurfaceFromText",             "function",     "geom",         
"(wkt:str,srid:sht):wkb;",                                                      
                                                        "nil"                   
                                ]
-[ "Touches",                     "command",      "geom",         
"(a:wkb,b:wkb):bit ",                                                           
                                                        "wkbTouches;"           
                                ]
-[ "Union",                       "command",      "geom",         
"(a:wkb,b:wkb):wkb ",                                                           
                                                        "wkbUnion;"             
                                ]
-[ "Within",                      "command",      "geom",         
"(a:wkb,b:wkb):bit ",                                                           
                                                        "wkbWithin;"            
                                ]
-[ "X",                           "command",      "geom",         "(g:wkb):dbl 
",                                                                              
                                           "wkbgetcoordX;"                      
                   ]
-[ "Y",                           "command",      "geom",         "(g:wkb):dbl 
",                                                                              
                                           "wkbgetcoordY;"                      
                   ]
-[ "epilogue",                    "command",      "geom",         "():void ",   
                                                                                
                                          "geom_epilogue;"                      
                  ]
-[ "mbr",                         "command",      "geom",         "(_1:wkb):mbr 
",                                                                              
                                          "wkbMBR;"                             
                  ]
-[ "mbr",                         "command",      "geom",         
"(_1:flt,_2:flt,_3:flt,_4:flt):mbr ",                                           
                                                        "ordinatesMBR;"         
                                ]
-[ "mbroverlaps",                 "command",      "geom",         
"(a:mbr,b:mbr):bit ",                                                           
                                                        "mbroverlaps;"          
                                ]
-[ "prelude",                     "command",      "geom",         "():void ",   
                                                                                
                                          "geom_prelude;"                       
                  ]
-[ "point",                       "command",      "geom",         
"(x:dbl,y:dbl):wkb ",                                                           
                                                        "wkbcreatepoint;"       
                                ]
-[ "point",                       "command",      "batgeom",      
"(x:bat[:oid,:dbl],y:bat[:oid,:dbl]):bat[:oid,:wkb] ",                          
                                                        "wkbcreatepoint_bat;"   
                                ]
-[ "#cmp",                        "command",      "mbr",          "():int ",    
                                                                                
                                          "mbrCOMP;"                            
                  ]
-[ "#fromstr",                    "command",      "mbr",          "():mbr ",    
                                                                                
                                          "mbrFROMSTR;"                         
                  ]
-[ "#hash",                       "command",      "mbr",          "():int ",    
                                                                                
                                          "mbrHASH;"                            
                  ]
-[ "mbr",                         "command",      "mbr",          "(v:str):mbr 
",                                                                              
                                           "mbrFromString;"                     
                   ]
-[ "#null",                       "command",      "mbr",          "():int ",    
                                                                                
                                          "mbrNULL;"                            
                  ]
-[ "#read",                       "command",      "mbr",          "():void ",   
                                                                                
                                          "mbrREAD;"                            
                  ]
-[ "#tostr",                      "command",      "mbr",          "():str ",    
                                                                                
                                          "mbrTOSTR;"                           
                  ]
-[ "#write",                      "command",      "mbr",          "():void ",   
                                                                                
                                          "mbrWRITE;"                           
                  ]
-[ "FromText",                    "command",      "wkb",          
"(w:str,type:int):wkb ",                                                        
                                                        "wkbFromText;"          
                                ]
-[ "#cmp",                        "command",      "wkb",          "():int ",    
                                                                                
                                          "wkbCOMP;"                            
                  ]
-[ "#del",                        "command",      "wkb",          "():int ",    
                                                                                
                                          "wkbDEL;"                             
                  ]
-[ "#fromstr",                    "command",      "wkb",          "():wkb ",    
                                                                                
                                          "wkbFROMSTR;"                         
                  ]
-[ "#heap",                       "command",      "wkb",          "():int ",    
                                                                                
                                          "wkbHEAP;"                            
                  ]
-[ "#hash",                       "command",      "wkb",          "():int ",    
                                                                                
                                          "wkbHASH;"                            
                  ]
-[ "#length",                     "command",      "wkb",          "():int ",    
                                                                                
                                          "wkbLENGTH;"                          
                  ]
-[ "#null",                       "command",      "wkb",          "():int ",    
                                                                                
                                          "wkbNULL;"                            
                  ]
-[ "#put",                        "command",      "wkb",          "():int ",    
                                                                                
                                          "wkbPUT;"                             
                  ]
-[ "#read",                       "command",      "wkb",          "():void ",   
                                                                                
                                          "wkbREAD;"                            
                  ]
-[ "#tostr",                      "command",      "wkb",          "():str ",    
                                                                                
                                          "wkbTOSTR;"                           
                  ]
-[ "wkb",                         "command",      "wkb",          "(v:str):wkb 
",                                                                              
                                           "wkbFromString;"                     
                   ]
-[ "#write",                      "command",      "wkb",          "():void ",   
                                                                                
                                          "wkbWRITE;"                           
                  ]
-[ "next_value",                          "pattern",      "batsql",       
"(sname:bat[:oid,:str],sequence:str):bat[:oid,:lng] ",                          
                                                        "mvc_bat_next_value;"   
                                ]
 [ "shred",                       "command",      "rdf",          
"(location:str,graphname:str,schema:str):bat[:void,:BAT] ",                     
                                                        "RDFParser;"            
                                ]
 [ "append",                      "command",      "tokenizer",    "(u:str):oid 
",                                                                              
                                           "TKNZRappend;"                       
                   ]
 [ "close",                               "command",      "tokenizer",    
"():void ",                                                                     
                                        "TKNZRclose;"                           
                ]
@@ -1031,126 +956,10 @@
 [ "register",                    "pattern",      "tarantula",    
"(node:int,fname:str...):void ",                                                
                                                        "TARregister;"          
                                ]
 [ "schedule",                    "pattern",      "tarantula",    
"(cost:int...):int... ",                                                        
                                                        "TARschedule;"          
                                ]
 [ "multiplex",                   "pattern",      "mal",          
"(a:any...):any ",                                                              
                                                        "OPTremapMultiplex;"    
                                ]
-[ "argRecord",                   "pattern",      "sql",          
"(a:any...):str ",                                                              
                                                        "SQLargRecord;"         
                                ]
-[ "argRecord",                   "pattern",      "sql",          "():str ",    
                                                                                
                                          "SQLargRecord;"                       
                  ]
-[ "affectedRows",                "pattern",      "sql",          
"(nr:wrd,w:str):void ",                                                         
                                                        
"mvc_affected_rows_wrap;"                               ]
-[ "append",                      "pattern",      "sql",          
"(mvc:ptr,sname:str,tname:str,cname:str,ins:any):ptr ",                         
                                                        "mvc_append_wrap;"      
                                ]
-[ "assert",                      "pattern",      "sql",          
"(b:lng,msg:str):void ",                                                        
                                                        "SQLassertLng;"         
                                ]
-[ "assert",                      "pattern",      "sql",          
"(b:wrd,msg:str):void ",                                                        
                                                        "SQLassertWrd;"         
                                ]
-[ "assert",                      "pattern",      "sql",          
"(b:int,msg:str):void ",                                                        
                                                        "SQLassertInt;"         
                                ]
-[ "assert",                      "pattern",      "sql",          
"(b:bit,msg:str):void ",                                                        
                                                        "SQLassert;"            
                                ]
-[ "bbp",                         "function",     "sql",          
"():bat[:str,:BAT];",                                                           
                                                        "nil"                   
                                ]
-[ "bind_dbat",                   "command",      "sql",          
"(clientid:int,schema:str,table:str,access:int,oldversion:lng,version:lng):bat[:oid,:oid]
 ",                                            "mvc_diff_dbat_wrap;"            
                       ]
-[ "bind",                        "pattern",      "sql",          
"(mvc:ptr,schema:str,table:str,column:str,access:int,low:oid,hgh:oid):bat[:oid,:any_1]
 ",                                               "mvc_bind_wrap;"              
                          ]
-[ "bind",                        "pattern",      "sql",          
"(mvc:ptr,schema:str,table:str,column:str,access:int):bat[:oid,:any_1] ",       
                                                        "mvc_bind_wrap;"        
                                ]
-[ "bind_idxbat",                 "pattern",      "sql",          
"(mvc:ptr,schema:str,table:str,index:str,access:int,low:oid,hgh:oid):bat[:oid,:any_1]
 ",                                                "mvc_bind_idxbat_wrap;"      
                           ]
-[ "bind_idxbat",                 "pattern",      "sql",          
"(mvc:ptr,schema:str,table:str,index:str,access:int):bat[:oid,:any_1] ",        
                                                        "mvc_bind_idxbat_wrap;" 
                                ]
-[ "bind_dbat",                   "pattern",      "sql",          
"(mvc:ptr,schema:str,table:str,access:int):bat[:oid,:oid] ",                    
                                                        "mvc_bind_dbat_wrap;"   
                                ]
-[ "cluster2",                    "pattern",      "sql",          
"(sch:str,tbl:str):void ",                                                      
                                                        "SQLcluster2;"          
                                ]
-[ "cluster1",                    "pattern",      "sql",          
"(sch:str,tbl:str):void ",                                                      
                                                        "SQLcluster1;"          
                                ]
-[ "clients",                     "function",     "sql",          
"():bat[:str,:BAT];",                                                           
                                                        "nil"                   
                                ]
-[ "copyfrom",                    "function",     "sql",          
"(sname:str,tname:str,tsep:str,rsep:str,ssep:str,ns:str,nr:lng,offset:lng):bat[:str,:BAT];",
                                            "nil"                               
                    ]
-[ "copy_from",                   "function",     "sql",          
"(sname:str,tname:str,tsep:str,rsep:str,ssep:str,ns:str,fname:str,nr:lng,offset:lng):bat[:str,:BAT];",
                                  "nil"                                         
          ]
-[ "columnBind",                          "command",      "sql",          
"(b:bat[:str,:BAT],nme:str):bat[:oid,:any_1] ",                                 
                                                        "mvc_bind_single_wrap;" 
                                ]
-[ "clear_table",                 "pattern",      "sql",          
"(sname:str,tname:str):wrd ",                                                   
                                                        "mvc_clear_table_wrap;" 
                                ]
-[ "catalog",                     "pattern",      "sql",          
"(type:int,sname:str,t:ptr,restart:lng):void ",                                 
                                                        "SQLcatalog;"           
                                ]
-[ "catalog",                     "pattern",      "sql",          
"(type:int,sname:str,t:ptr,temp:int):void ",                                    
                                                        "SQLcatalog;"           
                                ]
-[ "catalog",                     "pattern",      "sql",          
"(type:int,sname:str,name:str,action:int):void ",                               
                                                        "SQLcatalog;"           
                                ]
-[ "dropdictionary",              "pattern",      "sql",          
"(sch:str,tbl:str):void ",                                                      
                                                        "SQLdropDictionary;"    
                                ]
-[ "dense_rank",                          "command",      "sql",          
"(b:bat[:oid,:any_1]):bat[:oid,:int] ",                                         
                                                        "sql_dense_rank;"       
                                ]
-[ "dense_rank_grp",              "command",      "sql",          
"(b:bat[:oid,:any_1],gp:bat[:oid,:oid],gpe:bat[:oid,:oid]):bat[:oid,:int] ",    
                                                        "sql_dense_rank_grp;"   
                                ]
-[ "dec_round",                   "command",      "sql",          
"(v:dbl,r:dbl):dbl ",                                                           
                                                        "dbl_dec_round_wrap;"   
                                ]
-[ "dec_round",                   "command",      "sql",          
"(v:flt,r:flt):flt ",                                                           
                                                        "flt_dec_round_wrap;"   
                                ]
-[ "dec_round",                   "command",      "sql",          
"(v:lng,r:lng):lng ",                                                           
                                                        "lng_dec_round_wrap;"   
                                ]
-[ "dec_round",                   "command",      "sql",          
"(v:int,r:int):int ",                                                           
                                                        "int_dec_round_wrap;"   
                                ]
-[ "dec_round",                   "command",      "sql",          
"(v:sht,r:sht):sht ",                                                           
                                                        "sht_dec_round_wrap;"   
                                ]
-[ "dec_round",                   "command",      "sql",          
"(v:bte,r:bte):bte ",                                                           
                                                        "bte_dec_round_wrap;"   
                                ]
-[ "dump_slave",                          "pattern",      "sql",          
"():bat[:str,:BAT] ",                                                           
                                                        "dump_slave;"           
                                ]
-[ "dump_trace",                          "pattern",      "sql",          
"():bat[:str,:BAT] ",                                                           
                                                        "dump_trace;"           
                                ]
-[ "dump_opt_stats",              "pattern",      "sql",          
"():bat[:str,:BAT] ",                                                           
                                                        "dump_opt_stats;"       
                                ]
-[ "dump_cache",                          "pattern",      "sql",          
"():bat[:str,:BAT] ",                                                           
                                                        "dump_cache;"           
                                ]
-[ "db_users",                    "pattern",      "sql",          
"():bat[:str,:BAT] ",                                                           
                                                        "db_users_wrap;"        
                                ]
-[ "dropDeclaredTables",                  "pattern",      "sql",          
"(nr:int):void ",                                                               
                                                        
"mvc_drop_declared_tables_wrap;"                        ]
-[ "dropDeclaredTable",           "pattern",      "sql",          
"(name:str):void ",                                                             
                                                        
"mvc_drop_declared_table_wrap;"                         ]
-[ "dtColumn",                    "pattern",      "sql",          
"(rs:int,tname:str,name:str,typename:str,digits:int,scale:int):void ",          
                                                        
"mvc_declared_table_column_wrap;"                       ]
-[ "declaredTable",               "pattern",      "sql",          
"(name:str):int ",                                                              
                                                        
"mvc_declared_table_wrap;"                              ]
-[ "delete",                      "pattern",      "sql",          
"(mvc:ptr,sname:str,tname:str,b:any):ptr ",                                     
                                                        "mvc_delete_wrap;"      
                                ]
-[ "epilogue",                    "command",      "sql",          "():void ",   
                                                                                
                                          "SQLepilogue;"                        
                  ]
-[ "exportValue",                 "pattern",      "sql",          
"(qtype:int,tname:str,name:str,typename:str,digits:int,scale:int,eclass:int,val:any_1,w:str):void
 ",                                    "mvc_export_value_wrap;"                 
               ]
-[ "exportOperation",             "pattern",      "sql",          "(w:str):void 
",                                                                              
                                          "mvc_export_operation_wrap;"          
                  ]
-[ "exportChunk",                 "pattern",      "sql",          
"(s:streams,res_id:int,offset:int,nr:int):void ",                               
                                                        
"mvc_export_chunk_wrap;"                                ]
-[ "exportChunk",                 "pattern",      "sql",          
"(s:streams,res_id:int):void ",                                                 
                                                        
"mvc_export_chunk_wrap;"                                ]
-[ "exportResult",                "pattern",      "sql",          
"(s:streams,res_id:int):void ",                                                 
                                                        
"mvc_export_result_wrap;"                               ]
-[ "exportHead",                          "pattern",      "sql",          
"(s:streams,res_id:int):void ",                                                 
                                                        "mvc_export_head_wrap;" 
                                ]
-[ "eval",                        "pattern",      "sql",          
"(cmd:str,output:bit):void ",                                                   
                                                        "SQLstatement;"         
                                ]
-[ "eval",                        "pattern",      "sql",          
"(cmd:str):void ",                                                              
                                                        "SQLstatement;"         
                                ]
-[ "fitsView",                    "pattern",      "sql",          
"(fname:str):void ",                                                            
                                                        "fits_view;"            
                                ]
 [ "forgetPrevious",                      "pattern",      "sql",          
"():void ",                                                                     
                                                        "OPTforgetPrevious;"    
                                ]
-[ "gzexpand",                    "pattern",      "sql",          
"(sch:str,tbl:str):void ",                                                      
                                                        "SQLexpand;"            
                                ]
-[ "gztruncate",                          "pattern",      "sql",          
"(sch:str,tbl:str):void ",                                                      
                                                        "SQLtruncate;"          
                                ]
-[ "gzdecompress",                "pattern",      "sql",          
"(sch:str,tbl:str):void ",                                                      
                                                        "SQLgzdecompress;"      
                                ]
-[ "gzcompress",                          "pattern",      "sql",          
"(sch:str,tbl:str):void ",                                                      
                                                        "SQLgzcompress;"        
                                ]
-[ "getVersion",                          "command",      "sql",          
"(clientid:int):lng ",                                                          
                                                        "mvc_getVersion;"       
                                ]
-[ "get_value",                   "pattern",      "sql",          
"(sname:str,sequence:str):lng ",                                                
                                                        "mvc_get_value;"        
                                ]
-[ "getVariable",                 "pattern",      "sql",          
"(varname:str):any_1 ",                                                         
                                                        "getVariable;"          
                                ]
-[ "importTable",                 "pattern",      "sql",          
"(sname:str,tname:str,fname:str...):bat[:str,:BAT] ",                           
                                                        
"mvc_bin_import_table_wrap;"                            ]
-[ "importTable",                 "pattern",      "sql",          
"(s:bstream,sname:str,tname:str,sep:str,rsep:str,ssep:str,ns:str,nr:lng,offset:lng):bat[:str,:BAT]
 ",                                   "mvc_import_table_wrap;"                  
              ]
-[ "include",                     "pattern",      "sql",          
"(fname:str):void ",                                                            
                                                        "SQLinclude;"           
                                ]
-[ "init",                        "pattern",      "sql",          "():void ",   
                                                                                
                                          "SQLinitEnvironment;"                 
                  ]
 [ "keepquery",                           "function",     "sql",          
"(qid:int,qry:str,parse:lng,optimize:lng):void;",                               
                                                        "nil"                   
                                ]
-[ "logfile",                     "pattern",      "sql",          
"(filename:str):void ",                                                         
                                                        "mvc_logfile;"          
                                ]
-[ "mvc",                         "pattern",      "sql",          "():ptr ",    
                                                                                
                                          "SQLmvc;"                             
                  ]
-[ "newdictionary",               "pattern",      "sql",          
"(sch:str,tbl:str):void ",                                                      
                                                        "SQLnewDictionary;"     
                                ]
-[ "not_uniques",                 "command",      "sql",          
"(b:bat[:oid,:wrd]):bat[:oid,:oid] ",                                           
                                                        "not_unique_oids;"      
                                ]
-[ "not_uniques",                 "command",      "sql",          
"(b:bat[:oid,:oid]):bat[:oid,:oid] ",                                           
                                                        "not_unique_oids;"      
                                ]
-[ "not_unique",                          "command",      "sql",          
"(b:bat[:oid,:oid]):bit ",                                                      
                                                        "not_unique;"           
                                ]
-[ "next_value",                          "pattern",      "sql",          
"(sname:str,sequence:str):lng ",                                                
                                                        "mvc_next_value;"       
                                ]
-[ "prelude",                     "command",      "sql",          "():void ",   
                                                                                
                                          "SQLprelude;"                         
                  ]
-[ "password",                    "pattern",      "sql",          
"(user:str):str ",                                                              
                                                        "db_password_wrap;"     
                                ]
 [ "queryId",                             "function",     "sql",          
"(qid:int):void;",                                                              
                                                        "nil"                   
                                ]
-[ "rdfshred",                    "pattern",      "sql",          
"(location:str,gname:str,schema:str):void ",                                    
                                                        "SQLrdfShred;"          
                                ]
-[ "reuse",                       "pattern",      "sql",          
"(sch:str,tbl:str):void ",                                                      
                                                        "SQLreuse;"             
                                ]
-[ "rank",                        "command",      "sql",          
"(b:bat[:oid,:any_1]):bat[:oid,:int] ",                                         
                                                        "sql_rank;"             
                                ]
-[ "rank_grp",                    "command",      "sql",          
"(b:bat[:oid,:any_1],gp:bat[:oid,:oid],gpe:bat[:oid,:oid]):bat[:oid,:int] ",    
                                                        "sql_rank_grp;"         
                                ]
-[ "round",                       "command",      "sql",          
"(v:dbl,r:bte):dbl ",                                                           
                                                        "dbl_round_wrap;"       
                                ]
-[ "round",                       "command",      "sql",          
"(v:flt,r:bte):flt ",                                                           
                                                        "flt_round_wrap;"       
                                ]
-[ "round",                       "command",      "sql",          
"(v:lng,d:int,s:int,r:bte):lng ",                                               
                                                        "lng_round_wrap;"       
                                ]
-[ "round",                       "command",      "sql",          
"(v:int,d:int,s:int,r:bte):int ",                                               
                                                        "int_round_wrap;"       
                                ]
-[ "round",                       "command",      "sql",          
"(v:sht,d:int,s:int,r:bte):sht ",                                               
                                                        "sht_round_wrap;"       
                                ]
-[ "round",                       "command",      "sql",          
"(v:bte,d:int,s:int,r:bte):bte ",                                               
                                                        "bte_round_wrap;"       
                                ]
-[ "rsColumn",                    "pattern",      "sql",          
"(rs:int,tname:str,name:str,typename:str,digits:int,scale:int,col:bat[:oid,:any_1]):void
 ",                                             "mvc_result_column_wrap;"       
                        ]
-[ "rsColumn",                    "pattern",      "sql",          
"(rs:int,tname:str,name:str,typename:str,digits:int,scale:int,val:any_1):void 
",                                                        
"mvc_result_value_wrap;"                                ]
-[ "resultSet",                   "pattern",      "sql",          
"(nr_cols:int,qtype:int,order:bat[:oid,:any_1]):int ",                          
                                                        
"mvc_result_table_wrap;"                                ]
-[ "resultSet",                   "pattern",      "sql",          
"(nr_cols:int,qtype:int,order:any_1):int ",                                     
                                                        "mvc_result_row_wrap;"  
                                ]
-[ "resultSet",                   "pattern",      "sql",          
"(nr_cols:int,sep:str,rsep:str,ssep:str,ns:str,order:bat[:oid,:any_1]):int ",   
                                                        "mvc_result_file_wrap;" 
                                ]
-[ "resultSet",                   "pattern",      "sql",          
"(nr_cols:int,sep:str,rsep:str,ssep:str,ns:str,order:any_1):int ",              
                                                        "mvc_result_file_wrap;" 
                                ]
-[ "restart",                     "pattern",      "sql",          
"(sname:str,sequence:str,start:lng):lng ",                                      
                                                        "mvc_restart_seq;"      
                                ]
-[ "shrink",                      "pattern",      "sql",          
"(sch:str,tbl:str):void ",                                                      
                                                        "SQLshrink;"            
                                ]
-[ "sql_variables",               "pattern",      "sql",          
"():bat[:str,:BAT] ",                                                           
                                                        "sql_variables;"        
                                ]
-[ "sql_environment",             "function",     "sql",          
"():bat[:str,:BAT];",                                                           
                                                        "nil"                   
                                ]
-[ "single",                      "function",     "sql",          
"(x:any_2):bat[:oid,:any_2];",                                                  
                                                        "nil"                   
                                ]
-[ "setVariable",                 "pattern",      "sql",          
"(varname:str,value:any_1):void ",                                              
                                                        "setVariable;"          
                                ]
-[ "start2",                      "pattern",      "sql",          "():void ",   
                                                                                
                                          "SQLsession2;"                        
                  ]
-[ "start",                       "pattern",      "sql",          "():void ",   
                                                                                
                                          "SQLsession;"                         
                  ]
-[ "times",                       "factory",      "sql",          "():void;",   
                                                                                
                                          "nil"                                 
                  ]
-[ "times",                       "function",     "sql",          
"(elaps:int,inblock:lng,oublock:lng):void;",                                    
                                                        "nil"                   
                                ]
-[ "trans",                       "pattern",      "sql",          
"(type:int,chain:int,name:str):void ",                                          
                                                        "SQLtransaction;"       
                                ]
-[ "update",                      "pattern",      "sql",          
"(mvc:ptr,sname:str,tname:str,cname:str,ins:any):ptr ",                         
                                                        "mvc_update_wrap;"      
                                ]
-[ "vacuum",                      "pattern",      "sql",          
"(sch:str,tbl:str):void ",                                                      
                                                        "SQLvacuum;"            
                                ]
-[ "zero_or_one",                 "function",     "sql",          
"(b:bat[:oid,:any_1],gp:bat[:oid,:oid],gpe:bat[:oid,:oid]):bat[:oid,:any_1];",  
                                                        "nil"                   
                                ]
-[ "zero_or_one",                 "command",      "sql",          
"(col:bat[:any_2,:any_1]):any_1 ",                                              
                                                        "zero_or_one;"          
                                ]
-[ "bind_idxbat",                 "function",     "octopus",      
"(conn:str,sch:str,tab:str,index:str,access:int,low:oid,hgh:oid,version:int):bat[:oid,:oid];",
                                          "nil"                                 
                  ]
-[ "bind_idxbat",                 "function",     "octopus",      
"(conn:str,sch:str,tab:str,index:str,access:int,version:int):bat[:oid,:oid];",  
                                                        "nil"                   
                                ]
-[ "bind_idxbat",                 "function",     "octopus",      
"(mvc:ptr,sch:str,tab:str,index:str,access:int,version:int):bat[:oid,:oid];",   
                                                        "nil"                   
                                ]
-[ "bind_dbat",                   "function",     "octopus",      
"(conn:str,sch:str,tab:str,access:int,version:int):bat[:oid,:oid];",            
                                                        "nil"                   
                                ]
-[ "bind_dbat",                   "function",     "octopus",      
"(mvc:ptr,sch:str,tab:str,access:int,version:int):bat[:oid,:oid];",             
                                                        "nil"                   
                                ]
-[ "bind",                        "function",     "octopus",      
"(conn:str,sch:str,tab:str,col:str,kind:int,version:int):bat[:oid,:any_1];",    
                                                        "nil"                   
                                ]
-[ "bind",                        "function",     "octopus",      
"(conn:str,sch:str,tab:str,col:str,kind:int,low:oid,hgh:oid,version:int):bat[:oid,:any_1];",
                                            "nil"                               
                    ]
-[ "bind",                        "function",     "octopus",      
"(mvc:ptr,sch:str,tab:str,col:str,kind:int,version:int):bat[:oid,:any_1];",     
                                                        "nil"                   
                                ]
-[ "bind",                        "function",     "octopus",      
"(mvc:ptr,sch:str,tab:str,col:str,kind:int,low:oid,hgh:oid,version:int):bat[:oid,:any_1];",
                                             "nil"                              
                     ]
 [ "connect",                     "command",      "octopus",      
"(dbname:str):str ",                                                            
                                                        "OCTOPUSconnect;"       
                                ]
-[ "getBid",                      "function",     "octopus",      
"(dbname:str,fn:str,bidtype:sht):lng;",                                         
                                                        "nil"                   
                                ]
-[ "getVariable",                 "function",     "octopus",      
"(conn:str,name:str):any_1;",                                                   
                                                        "nil"                   
                                ]
 [ "legAdvice",                           "pattern",      "octopus",      
"(mod:str,fcn:str):int ",                                                       
                                                "OPTlegAdvice;"                 
                        ]
 [ "register",                    "pattern",      "octopus",      
"(dbname:str,fname:str...):void ",                                              
                                                        "OCTOPUSregister;"      
                                ]
 [ "addReg",                      "pattern",      "datacyclotron", 
"(sch:str,tab:str,col:str,acc:int,part:int,f_bun:int,l_bun:int):int ",          
                                                       "addRegWrap;"            
                               ]
@@ -1295,15 +1104,9 @@
 [ "toString",                    "pattern",      "statistics",   
"(name:any_1):str ",                                                            
                                                        "STATtoString;"         
                                ]
 [ "take",                        "pattern",      "statistics",   
"(name:any_1):any_2 ",                                                          
                                                        "STATtake;"             
                                ]
 [ "update",                      "command",      "statistics",   "():void ",   
                                                                                
                                          "STATupdate;"                         
                  ]
-[ "project",                             "pattern",      "mat",          
"(map:bat[:void,:bte],b:bat[:any_1,:any_2]...):bat[:void,:any_2] ",             
                                        "MATproject;"                           
        ]
-[ "project",                             "pattern",      "mat",          
"(map:bat[:void,:bte],b:bat[:any_1,:any_2]...):bat[:any_1,:any_2] ",            
                                        "MATproject;"                           
        ]
 [ "activate",                            "pattern",      "profiler",     
"(name:str...):void ",                                                          
                                                "CMDactivateProfiler;"          
                        ]
 [ "cleanup",                     "command",      "profiler",     "():void ",   
                                                                                
                                          "CMDcleanup;"                         
                  ]
 [ "clrFilter",                   "pattern",      "profiler",     "(v:any):void 
",                                                                              
                                          "CMDsetFilterVariable;"               
                  ]
-[ "refine_rev",                                  "pattern",      "mat",        
  "(sorted:bat[:void,:any_2],map:bat[:void,:bte],b:bat[:any_1,:any_3]...) 
(rsorted:bat[:void,:oid],rmap:bat[:void,:bte]) ", "MATrefineReverse;"           
                ]
-[ "refine",                              "pattern",      "mat",          
"(sorted:bat[:void,:any_2],map:bat[:void,:bte],b:bat[:any_1,:any_3]...) 
(rsorted:bat[:void,:oid],rmap:bat[:void,:bte]) ", "MATrefine;"                  
                        ]
-[ "sortReverseTail",                     "pattern",      "mat",          
"(b:bat[:any_1,:any_2]...) (sorted:bat[:void,:any_2],map:bat[:void,:bte]) ",    
                                        "MATsortReverseTail;"                   
        ]
-[ "sortTail",                            "pattern",      "mat",          
"(b:bat[:any_1,:any_2]...) (sorted:bat[:void,:any_2],map:bat[:void,:bte]) ",    
                                        "MATsortTail;"                          
        ]
 [ "clrFilter",                   "pattern",      "profiler",     
"(mod:str,fcn:str):void ",                                                      
                                                        "CMDclrFilterProfiler;" 
                                ]
 [ "closeStream",                 "command",      "profiler",     "():void ",   
                                                                                
                                          "CMDcloseProfilerStream;"             
                  ]
 [ "dumpTrace",                   "command",      "profiler",     "():void ",   
                                                                                
                                          "CMDdumpTrace;"                       
                  ]
@@ -1383,7 +1186,6 @@
 [ "stop",                        "command",      "mapi",         "():void ",   
                                                                                
                                          "SERVERstop;"                         
                  ]
 [ "trace",                       "command",      "mapi",         
"(mid:int,flag:int):void ",                                                     
                                                        "SERVERtrace;"          
                                ]
 [ "emptySet",                    "command",      "constraints",  
"(b:bat[:oid,:any_2]):void ",                                                   
                                                        "CemptySet;"            
                                ]
-[ "parts",                       "pattern",      "constraints",  
"(sname:str,tname:str,cname:str,access:int,nrparts:int):void ",                 
                                                        "Cparts;"               
                                ]
 [ "assertSpace",                         "pattern",      "language",     
"(depth:int):void ",                                                            
                                "safeguardStack;"                               
]
 [ "assert",                      "pattern",      "language",     
"(v:any_1,pname:str,oper:str,val:any_2):void ",                                 
                                                        "MALassertTriple;"      
                                ]
 [ "assert",                      "command",      "language",     
"(v:oid,term:str):void ",                                                       
                                                        "MALassertOid;"         
                                ]
@@ -1509,20 +1311,20 @@
 [ "take",                        "command",      "bpm",          
"(pb:str):bat[:any_1,:any_2] ",                                                 
                                                        "BPMtake;"              
                                ]
 [ "take",                        "command",      "bpm",          
"(pb:int):bat[:any_1,:any_2] ",                                                 
                                                        "BPMtakeIndexed;"       
                                ]
 [ "unfold",                      "command",      "bpm",          
"(alias:bat[:any_1,:any_2]):bat[:any_1,:any_2] ",                               
                                                        "BPMunfold;"            
                                ]
-[ "bind_idxbat",                 "pattern",      "mat",          
"(sname:str,tname:str,iname:str,access:int,part:int):bat[:oid,:any_1] ",        
                                                        "mat_bind_idxbat_wrap;" 
                                ]
-[ "bind",                        "pattern",      "mat",          
"(sname:str,tname:str,cname:str,access:int,part:int):bat[:oid,:any_1] ",        
                                                        "mat_bind_wrap;"        
                                ]
-[ "get_part",                    "pattern",      "mat",          
"(sname:str,tname:str,column:str,part:int):bat[:oid,:any_1] ",                  
                                                        "get_part_wrap;"        
                                ]
 [ "hasMoreElements",             "pattern",      "mat",          
"(grp:bat[:any_1,:any_2]...):bat[:any_1,:any_2] ",                              
                                                        "MAThasMoreElements;"   
                                ]
-[ "inc_parts",                   "pattern",      "mat",          
"(sname:str,tname:str):void ",                                                  
                                                        "inc_parts_wrap;"       
                                ]
 [ "info",                        "command",      "mat",          
"(g:str,e:str):bat[:any_1,:any_2] ",                                            
                                                        "MATinfo;"              
                                ]
 [ "newIterator",                 "pattern",      "mat",          
"(grp:bat[:any_1,:any_2]...):bat[:any_1,:any_2] ",                              
                                                        "MATnewIterator;"       
                                ]
 [ "new",                                 "pattern",      "mat",          
"(b:bat[:any_1,:any_2]...):bat[:any_1,:any_2] ",                                
                                        "MATpack;"                              
                ]
-[ "print_part",                          "pattern",      "mat",          
"(sname:str,tname:str,column:str,part:int):void ",                              
                                                        "print_part_wrap;"      
                                ]
 [ "print",                       "pattern",      "mat",          
"(b:bat[:any_1,:any_2]...):void ",                                              
                                                        "MATprint;"             
                                ]
+[ "project",                             "pattern",      "mat",                
  "(map:bat[:void,:bte],b:bat[:any_1,:any_2]...):bat[:void,:any_2] ",           
                                                                  "MATproject;" 
                                          ]
+[ "project",                             "pattern",      "mat",                
  "(map:bat[:void,:bte],b:bat[:any_1,:any_2]...):bat[:any_1,:any_2] ",          
                                                                  "MATproject;" 
                                          ]
 [ "pack2",                       "pattern",      "mat",                  
"(b:bat[:any_1,:any_2]...):bat[:any_1,:any_2] ",                                
                                                "MATpack2;"                     
                ]
 [ "pack",                        "pattern",      "mat",          
"(b:bat[:any_1,:any_2]...):bat[:any_1,:any_2] ",                                
                                                        "MATpack;"              
                                ]
 [ "pack",                                "pattern",      "mat",          
"(_1:any_2...):bat[:void,:any_2] ",                                             
                                        "MATpackValues;"                        
                ]
-[ "send_part",                   "pattern",      "mat",          
"(host:str,sname:str,tname:str,column:str,part:int):void ",                     
                                                        "send_part_wrap;"       
                                ]
+[ "refine_rev",                                  "pattern",      "mat",        
          
"(sorted:bat[:void,:any_2],map:bat[:void,:bte],b:bat[:any_1,:any_3]...) 
(rsorted:bat[:void,:oid],rmap:bat[:void,:bte]) ",                       
"MATrefineReverse;"                                     ]
+[ "refine",                              "pattern",      "mat",                
  "(sorted:bat[:void,:any_2],map:bat[:void,:bte],b:bat[:any_1,:any_3]...) 
(rsorted:bat[:void,:oid],rmap:bat[:void,:bte]) ",                       
"MATrefine;"                                            ]
+[ "sortReverseTail",                     "pattern",      "mat",                
  "(b:bat[:any_1,:any_2]...) (sorted:bat[:void,:any_2],map:bat[:void,:bte]) ",  
                                                                  
"MATsortReverseTail;"                                   ]
+[ "sortTail",                            "pattern",      "mat",                
  "(b:bat[:any_1,:any_2]...) (sorted:bat[:void,:any_2],map:bat[:void,:bte]) ",  
                                                                  
"MATsortTail;"                                          ]
 [ "slice",                               "pattern",      "mat",          
"(first:lng,last:lng,b:bat[:any_1,:any_2]...):bat[:any_1,:any_2] ",             
                                                                "MATpackSlice;" 
                                ]
 [ "slice",                               "pattern",      "mat",          
"(first:int,last:int,b:bat[:any_1,:any_2]...):bat[:any_1,:any_2] ",             
                                                                "MATpackSlice;" 
                                ]
 [ "slice",                               "pattern",      "mat",          
"(first:wrd,last:wrd,b:bat[:any_1,:any_2]...):bat[:any_1,:any_2] ",             
                                                                "MATpackSlice;" 
                                ]
@@ -3509,33 +3311,6 @@
 [ "and",                                 "command",      "batcalc",      
"(b:bat[:oid,:oid],c:bat[:oid,:oid]):bat[:oid,:oid] ",                          
                                                "CMDbatAND_oid_oid_oid;"        
                        ]
 [ "and",                                 "command",      "batcalc",      
"(cst:oid,b:bat[:oid,:oid]):bat[:oid,:oid] ",                                   
                                                "CMDcstANDbat_oid_oid_oid;"     
                        ]
 [ "and",                                 "command",      "batcalc",      
"(b:bat[:oid,:oid],cst:oid):bat[:oid,:oid] ",                                   
                                                "CMDbatANDcst_oid_oid_oid;"     
                        ]
-[ "bte",                         "command",      "batcalc",      
"(s1:int,v:bat[:oid,:lng],d2:int,s2:int):bat[:oid,:bte] ",                      
                                                        "batlng_dec2dec_bte;"   
                                ]
-[ "bte",                         "command",      "batcalc",      
"(s1:int,v:bat[:oid,:lng]):bat[:oid,:bte] ",                                    
                                                        "batlng_dec2_bte;"      
                                ]
-[ "bte",                         "command",      "batcalc",      
"(v:bat[:oid,:lng],digits:int,scale:int):bat[:oid,:bte] ",                      
                                                        "batlng_num2dec_bte;"   
                                ]
-[ "bte",                         "command",      "batcalc",      
"(v:bat[:oid,:lng]):bat[:oid,:bte] ",                                           
                                                        "batlng_2_bte;"         
                                ]
-[ "bte",                         "command",      "batcalc",      
"(s1:int,v:bat[:oid,:wrd],d2:int,s2:int):bat[:oid,:bte] ",                      
                                                        "batwrd_dec2dec_bte;"   
                                ]
-[ "bte",                         "command",      "batcalc",      
"(s1:int,v:bat[:oid,:wrd]):bat[:oid,:bte] ",                                    
                                                        "batwrd_dec2_bte;"      
                                ]
-[ "bte",                         "command",      "batcalc",      
"(v:bat[:oid,:wrd],digits:int,scale:int):bat[:oid,:bte] ",                      
                                                        "batwrd_num2dec_bte;"   
                                ]
-[ "bte",                         "command",      "batcalc",      
"(v:bat[:oid,:wrd]):bat[:oid,:bte] ",                                           
                                                        "batwrd_2_bte;"         
                                ]
-[ "bte",                         "command",      "batcalc",      
"(s1:int,v:bat[:oid,:int],d2:int,s2:int):bat[:oid,:bte] ",                      
                                                        "batint_dec2dec_bte;"   
                                ]
-[ "bte",                         "command",      "batcalc",      
"(s1:int,v:bat[:oid,:int]):bat[:oid,:bte] ",                                    
                                                        "batint_dec2_bte;"      
                                ]
-[ "bte",                         "command",      "batcalc",      
"(v:bat[:oid,:int],digits:int,scale:int):bat[:oid,:bte] ",                      
                                                        "batint_num2dec_bte;"   
                                ]
-[ "bte",                         "command",      "batcalc",      
"(v:bat[:oid,:int]):bat[:oid,:bte] ",                                           
                                                        "batint_2_bte;"         
                                ]
-[ "bte",                         "command",      "batcalc",      
"(s1:int,v:bat[:oid,:sht],d2:int,s2:int):bat[:oid,:bte] ",                      
                                                        "batsht_dec2dec_bte;"   
                                ]
-[ "bte",                         "command",      "batcalc",      
"(s1:int,v:bat[:oid,:sht]):bat[:oid,:bte] ",                                    
                                                        "batsht_dec2_bte;"      
                                ]
-[ "bte",                         "command",      "batcalc",      
"(v:bat[:oid,:sht],digits:int,scale:int):bat[:oid,:bte] ",                      
                                                        "batsht_num2dec_bte;"   
                                ]
-[ "bte",                         "command",      "batcalc",      
"(v:bat[:oid,:sht]):bat[:oid,:bte] ",                                           
                                                        "batsht_2_bte;"         
                                ]
-[ "bte",                         "command",      "batcalc",      
"(s1:int,v:bat[:oid,:bte],d2:int,s2:int):bat[:oid,:bte] ",                      
                                                        "batbte_dec2dec_bte;"   
                                ]
-[ "bte",                         "command",      "batcalc",      
"(s1:int,v:bat[:oid,:bte]):bat[:oid,:bte] ",                                    
                                                        "batbte_dec2_bte;"      
                                ]
-[ "bte",                         "command",      "batcalc",      
"(v:bat[:oid,:bte],digits:int,scale:int):bat[:oid,:bte] ",                      
                                                        "batbte_num2dec_bte;"   
                                ]
-[ "bte",                         "command",      "batcalc",      
"(v:bat[:oid,:bte]):bat[:oid,:bte] ",                                           
                                                        "batbte_2_bte;"         
                                ]
-[ "bte",                         "command",      "batcalc",      
"(v:bat[:oid,:dbl],digits:int,scale:int):bat[:oid,:bte] ",                      
                                                        "batdbl_num2dec_bte;"   
                                ]
-[ "bte",                         "command",      "batcalc",      
"(v:bat[:oid,:dbl]):bat[:oid,:bte] ",                                           
                                                        "batdbl_2_bte;"         
                                ]
-[ "bte",                         "command",      "batcalc",      
"(v:bat[:oid,:flt],digits:int,scale:int):bat[:oid,:bte] ",                      
                                                        "batflt_num2dec_bte;"   
                                ]
-[ "bte",                         "command",      "batcalc",      
"(v:bat[:oid,:flt]):bat[:oid,:bte] ",                                           
                                                        "batflt_2_bte;"         
                                ]
-[ "bte",                         "command",      "batcalc",      
"(v:bat[:oid,:str],digits:int,scale:int):bat[:oid,:bte] ",                      
                                                        "batstr_2dec_bte;"      
                                ]
-[ "bte",                         "command",      "batcalc",      
"(v:bat[:oid,:str],digits:int):bat[:oid,:bte] ",                                
                                                        "batstr_2num_bte;"      
                                ]
-[ "bte",                         "command",      "batcalc",      
"(v:bat[:oid,:str]):bat[:oid,:bte] ",                                           
                                                        "batstr_2_bte;"         
                                ]
 [ "bit",                         "command",      "batcalc",      
"(b:bat[:any_1,:str]):bat[:any_1,:bit] ",                                       
                                                        "CMDconvert_str_bit;"   
                                ]
 [ "bit",                         "command",      "batcalc",      
"(b:bat[:any_1,:lng]):bat[:any_1,:bit] ",                                       
                                                        "CMDconvert_lng_bit;"   
                                ]
 [ "bit",                         "command",      "batcalc",      
"(b:bat[:any_1,:wrd]):bat[:any_1,:bit] ",                                       
                                                                
"CMDconvert_wrd_bit;"                           ]
@@ -3553,31 +3328,6 @@
 [ "bte",                         "command",      "batcalc",      
"(b:bat[:any_1,:bte]):bat[:any_1,:bte] ",                                       
                                                        "CMDconvert_bte;"       
                                ]
 [ "bit",                         "command",      "batcalc",      
"(b:bat[:any_1,:bit]):bat[:any_1,:bit] ",                                       
                                                        "CMDconvert_bit;"       
                                ]
_______________________________________________
Checkin-list mailing list
Checkin-list@monetdb.org
http://mail.monetdb.org/mailman/listinfo/checkin-list

Reply via email to