A tool to access a file in the vim editor by creating a shortcut from file-name and directory-name …

‍The basic problem in a project with a lot of files and a lot of directories is to find a way to navigate quickly and easily.

Two tools are used for this:

Nhi1Tags, A tool to generate the .tags file to navigaet in source-code and documentation …
Nhi1Shortcut, A tool to access a file in the vim editor by creating a shortcut from file-name and directory-name …

using: Nhi1Shortcut

Files involved :

.../.shortcut                       local shortcut database for directory "..."
.../.shortcutignore                 ignore file/pattern for directory "..."
etc/shortcut.local                  shortcut extension (example: test "db" lookup)
sbin/vim-shortcut.tcl               shortcut integration into "vim"
theCompiler/src/lng_Shortcut.tcl    frontend of the shortcut tool
theCompiler/src/lib_Shortcut.tcl    backend of the shortcut tool

The tool Nhi1Shortcut tool creates a file called .shortcut with a simple TCL array using: mapping : array set dirA { shortcut → filename ... }

The navigation is done using the vim extension vim-shortcut.tcl :: " open file based on return from 'vim-key-2-file.tcl'

" optional … popup_notification on ERROR or WARNING

" cd DIR | e FILE

func! SC_exec(init)

execute system("$NHI1_HOME/sbin/vim-shortcut.tcl " ..

\ shellescape(expand('%')) .. ' ' ..

\ shellescape(a:init)

\ )

endfunc

" CTRL+e

nnoremap ␅ :call SC_exec(inputdialog("SC>")) <CR>

" call it from commandline (:E ...) and extern (vim -c ':E ...')

command! -nargs=1 E call SC_exec('<args>')

Calling a shortcut is done with :E ... or <CTRL-E>...

The shortcut itself is a mix of upper and lower case letters :

upper = directory-shortcut
lower = file-shortcut

The directory has some predefined token :

