load.txt    Utility used for loading other plugins


CONTENTS                                                     load-contents

    1. Intro                                      load-intro

    2. Functionality provided                     load-functionality

        2.1. Commands                             load-commands

        2.2. Functions                            load-functions

        2.3. `Autocommands'                       load-autocommands

    3. Plugin registration                        load-reg

    4. Sessions                                   load-sessions

    5. Options                                    load-options


1. Intro                                                        load-intro

This plugin provides the ability to autoload other plugins on demand, create 

global functions and commands and share plugin's functionality.


    ∙ Autoloading plugins on FuncUndefined event.

    ∙ Autoloading plugins when their command is called.

    ∙ Autoloading plugins when their mapping is used.

    ∙ Autoloading plugins when their functionality is required.

    ∙ Displaying plugins' status.

    ∙ Unloading and reloading plugins.

    ∙ Searching for a function number through registered plugins.

This plugin requires chk plugin.


2. Functionality provided                               load-functionality

This plugin provides one command and one function. Both command and function 

names start with Load, but this prefix can be altered by _fprefix and _cprefix 

options in g:loadOptions dictionary (Note that it is a very bad idea).


2.1. Commands                                                load-commands


:LoadCommand {action} ...                     load-:Command :LoadCommand

            The only command provided by this plugin. If variable 

            g:loadOptions exists and has key _cprefix, then prefix Load is 


:LoadCommand unload {plugin}                            load-action-unload

            Unload plugin named {plugin} and all plugins that depend on it.

            Unloading is done in the following order:

            0. If plugin is not already loaded it is first loaded and only 

               then unloaded.

            1. Plugin is unregistered. See load-func-unreg.

            2. load-reg-F.main.destruct function is called. See load-reg-F 

               for details.

            3. load-reg-g and load-reg-F variables are unlocked.

            4. All keys in load-reg-g and load-reg-F are deleted.

            In order to be able to be unloaded correctly your plugin must 

            follow the following rules:

            1. Put all functions into s:F dictionary and use it as 

               load-reg-F. If some function cannot be put into dictionary 

               (for example, because you cannot use script variables in 

               mappings), then this function should be deleted in 

               s:F.main.destruct function.

            2. Put all script variables into s:g dictionary and use it as 

               load-reg-g. Use dictionary where keys are buffer numbers 

               instead of buffer variables. If you still require to modify 

               external variables, then they should be reset in 

               s:F.main.destruct function.

            3. Do other cleanup (like deleting completion function created by 

               comp.vim plugin) inside s:F.main.destruct.

            4. Last three lines of s:F.main.destruct must be >

                    unlet s:g

                    unlet s:F

                    return 1

:LoadCommand reload {plugin}                            load-action-reload

            Reload plugin named {plugin}. Just like load-action-unload, but 

            after unloading load-reg-files are sourced.

:LoadCommand sesreload {plugin}                      load-action-sesreload

            Reload plugin named {plugin}. Just like load-action-reload, but 

            before unloading plugins session information is saved and after 

            loading plugins it is restored.

:LoadCommand show                                         load-action-show

            Show load-reg-scriptidload-reg-nameload-reg-file and 

            status for all plugins. Possible statuses: registered and loaded. 

            See load-reg for details.

:LoadCommand findnr {nr}                                load-action-findnr

            Find a function with number {nr}. Function is searched through

            load-reg-F variables of plugins.

:LoadCommand nrof {fname}                                 load-action-nrof

            Display a number of function {fname}{fname} must have the 

            following structure: /{plugname}/{pathToFunction}.

:LoadCommand function {fname}                         load-action-function

            Display a code of function {fname}, just like builtin :function

            {fname} argument is described in load-action-nrof.

:LoadCommand breakadd {fname}{line}]                load-action-breakadd

            Set a breakpoint at line {line} (default 1) of a function {fname}

            {fname} argument is described in load-action-nrof.

:LoadCommand autocmd {event} {plugin} {command}        load-action-autocmd

            Create an `autocommand', see load-autocommands. For 

            a description of arguments see load-func-autocmdNote that you 

            need to escape a backslash in {command}.

