{{{  Ctags
   {{{  push-tag
   (deffun push-tag
    (
      enter-command-mode
      ; push the current position here..
      find-or-enter-and-go-tags-buffer
    )
   )
   }}}
   {{{  pop-tag
   (deffun pop-tag
    ( no-operation
    )
   )
   }}}
   {{{  goto-tag-in-window
   (deffun goto-tag-in-window
    (
    )
   )
   }}}
   {{{  print-stack
   (deffun print-stack
    ( no-operation
    )
   )
   }}}
   }}}
   {{{  macros for command, motion, and argument modes
      {{{  macros to repeat searches
      {{{  To get the last item ftpom the history list
      (defmac use-prev-from-hist
       ( previous-line
         newline-and-indent
       )
      )
      }}}
      (deffun repeat-forward
       ( enter-command-from-insert forward-character search-forward use-prev-from-hist))
      (deffun repeat-reverse
       ( enter-command-from-insert backward-character search-reverse use-prev-from-hist))
      }}}
      {{{  macros to fix the semantics of origami yanking
      {{{  vi-put-buffer-above
      (deffun vi-put-buffer-above
       ( enter-command-from-insert
         delete-mode-view
         undo-delete-line
         double-line
         delete-line
         unfold-fold
         add-mode-view
         previous-line
       )
      )
      }}}
      {{{  vi-undo-delete-line
      (deffun vi-put-buffer
       ( next-line
         vi-put-buffer-above
       )
      )
      }}}
      }}}
      {{{  macros for insert mode entry bindings
      (deffun append (enter-command-from-insert forward-character delete-mode-view enter-insert-mode))
      (deffun Append (enter-command-from-insert end-of-line delete-mode-view enter-insert-mode))
      (deffun insert (enter-command-from-insert delete-mode-view enter-insert-mode))
      (deffun Insert (enter-command-from-insert beginning-of-line delete-mode-view enter-insert-mode))
      (deffun open
       (enter-command-from-insert end-of-line
        delete-mode-view
        newline-and-indent ; this needs a hook for eg c-mode ?
        enter-insert-mode
       )
      )
      (deffun Open
       (enter-command-from-insert beginning-of-line
        delete-mode-view
        newline-and-indent ; needs a hook again!
        previous-line
        enter-insert-mode
       )
      )
      }}}
      {{{  macros for searching
      (deffun search-f
        ( enter-command-from-insert
          search-forward
        )
      )
      (deffun search-r
        ( enter-command-from-insert
          search-reverse
        )
      )
      (deffun il-search-f
        ( enter-command-from-insert
          incremental-search-forward
        )
      )
      (deffun il-search-r
        ( enter-command-from-insert
          incremental-search-reverse
        )
      )

      }}}
      {{{  macros for TtFf
      {{{  for Ff
      {{{  right-loop
      (defmac right-loop
      (do(
          if test-end-line
           ( if or(stop-at-eol test-bottom)
              ( return-from-macro
              )
             fi
             next-line
             beginning-of-line
           )
           else
            ( forward-character
            )
           fi
          )while not(test-char tc)
       )
                )
       (deffun find-char-right
        ( enter-command-from-insert
          parameter-mode
          prompt-char-counter tc ("Enter "  "target "  "character )
          right-loop
          comrepmv-mode
       )
      )
      }}}
      {{{  left-loop
      (defmac left-loop
      (do(
          if test-begin-line
           ( if or(stop-at-eol test-top)
              ( return-from-macro
              )
             fi
             previous-line
             end-of-line)
             else
             ( backward-character)
             fi
             )while not(test-char tc)
      )
      )
      (deffun find-char-left
       ( enter-command-from-insert
         parameter-mode
         prompt-char-counter tc ("Enter "  "target "  "character )
           left-loop
           comrepmv-mode
       )
      )
      }}}
      }}}
      {{{  for Tt
      (deffun one-before
       ( enter-command-from-insert
         find-char-right
         backward-character
       )
      )

      (deffun one-after
       ( enter-command-from-insert
        find-char-left
        forward-character
       )
      )
      }}}
      }}}
      {{{  replace
      (deffun replace-chars
       ( enter-command-from-insert
         enter-parameter-mode
         prompt-char-counter tc ("Enter "  "target "  "character )
         delete-character
         insert-ascii tc
         enter-command-mode
         backward-character
       )
      )
      }}}
      {{{  leaving with ZZ
      (deffun real-save-and-exit-origami ; because view mode stops autosaves!
       ( enter-command-from-insert
         delete-mode-view
         save-and-exit-origami
       )
      )
      }}}
      {{{  doing ~
      (deffun proper-toggle-case
       ( enter-command-from-insert
         if test-char-set close-fence
          (
           set matching  store-line
           goto-matching-fence
           show-cursor 5
           set go-line-arg matching-fence-y go-line
           goto matching-fence-x
           set matching 0
          )
         else
          ( delete-mode-view
            case-character-toggle
            add-mode-view
          )
         fi
         forward-character
         if and(test-end-line stop-at-eol) ( backward-character ) fi
       )
      )
      }}}
      {{{  doing %
      (deffun proper-percent
       ( enter-command-from-insert
         if not(test-char-set fence)
          {{{  find fence
          ( do
             ( forward-text-character )
            while not(test-char-set fence)
          )
          }}}
         fi
         goto-matching-fence
       )
      )
      }}}
      {{{  folding macros
          {{{  vi-open-fold
          (deffun vi-open-fold
           ( enter-command-from-insert
             open-fold
           )
          )
          }}}
          {{{  vi-close-fold
          (deffun vi-close-fold
           ( enter-command-from-insert
             close-fold
           )
          )
          }}}
          {{{  vi-enter-fold
          (deffun vi-enter-fold
           ( enter-command-from-insert
                 delete-mode-view
             enter-fold
             add-mode-view
           )
          )
          }}}
          {{{  vi-exit-fold
          (deffun vi-exit-fold
           ( enter-command-from-insert
                 delete-mode-view
             exit-fold
             add-mode-view
           )
          )
          }}}
          {{{  vi-unfold-fold
          (deffun vi-unfold-fold
           ( enter-command-from-insert
                 delete-mode-view
             unfold-fold
             add-mode-view
           )
          )
          }}}
          {{{  vi-auto-header
          (deffun vi-auto-header
           ( enter-command-from-insert
                 delete-mode-view
             auto-header
             add-mode-view
           )
          )
          }}}
          {{{  vi-toggle-file-fold
          (deffun vi-toggle-file-fold
           ( enter-command-from-insert
                 delete-mode-view
             toggle-file-fold
             add-mode-view
           )
          )
          }}}
          {{{  vi-attach-file-to-fold
          (deffun vi-attach-file-to-fold
           ( enter-command-from-insert
                 delete-mode-view
             toggle-attach-file-to-fold
             add-mode-view
           )
          )
          }}}
          ;vi-open-buffer
          ;vi-open-list-buffer
          ;vi-next-buffer
          ;vi-previous-buffer
          ;vi-grow-buffer
          ;vi-shrink-buffer
          ;vi-goto-buffer (term)
          ;vi-used-buffers
          ;vi-count-buffer

      }}}
      {{{  vi-x
      (deffun vi-x
       ( enter-command-from-insert
         delete-mode-view
         do (delete-character set tot -(tot 1)) while >(tot 0)
         set tot 0
         add-mode-view
       )
      )
      }}}
      {{{  vi-X
      (deffun vi-X
       ( enter-command-from-insert
         delete-mode-view
         do (delete-previous-character set tot -(tot 1)) while >(tot 0)
         set tot 0
         add-mode-view
       )
      )
      }}}

      {{{  active mode identifiers
      ;nothing active
      ;c  1  change
      ;d  2  delete
      ;V  3  fold
      ;>  4  shift in
      ;<  5  shift out
      ;y  6  yank
      }}}

      {{{  is-line-command
          (deffun is-line-command
           (
             set diffx -(end-x start-x)
             set diffy -(end-y start-y)
           )
          )

          ; useage
          ;   if and(counter-0 diffx,counter-0 diffy)
          ;    (   :
          ;        :
          ;    )
          ;    etc.

      }}}

      {{{  perform stuff for V command and motion modes
           {{{  do-v-command
           (deffun do-v-command
            (set isactive 3 ; make v active
             ; this is always a line command!
             beginning-of-line
             set-start-mark
             enter-motion-mode
            )
           )
           }}}
           {{{  do-v-motion
           (deffun do-v-motion
            (if pre(set isactive -(isactive 3)) =(isactive 0)
              ( end-of-line
                set-end-mark
                delete-mode-view
                fold-region
                enter-command-mode
              )
            else
              (enter-command-mode
               message-exit ( "[ "Folding! "] )
              )
             fi
             )
           )
           }}}
      }}}
      {{{  perform stuff for d command and motion modes
           {{{  do-d-command
           (deffun do-d-command
            (set isactive 2 ; make d active
             set-start-mark
             enter-motion-mode
            )
           )
           }}}
           {{{  do-d-motion
           (deffun do-d-motion
            (if pre(set isactive -(isactive 2)) =(isactive 0)
              ( ; then delete
                delete-mode-view
                set-end-mark
                fold-region
                delete-line
                is-line-command
                enter-command-mode
              )else
              (enter-command-mode
               message-exit ( "[ "Deleting! "] )
              )
             fi
            )
           )
           }}}
      }}}
      {{{  perform stuff for c command and motion modes
           (deffun do-c-command
            (set isactive 1 ; make c active
             set-start-mark
             enter-motion-mode
            )
           )

           (deffun do-c-motion
            (if pre(set isactive -(isactive 1)) =(isactive 0)
              ( set-end-mark
                fold-region
                delete-line
                enter-insert-mode)
            else
              (enter-command-mode
               message-exit ( "[ "Changing! "] )
              )
             fi
            )
            )
      }}}
      {{{  perform stuff for y command and motion modes
           {{{  do-y-command
           (deffun do-y-command
            (set isactive 6 ; make d active
             set-start-mark
             enter-motion-mode
            )
           )
           }}}
           {{{  do-y-motion
           (deffun do-y-motion
            (if pre(set isactive -(isactive 6)) =(isactive 0)
              ( ; then yank
                set-end-mark
                delete-mode-view
                fold-region
                double-line
                delete-line
                unfold-fold
                enter-command-mode
              )
            else
              (enter-command-mode
               message-exit ( "[ "yanking! "] )
              )
             fi
            )
           )
           }}}
      }}}
      {{{  command or move or repeat mode?

      {{{  crm-V
      (deffun crm-V
       ( enter-command-from-insert
         if =(modec 0)
          ( do-v-command enter-motion-mode)
         else
          ( do-v-motion enter-command-mode)
         fi
       )
      )

      }}}
      {{{  crm-d
      (deffun crm-d
       ( enter-command-from-insert
         if =(modec 0)
          ( do-d-command)
         else
          ( set-end-mark
            is-line-command
            if =(diffy 0) ; then a line command
              {{{  fudge start & finish x
              ;insert check for begin/end conditions when rest works
              (
               if =(diffx 0)
                ( ; dx==dy==0 remove line
                  delete-mode-view
                  delete-line
                  enter-command-mode
                )
               else
                ( ; dy==0 dx!=0 remove part of line
                  do-d-motion
                  previous-line
                  vi-append-to-previous-line
                )
              fi
              )
              else
               ( ; dy!=0 remove several lines
                 {{{  correct start
                 set go-line-arg start-y
                 go-line
                 beginning-of-line
                 set start-x store-pos
                 }}}
                 {{{  correct end
                 ;put cursor at end of last line and save
                 set go-line-arg end-y
                 go-line
                 end-of-line
                 set end-x store-pos
                 }}}
                 do-d-motion
                 enter-command-mode
               )
              }}}
            fi
          )
         fi
       )
      )
      }}}
      {{{  crm-c
      (deffun crm-c
       ( enter-command-from-insert
         if =(modec 0)
          ( do-c-command )
         else
          ( set-end-mark
            is-line-command
            if =(diffy 0); then a line command
              {{{  fudge start & finish x
              ;insert check for begin/end conditions when rest works
              (
               if =(diffx 0)
                ( ; dx==dy==0 remove line
                  delete-mode-view
                  delete-line
                  enter-command-mode
                )
               else
                ( ; dy==0 dx!=0 remove part of line
                  do-c-motion
                  previous-line
                  vi-append-to-previous-line
                )
              fi
              )
              else
               ( ; dy!=0 remove several lines
                 {{{  correct start
                 set go-line-arg start-y
                 go-line
                 beginning-of-line
                 set start-x store-pos
                 }}}
                 {{{  correct end
                 ;put cursor at end of last line and save
                 set go-line-arg end-y
                 go-line
                 end-of-line
                 set end-x store-pos
                 }}}
                 do-d-motion
                 enter-command-mode
               )
              }}}
            fi
          )
          fi
       )
      )
      }}}
      {{{  crm-D
      (deffun crm-D
       ;Always character based delete!
       ( enter-command-from-insert
         if =(modec 0)
          ( do-d-command )
         else
          ( do-d-motion )
         fi
       )
      )
      }}}
      {{{  crm-y
      (deffun crm-y
       ( enter-command-from-insert
         if =(modec 0)
          ( do-y-command)
         else
          ( set-end-mark
            is-line-command
            if =(diffy 0) ; then a line command
              {{{  fudge start & finish x
              ;insert check for begin/end conditions when rest works
              (
               if =(diffx 0)
                ( ; dx==dy==0 remove line
                  delete-mode-view
                  delete-line
                  undo-delete-line
                  enter-command-mode
                )
               else
                ( ; dy==0 dx!=0 remove part of line
                  do-y-motion
                  previous-line
                  vi-append-to-previous-line
                )
              fi
              )
              else
               ( ; dy!=0 remove several lines
                 {{{  correct start
                 set go-line-arg start-y
                 go-line
                 beginning-of-line
                 set start-x store-pos
                 }}}
                 {{{  correct end
                 ;put cursor at end of last line and save
                 set go-line-arg end-y
                 go-line
                 end-of-line
                 set end-x store-pos
                 }}}
                 do-y-motion
                 enter-command-mode
               )
              }}}
            fi
          )
         fi
       )
      )
      }}}
      {{{  crm-Y
      (deffun crm-Y
       ( enter-command-from-insert
         if =(modec 0)
          ( do-y-command )
         else
          ( do-y-motion )
         fi
       )
      )
      }}}
      }}}

      {{{  indent outdent region
      {{{  shift-in-command
      (deffun shift-in-command
       ( set isactive 4 ; make > active
         set-start-mark
         enter-motion-mode
       )
      )
      }}}
      {{{  shift-in-motion
      (deffun shift-in-motion
       ( if =(isactive 4)
          ( set-end-mark
            indent-region( 4 )
            enter-command-mode
          )
        fi
       )
      )
      }}}
      {{{  crm-shift-in
      (deffun crm-shift-in
       ( enter-command-from-insert
         if =(modec 0)
            ( shift-in-command )
         else
            ( shift-in-motion )
         fi
       )
      )
      }}}
      {{{  shift-out-command
      (deffun shift-out-command
       ( set isactive 5; make < active
         set-start-mark
         enter-motion-mode
       )
      )
      }}}
      {{{  shift-out-motion
      (deffun shift-out-motion
       ( if =(isactive 5 )
           ( set-end-mark
             indent-region( -4 )
             enter-command-mode
           )
          fi
       )
      )
      }}}
      {{{  crm-shift-out
      (deffun crm-shift-out
       ( enter-command-from-insert
         if =(modec 0)
          ( shift-out-command )
         else
          ( shift-out-motion)
         fi
       )
      )
      }}}
      }}}
      {{{  set language
      (deffun vi-set-language
       ( enter-command-from-insert
         delete-mode-view
         set-language
       )
      )
      }}}
      {{{  vi +_-
      (deffun vi-underscore
       ( enter-command-from-insert
         previous-line
         beginning-of-line
       )
      )
      (deffun vi-plus
       (enter-command-from-insert
         next-line
         beginning-of-line
       )
      )
      }}}
      {{{  create-line-fold
      (deffun create-line-fold
          ( enter-command-from-insert
            delete-mode-view
            create-fold
            create-fold
            add-mode-view
          )
         )
      }}}
      {{{  vi-set-argument-X family
         {{{  deffun vi-set-argument-0
         (deffun vi-set-argument-0
          ( enter-command-from-insert
               if =(tot 0)
            (goto 0)
           else
           ( set tot *(tot 10))
           fi
          )
         )
         }}}
         {{{  vi-set-argument-1
         (deffun vi-set-argument-1
          (enter-command-from-insert
               if =(tot 0)
             ( set tot 1
             )
            else
            ( set tot +(*(tot 10) 1)
            )
           fi
          )
         )
         }}}
         {{{  vi-set-argument-2
         (deffun vi-set-argument-2
          (enter-command-from-insert
               if =(tot 0)
             ( set tot 2
             )
            else
            ( set tot +(*(tot 10) 2)
            )
           fi
          )
         )
         }}}
         {{{  vi-set-argument-3
         (deffun vi-set-argument-3
          ( enter-command-from-insert
               if =(tot 0)
             ( set tot 3
             )
            else
            ( set tot +(*(tot 10) 3)
            )
           fi
          )
         )
         }}}
         {{{  vi-set-argument-4
         (deffun vi-set-argument-4
          (enter-command-from-insert
            if =(tot 0)
             ( set tot 4
             )
            else
            ( set tot +(*(tot 10) 4)
            )
           fi
          )
         )
         }}}
         {{{  vi-set-argument-5
         (deffun vi-set-argument-5
          (enter-command-from-insert
            if =(tot 0)
             ( set tot 5
             )
            else
            ( set tot +(*(tot 10) 5)
            )
           fi
          )
         )
         }}}
         {{{  vi-set-argument-6
         (deffun vi-set-argument-6
          (enter-command-from-insert
               if =(tot 0)
             ( set tot 6
             )
            else
            ( set tot +(*(tot 10) 6)
            )
           fi
          )
         )
         }}}
         {{{  vi-set-argument-7
         (deffun vi-set-argument-7
          ( enter-command-from-insert
               if =(tot 0)
             ( set tot 7
             )
            else
            ( set tot +(*(tot 10) 7)
            )
           fi
          )
         )
         }}}
         {{{  vi-set-argument-8
         (deffun vi-set-argument-8
          ( enter-command-from-insert
               if =(tot 0)
             ( set tot 8
             )
            else
            ( set tot +(*(tot 10) 8)
            )
           fi
          )
         )
         }}}
         {{{  vi-set-argument-9
         (deffun vi-set-argument-9
          ( enter-command-from-insert
               if =(tot 0)
             ( set tot 9
             )
            else
            ( set tot +(*(tot 10) 9)
            )
           fi
          )
         )
         }}}
         {{{  test tot
         (deffun test-tot
         (enter-command-from-insert
              delete-mode-view
         counter  tot
         add-mode-view
         )
         )
         (deffun test-ascii
          ( enter-command-from-insert
               delete-mode-view insert-ascii 77 add-mode-view)
         )
         }}}

      }}}
      {{{  extended mode control macros
      (deffun add-mode-extended (enter-command-from-insert set extended 1 ))
      (deffun delete-mode-extended (enter-command-from-insert set extended 0 ))
      (deffun vi-add-mode-wrap (enter-command-from-insert set wrap-mode 1 ))
      (deffun vi-delete-mode-wrap (enter-command-from-insert set wrap-mode 0  ))
      (deffun del-line-stop-mode (enter-command-from-insert set stop-at-eol 0))
      (deffun add-line-stop-mode (enter-command-from-insert set stop-at-eol 1))
      (deffun vi-add-mode-autosave (enter-command-from-insert add-mode-autosave))
      (deffun vi-del-mode-autosave (enter-command-from-insert delete-mode-autosave))
      }}}
      {{{  vi-goto-line
      (deffun vi-goto-line
       ( enter-command-from-insert
         if =(tot 0)
          ( end-of-fold )
         else
          ( if <>(fast-gotol 0)
             ( set go-line-arg  tot
               go-line
               set tot 0
             )
             else
             ( goto-line-counter tot
               set tot 0
             )
            fi
          )
         fi
       )
      )
      }}}
      {{{  toggle fast-goto
      (deffun fast-goto (enter-command-from-insert set fast-gotol 0))
      (deffun slow-goto (enter-command-from-insert set fast-gotol 1))
      }}}
      {{{  vi-goto-column
       (deffun vi-goto-column
        ( enter-command-from-insert
          goto tot
          set tot 0 )
        )
      }}}

      {{{  vi-backward-character/forward-character
      (deffun vi-backward-character
       ( enter-command-from-insert 
         do ( backward-character set tot -(tot 1)) while >(tot 0)
         set tot 0
       )
      )
      (deffun vi-forward-character
       ( enter-command-from-insert 
         do (forward-character set tot -(tot 1)) while >(tot 0)
         set tot 0
       )
      )
      }}}
      {{{  vi-start/end-of line
      (deffun vi-beginning-of-line
       ( enter-command-from-insert
         beginning-of-line
       )
      )
      (deffun vi-end-of-line
       ( enter-command-from-insert
         end-of-line
       )
      )
      }}}
      {{{  vi-beginning/end-of-fold
      (deffun vi-beginning-of-fold
       ( enter-command-from-insert
         beginning-of-fold
       )
      )
      (deffun vi-end-of-fold
       ( enter-command-from-insert
         end-of-fold
       )
      )

      }}}
      {{{  vi-start/end-word
      (deffun vi-start-word
       ( enter-command-from-insert
         start-word
       )
      )
      (deffun vi-end-word
       ( enter-command-from-insert
         end-word
       )
      )
      }}}
      {{{  display motion stuff
      (deffun vi-C-B
       ( enter-command-from-insert
         do ( previous-page set tot +(tot -1)) while >(tot 0)
         set tot 0
       )
      )
      (deffun vi-C-F
       ( enter-command-from-insert
         do ( next-page set tot +(tot -1)) while >(tot 0)
         set tot 0
       )
      )
      }}}
      {{{  vi-fill-paragraph
      (deffun vi-fill-paragraph
       ( enter-command-from-insert 
         delete-mode-view
         fill-paragraph
         add-mode-view
       )
      )
      }}}
      {{{  line motion with repeat
      (deffun vi-previous-line
       ( enter-command-from-insert
         do ( previous-line set tot +(tot -1)) while >(tot 0)
         set tot 0
       )
      )
      (deffun vi-next-line
       ( enter-command-from-insert
         do (next-line set tot +(tot -1)) while >(tot 0)
         set tot 0
       )
      )
      }}}
      {{{  redraw display
      (deffun redraw-display-
       ( enter-command-from-insert
         redraw-display
       )
      )
      }}}
      {{{  center-redraw display
      (deffun center-and-redraw-display-
       ( enter-command-from-insert
         center-and-redraw-display
       )
      )
      }}}
      {{{  status line
      (deffun status-line-off-
       ( enter-command-from-insert
         status-line-off
       )
      )
      (deffun status-line-on-
       ( enter-command-from-insert
         status-line-on
       )
      )
      }}}
      {{{  describe-fold
      }}}
      {{{  Marks
         {{{  vi-set-mark
         (deffun vi-set-mark
          ( enter-command-from-insert
            parameter-mode
            prompt-char-counter mc ("Enter "  "Mark "  "letter )
            ; A is 65
            ; Z is 90
            ; a is 97
            ; z is 122
            ; ' is 39
            ; ` is 96
            if and(>=(mc 97),<=(mc 122))
            ( ; then its lower case
              set mc -(mc 97)
            )
            else
            ( if and(>=(mc 65),<=(mc 90))
              ( ; then its lower case
                set mc -(mc 65)
              )
              else
              ( ; its an error
                return-from-macro
              )
              fi
            )
            fi
            set mx(mc) store-pos
            set my(mc) store-line-mark
            exit-parameter-mode
            enter-command-mode
           )
          )
         }}}
         {{{  vi-goto-mark
         (deffun vi-goto-mark
          ( enter-command-from-insert
            parameter-mode
            prompt-char-counter mc ("Enter "  "Mark "  "letter )
            ; A is 65
            ; Z is 90
            ; a is 97
            ; z is 122
            ; ' is 39
            ; ` is 96
            if and(>=(mc 97),<=(mc 122))
            ( ; then its lower case
              set mc -(mc 97)
            )
            else
            ( if and(>=(mc 65),<=(mc 90))
              ( ; then its lower case
                set mc -(mc 65)
              )
              else
              ( ; its an error
                return-from-macro
              )
              fi
            )
            fi
            set mtemp my(mc)
            goto-line-mark mtemp
            exit-parameter-mode
            enter-command-mode
           )
          )
         }}}
         {{{  vi-goto-mark-exact
         (deffun vi-goto-mark-exact
          ( enter-command-from-insert
            parameter-mode
            prompt-char-counter mc ("Enter "  "Mark "  "letter )
            ; A is 65
            ; Z is 90
            ; a is 97
            ; z is 122
            ; ' is 39
            ; ` is 96
            if and(>=(mc 97),<=(mc 122))
            ( ; then its lower case
              set mc -(mc 97)
            )
            else
            ( if and(>=(mc 65),<=(mc 90))
              ( ; then its lower case
                set mc -(mc 65)
              )
              else
              ( ; its an error
                return-from-macro
              )
              fi
            )
            fi
            set mtemp my(mc)
            goto-line-mark mtemp
            set mtemp mx(mc)
            goto-counter mtemp
            exit-parameter-mode
            enter-command-mode
           )
          )
         }}}
      }}}
      {{{  !filter line
      (deffun vi-filter-line
       ( enter-parameter-mode
         delete-mode-view
         filter-line "awk "-f "prg newline-and-indent
         enter-command-mode
       )
      )
      }}}
   }}}
   {{{  insert mode functions
       {{{  brace } showmatch
       (deffun brace-close
        ( "}
          backward-character
          goto-matching-fence
          show-cursor 10
          set go-line-arg matching-fence-y go-line
          goto matching-fence-x
          forward-character
          enter-insert-mode
        )
       )
       }}}
       {{{  close-bracket ) showmatch
       (deffun close-bracket
        ( ")
          backward-character
          goto-matching-fence
          show-cursor 10
          set go-line-arg matching-fence-y go-line
          goto matching-fence-x
          forward-character
          enter-insert-mode
        )
       )
       }}}
       {{{  square-bracket ] showmatch
       (deffun square-bracket-close
        ( "]
          backward-character
          goto-matching-fence
          show-cursor 10
          set go-line-arg matching-fence-y go-line
          goto matching-fence-x
          forward-character
          enter-insert-mode
        )
       )
       }}}
       {{{  tabin
       (deffun tabin
        ( set tabx +(store-pos 4)
          beginning-of-line
          "  "  "  "  ;
          goto tabx
         )
       )
       }}}
       {{{  tabout
       (deffun tabout
        ( set tabx -(store-pos 4)
          beginning-of-line
          ;while whitespace and still crunching
        )
       )
       }}}
       {{{  getxselection
       (deffun vi-get-Xselection
        ( pipe-from-command "xv_get_sel newline-and-indent
        )
       )
       }}}
   }}}
   {{{  mouse
   @if-using not(ATARI)
      @if-using (MOUSY)
         ( mouse-buttons
           go-and-open-mouse
           go-and-close-mouse
           go-mouse-and-center
         )
      @fi
   @fi
   @if-using (ATARI)
      @if-using (MOUSY)
         ( mouse-buttons
           go-and-open-mouse
           go-mouse-and-center
           go-and-close-mouse
           go-and-close-mouse
         )
      @fi
   @fi
   }}}