starting with :

      switch $curK {
        T { DIR $env(NHI1_HOME)     ; # top     }
        U { DIR [file dirname $DIR] ; # up      }
        C { continue                ; # current }
      }

second with :

array set topA [list            \
  K $env(theKernel_SRCDIR)      \
  L $env(theLink_SRCDIR)        \
  O $env(theConfig_SRCDIR)      \
  Q $env(theSq3Lite_SRCDIR)     \
  B $env(theBrain_SRCDIR)       \
  G $env(theGuard_SRCDIR)       \
  C $env(theCompiler_SRCDIR)    \
  D $env(docs_SRCDIR)           \
  E $env(example_SRCDIR)        \
]

following with :

array set lngA {
  A {"" main  }
  C {"" c     }
  D {"" docs  }
  G {"" go    "" gen}
  H {"" php   }
  J {"" jv    }
  M {"" man   }
  P {"" public "" pl    }
  R {"" rb    }
  S {"" cs    }
  T {E tests "" tcl}
  U {"" ..    }
  V {"" vb    }
  X {"" cc    }
  Y {"" py    }
}

if multiple items per char are available the first match is used.
directory can be skipped if current position is searched.
reference is always the current (open) file directory.
an absolute position always start with T
an relative position start with "", C, U or lngA follewd by file-shortcut

The filename part is read from the file .shortcut in the directory :

Example file docs/main/.shortcut :

 
array set dirA {
  id        index.doc
  pd        pages.doc
  ld        Nhi1Label.doc
  sd        Nhi1Shortcut.doc
  ed        Nhi1Exec.doc
  td        Nhi1Tags.doc
  rd        Ruby.doc
}
 
# BEGIN-mark - created by 'lng_Shortcut.tcl ' - DO NOT change
 
# $NHI1_HOME/docs/main
array set dirA {
  d         Doxyfile.main
  mc        main.config
  md        main.doc
  s         .shortcut
  v         .vimrc
}
 
# END-mark - created by 'lng_Shortcut.tcl ' - DO NOT change
 
# vim: syntax=tcl

the first array dirA is written be the user
the second array dirA is written be the Nhi1Shortcut tool

The usage of the Nhi1Shortcut tool :

␛[1;36mpInit                                    -> PINIT[#0] -> +++ use              : lang<lng>       : api<Shortcut>        : top<lng_Shortcut.tcl>␛[0;m
␛[1;36m                                         -> PINIT[#0] -> argv<-h>␛[0;m
usage: Nhi1Shortcut ?options...? 
  options:
    ^-(?:i|meta)(?:=(.*))?$   |  set META file for inpout   :  default: value from -|mk|mq|lc|sq3|...
    ^-(mk|mq|lc|sq3)$         |  set LIBRARY                :  
  
  filter options
    ^-(?:f|func)(?:=(.*))?$   |  filter FUNCEXPR            :  all kind of objects (-ff/-ffunc = stonger)
    ^-(?:c|class)(?:=(.*))?$  |  filter CLASSEXPR           :  filter by class name
    ^-show-filter$            |  show filter data           :  API_IGNORE_* and API_ALLOW_*
  
  profiling options
    ^-profile$                |  use prfiling               :  
    ^-profile-key$            |  set profile key            :  default: exclusiveRuntime
                                   compileTime, nonCompileTime, avgExclusiveTime, calls
                                   totalRuntime, exclusiveRuntime, avgRuntime
    ^-profile-pat$            |  filter result              :  default: *
  
  TASK options
    ^-ignore(?:=(.*))?$       |  ignore=TASK,TASK,...       :  use -h to get list
    ^-only(?:=(.*))?$         |  only=TASK,TASK,...         :  use -h to get list
  
  debug options
    ^-trace(?:=(.*))?$        |  trace VARIABLE on WRITE    :  discover modification
    ^-force$                  |  use META code              :  disable the cache
    ^-erase-all$              |  erase generated code       :  apply to target file(s)
    ^-warning-as-error$       |  raise an ERROR on WARNING  :  
    ^-(d+)$                   |  incr DEBUG level           :  -d -dd -ddd ...
    ^-(v+)$                   |  incr VERBOSE level         :  -v -vv -vvv ...
    ^-(s+)$                   |  always print to STDOUT     :  BOOLEAN
    ^-(?:w|write)$            |  always write               :  BOOLEAN
    ^-tcl-trace$              |  enable TCL trace           :  
  
  misc options
    ^-(h|help)$               |  get this help              :  
    ^-dependency$             |  write dependency tree      :  used for MAKE
    ^-attribute(?:=(.*))?$$   |  attribute KEY=VAL          :  modify the attributeDEF database

  lng_Shortcut options:

    -do-lib ...... LIB ....... DO the 'project' directory (default: no)
    -do-example .. EXAMPLE ... DO the 'example' directory (default: no)
    -do-docs ..... DOCS ...... DO the 'docs' directory (default: no)
    -do-the ...... THE ....... DO the 'theX' directory (default: no)
    -all ..................... DO all above

    -sc-write ................ DO write file '.shortcutignore'
    -sc-no-deep .............. DON'T use parallel directories also
    -diff .................... DO the 'diff' at the end (default: no)
    -(tcl|py|pl|rb|php|c|cc|cs|jv|go|vb) ... chose language
    -(mk|mq|lc|sq3) ........................ chose namespace


  supported '-ignore' args:

    IGNORE(#usage)<list> , IGNORE(#only)<EMPTY> , IGNORE<array|P|#group,*>
      IGNORE(#usage) = <list>
        | DOCS | EXAMPLE | LIB
      IGNORE = <array|P|#group,*>
        | #group,all-lng | tcl cc cs vb jv rb php pl c go py
        | #group,all-ns  | mk mq lc sq3
        | #group,all-tsk | LIB EXAMPLE DOCS TESTS THE

Simple Example : create the shortcut for a LIB (library) using package mk (theKernel) target language py (python)

> Nhi1Shortcut -only=LIB,mk,py
pInit                                    -> PINIT[#0] -> +++ use              : lang<lng>       : api<Shortcut>        : top<lng_Shortcut.tcl>
                                         -> PINIT[#0] ->                      : argv<-only=LIB,mk,py>
Do                                       -> LIB start
  GLOBAL                                   -> LIB project: mk
  cache_close                              -> write file -> fn<.../NHI1/theKernel/py/.shortcut>
Do                                       -> LIB end