:LoadCommand autocmd! {event}{plugin}{command}]]  load-action-autocmd!

            Delete an `autocommand', see load-autocommands. For 

            a description of arguments see load-func-delautocmdNote that 

            you need to escape a backslash in {command}.

:LoadCommand mksession {filename}                    load-action-mksession

            Creates a session: two files, {filename} and {root}x.vim, where 

            {root} is {filename} with extension removed, see :mkssession for 

            information about filenames and load-sessions about how to 

            implement session support in your plugin. This command always 

            overwrites existing files.


2.2. Functions                                              load-functions

                                   load-func-LoadFuncdict LoadFuncdict()

This plugin provides only one global function: LoadFuncdict (prefix Load may 

be altered, but this is a very bad idea). You can also use load#LoadFuncdict() 

which loads the plugin and then calls LoadFuncdict(). This function returns 

a dictionary with the following keys (each value is a function reference):



            Register plugin. For the meaning of the argument see load-reg

            Returns a dictionary with following keys:

            Key        Value

            name       Name of the plugin, see load-reg-name for information 

                       about how it is constructed.

            type       Type of the plugin, see load-reg-name for information 

                       about how it is obtained.

            functions  Some useful functions:


                       eerror({srcname}{etype}{arg1}, ...)

                            Display the error message with pattern


                            Here {plugtype} stands for plugin type, {plugname} 

                            for plugin name (see the `name' and `type' keys 

                            above), {srcname} is a string provided as the 

                            first argument, {etypestr} is a string obtained 

                            from load-reg-g.etype[{etype}] (or empty string 

                            if it does not exist) and {argN} are handled in 

                            following way:

                            1. If {arg1} (only {arg1}, not {argN}) is 

                               a non-zero number then throw error message 

                               after echoing it.

                            2. If {argN} is a list, its first value is 

                               a string and load-reg-g.emsg[{argN}[0]] 

                               exists, then add 

                               printf(load-reg-g.emsg[{argN}[0]], {argN}[1], 

                               {argN}[2], ...) to {msgs}.

                            3. In other cases add {argN} to {msgs}.

                            String {msgs} is a list of strings separated by

                            ": ".



                            Try getting option named {optname} first from 

                            b:{optionPrefix}Options, then from 

                            g:{optionPrefix}Options and finally from 

                            load-reg-g.defaultOptions. Throw an exception on 

                            failure. If exists 

                            load-reg-g.c.options[{optname}], then use it to 

                            check obtained option by function 

                            chk-func-checkargument. Throw an exception if 

                            check failed. Note that all option names starting 

                            with underscore are reserved.


                        bufdict([{Constructor}[, {Destructor}]])

                            Setup buffers dictionary: it is a dictionary where 

                            keys are buffer numbers, use it if you want to 

                            hide buffer-local variables from user. When a new 

                            buffer is created, {Constructor} is called. If it 

                            returns something different from 0, returned value 

                            is assigned to the {bufdict}[{bufnr}], where 

                            {bufdict} is created buffers dictionary. If it 

                            returns 0 or {Constructor} itself is not 

                            a function reference, then no new keys are created 

                            in buffers dictionary. {Destructor} (if it is 

                            a function reference) is called when buffer which 

                            number is a key of a buffers dictionary gets 

                            deleted, just before value is removed from it. 

                            Both {Constructor} and {Destructor} are called 

                            with buffer number and a buffers dictionary as 

                            their arguments.




                            Create a new autocommand, see :au{event} may 

                            be a List of events, {AuG-suffix} is an 

                            autocommand group suffix (with length limited to 

                            sixteen characters, may be empty), other arguments 

                            are self-explanatory after you read :au. Returns 

                            name of autocmd group (which is currently 

                            "LoadPlugin_{plugname}{N}[_{AuG-suffix}]") or 0 if 

                            creation fails. No errors are echoed or thrown. If 

                            {command} is a function reference, then this 

                            function will be called with <amatch><abuf> (as 

                            a number) and <afile> in arguments.

