whereis Returns the name of the loaded library/module a given function belongs to

## Syntax

    libmod = whereis(function)

## Arguments

function

  Name (text) or handle of a Scilab "macro" or builtin function.

libmod

  If `function` points to

  - a function written in Scilab language and registered with genlib in some loaded library: `libmod` returns the name of the library.
  - an unregistered user-defined function written in Scilab language: `libmod` returns `"script"`.
  - a builtin function (so-called Scilab primitive): the name of the module the `function` belongs to is returned.
  - Otherwise: `libmod` returns `[]`.

## Description

`whereis` allows to identify the library of Scilab macros or the module a given function belongs to.

When the function is

a "macro" (written in Scilab language and compiled):

  it may be not loaded (not yet called), but its library must be so.

  When the same function name is registered in several loaded libraries of macros, `whereis` returns the name of all of them.

  libraryinfo(..) allows to retrieve the path to definition files of a library.

  - Since Scilab 6.0: When, in the mymacro.sci file defining a public macro mymacro() registered in a library, some additional functions are defined after mymacro(), these additional functions are NOT registered in the library. So, `whereis` ignores them and will return `[]` for them. See the Examples section.
  - When a module like `xcos` has sublibraries, these ones are often loaded in Scilab only after the first call to the main function (like `xcos()`). As a consequence, `whereis(..)` querried for a function of such a sublibrary will return `[]`, until the main function -- like `xcos()` -- is called a first time. See the Examples section.
a user-defined function registered in no library

  but defined

  - directly in the console by `deff(..)` or by `function ... endfunction`, or
  - in a file loaded in the Scilab session with `exec(functionfile.sci)` or with `getd(..)`,

  `whereis` returns `"script"`. When this function is defined in a file, there is no way to retrieve the file path and name.

a builtin written and compiled in an external language (C, C++..):

  `whereis` returns the name of the module the function belongs to.

  The gateway file where the builtin function is declared to belong to the module is located at `SCI/modules/moduleName/gateway/moduleName_gateway.xml`, where `moduleName` must be replaced with the actual module name.

## Examples

    // Case of an unregistered macro:
    function myTest(), disp("Unregistered function"), endfunction
    whereis myTest                  // => "script"

    // Case of a registered macro:
    r = whereis("ls")               // => "fileiolib"
    [?,path]= libraryinfo(r); path  // => "SCI\modules\fileio\macros\"

    // Let's define another ls() in another library:
    path = TMPDIR+"/myls";
    mkdir(path);
    mputl("function ls(), disp(""my other ls() in lslib""), endfunction", path+"/ls.sci");
    genlib("lslib", path);
    whereis ls                      // => ["fileiolib"; "lslib"]

    // Case of a builtin function
    whereis sin                     // => "elementary_functions"
    whereis conv2                   // => "signal_processing"

    // Case of an unregistered macro defined/loaded after a registered one:
    clear ls lslib
    whereis ls                      // "fileiolib" : OK
    function ls(),  disp("my local ls()"), endfunction
    ls                              // => "my local ls()"
    whereis ls                      // => ["script"; fileiolib"]
    clear ls                        // (cleaning up)
    whereis ls                      // "fileiolib" : OK

    // Dependencies are ignored:
    // chfact() has some private dependency functions blkfc1(), inpnv(), etc:
    edit chfact
    // chfact() is registered:
    whereis chfact                  // => "sparselib"
    // .. but not its dependencies:
    whereis blkfc1                  // => []

    // Sublibraries may be loaded only after the first call to a main driving function:
    // CLR() is a public function related to the CLR Xcos block belonging to the
    //  Linear palette and declared in the Linearlib library.
    // But this sublibrary is loaded only after a first call to xcos():
    whereis xcos         // => "xcos"
    whereis CLR          // => [], if you never called xcos() in the session yet.
    xcos()               // => loads all its sublibraries. Please ignore the interfaces.
                         //    You may even close them.
    whereis CLR          // => "Linearlib" non-empty answer, now

## See also

- genlib
- libraryinfo
- lib
- getmodules

## History

6.0

- `whereis` now supports builtin functions.
- When the same function name is registered in several libraries, `whereis` now returns all of them instead of only the last loaded one.
- For unregistered user-defined macros, `whereis` now returns `"script"` instead of `[]`.

2023.0.0

- `whereis("function")` now returns several libraries names.