unregister({plugname}[, {plugtype}])                  load-func-unregister

        Unregister plugin. For {plugname} and {plugtype} arguments see 

        load-reg-name. `Unregister' means:

        1. delete all global functions;

        2. delete all commands;

        3. remove plugin dictionary.


getfunctions({plugname}[, {plugtype}[, {from}]])

        Get the dictionary functions listed in load-reg-dictfunctions 

        argument provided when plugin {plugname} was registered. If {from} 

        argument is given and it is equal to string `functions', then it will 

        return functions listed in load-reg-functions instead of 

        load-reg-getfunctions, which can be useful if you expect user to 

        override default prefix. For {plugname} and {plugtype} arguments see 



lazygetfunctions({plugname}[, {plugtype}[, {from}]])

        Get the dictionary which will be populated with plugin's dictionary 

        functions when this plugin will be loaded. Can be used to resolve 

        cyclic dependencies. See load-func-run for information about how to 

        run functions from this dictionary. See load-func-getfunctions about 

        the meaning of {from} argument.

run({dict}{funcname}[, {arg1}[, ...]])                     load-func-run

        Run function {funcname} from dictionary {dict} with arguments 

        {arg1}..{argN} (N may be 0). If {dict} was obtained by 

        load-func-lazygetfunctions and was not modified then first load the 

        plugin and then run the function. Trows an exception, if function is 

        not found in dictionary.

autocmd({event}{plugin}{command})                    load-func-autocmd

        Register an autocommand. For a description of {event} see 

        load-autocommands{plugin} is any string of a form 

        {plugtype}/{plugname}{command} is either a string which will be 

        executed (see :execute) or a function reference which will be called 

        with two arguments: {event} and {plugin}.

delautocmd({event}[, {plugin}[, {command}]])          load-func-delautocmd

        Delete `autocommand(s)': if only {event} is given, then all 

        `autocommands' attached to this event are cleared. If {plugin} is 

        given, then it deletes all `autocommands' associated with the given 

        event and given plugin (if any). If both {plugin} and {command} 

        arguments are given, then it filters out all autocommands that match 

        all of {event}{plugin} and {command}.

restoresession({filename})                        load-func-restoresession

        Restore additional session information stored by 

        load-action-mksessionNote that you should not call this function 

        by yourself, it should be used from session file only.

There are also some convenience functions in autoload/load.vim file:

load#LoadFuncdict([{plugname}[, {plugtype}]])          load#LoadFuncdict()

        Calls LoadFuncdict(), loads the plugin if it is not defined. If the 

        optional {plugname} argument is provided, then it calls 


load#Setoption({dictname}{key}{value}[, {extend}])    load#Setoption()

        Sets the value of {key} in dictionary with name {dictname} to {value} 

        if it is possible. If {extend} is given and is 1, then try to extend 

        existing option instead of overwriting it. Some notes:

        1. If variable {dictname} does not exist it will be created.

        2. If variable {dictname} does not contain a dictionary, it will be 

           reset to an empty dictionary without notice.

        3. If {key} is locked, it will be unlocked without notice and will not 

           be locked again.

        4. If {extend} is given, but {key} cannot be extended with {value}

           then it will be overwritten without notice.

        5. If setting an option failed, then function will return 0, otherwise 

           it will return a dictionary. No error will be echoed anyway.

load#CreateDictFunction({arguments}{body})     load#CreateDictFunction()

        Creates a dictionary function with given arguments and body. The 

        advantage of creating a dictionary function using this function is 

        that created function will be unable to get access to script 

        variables. For example, to create an eval() function that does not 

        have access to script variables you should do the following call: >

            let s:F.safeeval=load#CreateDictFunction("s", "return eval(a:s)")

<                                                             load#Setup()

load#Setup({apiversion}[, {oprefix}[, {cprefix}[, {fprefix}[, {oneload}]]]])

        Does some common plugin setup actions:

        1. Creates s:Fs:F.plug and s:F.main dictionaries, populates 

           s:F.plug.load with load plugin functions.

        2. Creates s:g and s:g._load dictionaries, sets s:g._pluginloaded to 

           {oneload} (or 0), populates _load dictionary with the following 


           Key         Description

           funcdict    See load-reg-funcdict

           globdict    See load-reg-globdict

           sid         See load-reg-sid

           scriptfile  See load-reg-scriptfile

           apiversion  {apiversion}, see load-reg-apiversion

           oprefix     If {oprefix} is defined and is a string, then 

                       {oprefix}, otherwise root (%:r) of the filename with 

                       invalid characters removed. See load-reg-oprefix.

           cprefix     If {cprefix} is defined and is a string, then 

                       {cprefix}. If {cprefix} is 1 then `oprefix' with first 

                       letter capitalized, if it is not defined or is 0 then 

                       `cprefix' is not defined at all.

                       See load-reg-cprefix.

           fprefix     Just like `cprefix', but using {fprefix} value.

                       See load-reg-fprefix.

           oneload     {oneload} or 0. See load-reg-oneload.

        Example usage: >

            if (exists("s:g._pluginloaded") && s:g._pluginloaded) ||



            elseif !exists("s:g._pluginloaded")

                execute load#Setup('0.1', 1, 0, 1)

                let s:g._load.functions=[["bar", "baz.bar", {}]]

                let s:g.reginfo=s:F.plug.load.register(s:g._load)



2.3. `Autocommands'                                      load-autocommands

This plugin provides a way to run custom hooks on the following events:

RegisterPluginPre                                load-au-RegisterPluginPre

        Before plugin registration. Note that there is no way to catch this 

        event for a load plugin as it must be loaded before you are able to 

        define any autocommand.

RegisterPluginPost                              load-au-RegisterPluginPost

        After plugin registration. Note that there is no way to catch this 

        event for a load plugin as it must be loaded before you are able to 

        define any autocommand.

LoadPluginPre                                        load-au-LoadPluginPre

        After plugin registration, before plugin is sourced second time.

        Some note's:

        1. There is no way to catch this event for a load plugin as it must be 

           loaded before you are able to define any autocommand.

        2. If plugin is sourced only once (if it defines load-reg-oneload 

           key) then this event occures just after 


LoadPluginPost                                      load-au-LoadPluginPost

        After plugin is sourced second time.

        Some note's:

        1. There is no way to catch this event for a load plugin as it must be 

           loaded before you are able to define any autocommand.

        2. If plugin is sourced only once (if it defines load-reg-oneload 

           key) then this event never occures.

UnloadPluginPre                                    load-au-UnloadPluginPre

        Just before unloading the plugin.

UnloadPluginPost                                  load-au-UnloadPluginPost

        Just after unloading the plugin.


3. Plugin registration                                            load-reg

Registration is done via calling load-func-register function with a single 

dictionary as an argument. The following keys are required: oprefix, funcdict, 

globdict, sid, scriptfile, apiversion. Possible keys:


dictfunctions :: [({dictname}{internalname}[, {check}[, {with}]])]

        List of lists with the following items:

        {dictname}     any string, which will be the function name in the

                       dictionary returned by load-func-getfunctions.

        {internalname} string, which consist of alphanumeric characters,

                       underscores and dots, where dot does neither start nor 

                       end the string. Dictionary function with name 

                       load-reg-F.{internalname} must exist. Value returned 

                       by this function will be returned by {dictname} 

                       dictionary function.

        {check}        Argument check for a function or an empty dictionary if

                       no check is required. See chk-func-checkarguments for 

                       more details.

        {with}         List of lists with two or three items: it is either 

                       ({varname}{value}), or ({saver}{setter}

                       {restorer}). In the first case value of {varname} will 

                       be stored into local variable, then {value} will be 

                       assigned to {varname} and, after the function was run, 

                       restored value will be assigned to {varname} (note that 

                       variable {varname} must exist, but may be actually an 

                       option). In the second case {saver} and {setter} are 

                       run before the function and {restorer} will be run 

                       after it. All of {saver}{setter} and {restorer} must 

                       be strings; in this strings `%.' will be replaced with 

                       internal variable name. So, lists >

                            ["&magic", 1]

<                      and >

                            ["let %.=&magic", "let &magic=1", "let &magic=%."]

<                      are equivalent.

fprefix :: String                                         load-reg-fprefix

        String which starts either with g: or with uppercase latin letter and 

        contains any number of latin letters, digits and underscores. It is 

        the default function prefix for plugin being registered. You must not 

        use this key unless `functions' key is present.

cprefix :: String                                         load-reg-cprefix

        String which starts with uppercase latin letter and contains any 

        number of latin letters, digits and underscores. It is the default 

        command prefix for plugin being registered. You must not use this key 

        unless `commands' key is present.

oprefix :: String                                         load-reg-oprefix

        String, which contains any number of latin letters, digits and 

        underscores. It is used to construct option dictionary name 

        (g:{oprefix}Options), which is used to get custom command (from 

        g:{oprefix}Options._cpferix) and function (from 

        g:{oprefix}Options._fprefix) prefixes, and also to get options by an 

        option function (see load-func-registerplugin).


funcdict :: Dictionary                                   load-reg-funcdict

        Dictionary with plugin functions. The load plugin assumes that all 

        functions are declared as dictionary functions inside this 



globdict :: Dictionary                                   load-reg-globdict

        Dictionary with global script variables. The load plugin assumes that 

        this dictionary is the only s: variable declared in the plugin.

commands :: Dictionary                                   load-reg-commands

        Dictionary {{CmdTail}{Arguments}}, where arguments is a dictionary 

        with the following keys:

        Key       Value

        func      string, which consist of alphanumeric characters,

                  underscores and dots, where dot does neither start nor end 

                  the string. Dictionary function with name 

                  load-reg-F.{internalname} must exist. This function is 

                  called when the command {cprefix}{CmdTail} is run. Arguments 

                  of the function (depending on other keys, some of them may 

                  not be present):

                  '<bang>', '<reg>', <LINE1><LINE2><count><f-args>.

        nargs     `+', `?', `*', `0', natural number or an empty string.

                  See :command-nargs. Adds <f-args> to the function 


        range     `%', non-negative number or an empty string.

                  See :command-range. Adds <LINE1> and <LINE2> to function 


        count     Non-negative number or an empty string.

                  See :command-count. Adds <count> to function arguments.

        bang      Emty string. See :command-bang.

                  Adds '<bang>' to function arguments.

        bar       Emty string. See :command-bar.

        reg       Emty string. See :command-register.

                  Adds '<reg>' to function arguments.

        complete  Non-empty string. See :command-complete for possible

                  values. Note that for custom completion function it must be 

                  equal either to custom=s:{FunctionName} or 

                  customlist=s:{FunctionName}. In both cases 

                  load-reg-F.comp.{FunctionName} function must exist because 

                  it will be silently (see :silent) called instead of 


        This key is used to construct plugin's commands. Note that existing 

        commands will not be redefined. Key `cprefix' must also be present.


functions :: [({functiontail}{internalname}[, {check}[, {with}]])]

        List of lists with the following items:

        {functiontail} string, which consist of any number of latin letters,

                       digits and underscores. It is used to construct plugin 

                       global function's name ({fprefix}{functiontail}).

        For the description of other list items, see load-reg-dictfunctions.

        This key is used to construct plugin's global functions. Note that 

        existing functions will not be redefined. Key `fprefix' must also be 


mappings :: {{MapName}{MapOptions}}                    load-reg-mappings

        Dictionary where keys are map names (names that start with underscore 

        are reserved, they also must not start with `+') and values are 

        dictionaries with the following keys:

        Key       Description


        function  String, which consist of alphanumeric characters, 

                  underscores and dots, where dot must not start or end the 

                  string or follow another dot. Required Dictionary function 

                  with name load-reg-F.{function} must exist. Value returned 

                  by this function is used as {rhs} of the mapping, see 

                  :map-<expr>. This function must take four arguments: type 

                  of mapping (one character, see below), mapping name, 

                  sequence of keys which invoked it (mapping string) and 

                  buffer number, if it was mapping local to buffer or -1 if it 

                  was not.


        default   String, defines a default {lhs} of the mapping. May be 

                  overriden by load-opt-_maps.


        type      Char, defines a type of the mapping. Possible types and 

                  corresponding commands:

                  Type        Command

                  " " (space) noremap

                   !          noremap!

                  n, v, x, s, o, i, l, c


                  In order to specify more then one type, just concatenate 

                  characters. For example, to specify one mapping both for 

                  visual and normal mode, use "nv".


        silent    Bool. If true, then <silent> argument is added to the map 



        remap     If this key is present, then *map commands will be used 

                  instead of *noremap commands when defining a mapping. See 

                  noremap and recursive_mapping.


        leader    Bool. If true, then either load-reg-leader or 

                  load-opt-_leader is prepended to the default mapping.


        getc      String, just like in load-map-function. If it is present, 

                  then before mapping function is invoked, vimpluginloader 

                  will use getc function to obtain additional keys like this: 

                  it will call this function with a dictionary and a key 

                  obtained from user as arguments and check for return value:

                  0 either aborts mapping (if no characters were accepted) or 

                    causes it to use previously accepted string (from the 

                    first character to the last charactor for which 2 was 

                    returned, subsequent characters are appended to the result 

                    of load-map-function). Note that vimpluginloader will 

                    use deep copy of a dictionary which was used as an 

                    argument to getc function (see deepcopy()).

                  1 accepts current character and tells vimpluginloader that 

                    more characters are required.

                  2 accepts current character and tells vimpluginloader that 

                    more characters can be accepted (it will take 'timeout' 

                    and 'timeoutlen'  options into account).

                  3 accepts current character and invokes load-map-function 


                  Dictionary is preserved for the current key sequence, so 

                  this function must store its `static' variables there. If 

                  this key is present, then this dictionary will be the fifth 

                  argument to load-map-function. This dictionary is 

                  initialized with the following keys:

                  Key      Description

                  type     Type (load-map-type) of the mapping (first 

                           argument of load-map-function): mode from which 

                           mapping is called. Note that for

                           '<Space>' (normal+visual+operator-pending),

                           'v' (visual+select), '!' (insert+command-line) and

                           'l' (insert+command-line+lang-arg) mappings, it 

                           will always be equal to one value, use mode() for 

                           more precise results. There will be difference if 

                           you define mapping with `type' containing more then 

                           one character.

                  name     Name (key of load-reg-mappings dictionary) of the 

                           mapping (second argument of load-map-function).

                  string   Sequence of keys which was used to invoke the 

                           mapping (third argument of load-map-function).

                  buffer   Buffer number (if the mapping is local to buffer) 

                           or -1 (if mapping is global) (fourth argument of 


                  self     Reference to getc function itself.

                  mottype  For load-map-operator mappings: type of the 

                           motion (fifth argument to load-map-function).

                  Note that in order to work correctly, this option requires 

                  +float and +reltime features. In case they are absent, 

                  plugin works like if 'timeout' was unset.


        nochars   If it is present, then mappings that use getc also accept 

                  zero additional characters.


        operator  If it is present, then load-map-function is considered to 

                  be an operator function, so it will be invoked outside of 

                  textlock and get three additional arguments: type of 

                  motion operated upon (see g@), position of the first 

                  character operated upon (obtained via getpos()), position 

                  of the last character operated upon. For normal mode it uses 

                  getpos("'[") and getpos("']"), for visual mode it uses 

                  getpos("'<") and getpos("'>") because getpos("']") will not 

                  return column that is past the end-of-line (but it matters 

                  whether EOL is included or not).

                  Note: for insert-modeReplace-mode and select-mode it 

                  will use <C-o>g@ (thus temporary changing the mode, see 

                  i_CTRL-O and v_CTRL-O) to invoke an operator function 

                  because using g@ does not make sense in this modes. It will 

                  use g@ for other modes including such modes as 

                  Command-lineEx and others where g@ means something 

                  different from `invoke an operator function'.

leader :: String                                           load-reg-leader

        Defines the mapping leader.

sid :: String                                            load-reg-scriptid

        The script id obtained by s:SID function called in the plugin. See 

        <SID> for more details.


scriptfile :: String                                   load-reg-scriptfile

        The script filename. It is used to autoload plugin and also to get 

        a plugin name. Must end with `.vim'. Here is a way how plugin name is 


        0. Resolve given path to full path (using %:p path modifier).

        1. Get last path component without extension and remove it (see %:t 

           and %:r path modifiers description).

        2. Remove tail path components until last path component will not 

           match one of the following strings: `plugin', `autoload', 

           `ftplugin', `ftdetect', `syntax', `indent', `colors', `keymap' or 

           `compiler' (yes, they all are names of special folders in vim 

           runtime directory). If it is found, this component is remembered as 

           a script type. If it is not, then script type will be `/unknown'.

        3. Join all removed path components (except those with type) with `/'. 

           This will be a plugin name.

oneload :: Bool                                           load-reg-oneload

        Defines whether plugin needs to be autoloaded (defines whether plugin 

        file needs to be sourced twice before plugin is actually ready to 


apiversion :: String                                   load-reg-apiversion

        String, defines the api version. Must consist of a number (unsigned 

        integer) followed by a dot and another unsigned integer. Everything 

        after this is ignored.


requires :: [({PlugName}{APIVersion}[, {PlugType}])]

        List of lists of two or three items. Defines requirements for the 

        plugin. Requirements are considered satisfied if {PlugName} was 

        loaded, its major api version number is equal to the one specified in 

        {APIVersion} and minor api version number greater then or equal to the 

        one specified in {APIVersion}. Minor api version number may be 

        omitted. {APIVersion} has syntax equal to load-reg-apiversion. If 

        {PlugType} is not given it is assumed to be equal to `plugin'.

preload :: [({PlugName}[, {PlugType}])]                  load-reg-preload

        List of lists of one or two items. Defines requirements for the plugin 

        that do not use pluginloader. Requirements are considered satisfied if 

        {PlugType}/{PlugName} was sourced. Note that you must not disable 

        SourcePre events in order to get this work.


4. Sessions                                                 load-sessions

All plugins that use vim plugin loader can easily implement a sessions 

support: all you need is to define load-reg-F.main.session function which 

will take either no or one argument. When session file is created using 

load-action-session, this function will be called with no arguments and its 

result will be stored in {root}x.vim file ({root} is a session file name with 

extension removed). When session is restored, this function will be called 

with the only argument: value stored on previous step.


5. Options                                                   load-options

Plugin registered by load-func-registerplugin automatically gets some 


_cprefix :: String                                      load-opt-_cprefix

_fprefix :: String                                      load-opt-_fprefix

        Global. This options override command and function prefixes provided 

        to load-func-registerplugin. They have the same restrictions as 

        load-reg-cprefix and load-reg-fprefix.

_maps :: {{MapName}: String}                               load-opt-_maps

        This option provides a way to override default values given in 

        load-reg-mappings either locally (local to buffer) or globally. If 

        {MapName} starts with `{-' and contains string `-}', then everything 

        between starting `{-' and first occurence of `-}' is stripped, 

        providing a way to map several strings to one {MapName}. If {MapName} 

        starts with `+' then `+' is stripped and plugin mapping leader is 

        prepended to the string (see load-opt-_leader for details). Note 

        that `{-...-}' is stripped before checking for `+'. Empty string 

        disables mapping.

_leader :: String                                        load-opt-_leader

        Overrides plugin mapping leader provided in load-reg-leader.

_disablemaps :: Bool                                load-opt-_disablemaps

        Global. If true then all plugin mappings are disabled. May be set to 

        1 in load-reg-g.defaultOptions in order to disable mappings by


_disable_option_checks :: Bool            load-opt-_disable_option_checks

        Global. If true then load-f-option will omit checking plugin 

        options. Use load-opt-DisableOptionChecks to disable option checking 

        for all plugins.

This plugin also has its own options:

DisableLoadChecks :: Bool                      load-opt-DisableLoadChecks

        Disables checking of load-func-registerplugin argument, speeding up 

        loading of plugins that use it. On by default, should be turned off by 

        plugin developers.

DisableOptionChecks :: Bool                  load-opt-DisableOptionChecks

        If this option is true, then load-f-option will not check plugin 

        options by default. This option may be overriden by 


vim: ft=help:tw=78