diff options
Diffstat (limited to 'uvim/runtime/plugin/logiPat.vim')
| -rw-r--r-- | uvim/runtime/plugin/logiPat.vim | 340 |
1 files changed, 0 insertions, 340 deletions
diff --git a/uvim/runtime/plugin/logiPat.vim b/uvim/runtime/plugin/logiPat.vim deleted file mode 100644 index a8c154e207..0000000000 --- a/uvim/runtime/plugin/logiPat.vim +++ /dev/null @@ -1,340 +0,0 @@ -" LogiPat: Boolean logical pattern matcher -" Maintainer: This runtime file is looking for a new maintainer. -" Original Author: Charles E. Campbell -" Date: Apr 04, 2016 -" Version: 4 -" Purpose: to do Boolean-logic based regular expression pattern matching -" Copyright: Copyright (C) 1999-2011 Charles E. Campbell {{{1 -" Permission is hereby granted to use and distribute this code, -" with or without modifications, provided that this copyright -" notice is copied with it. Like most anything else that's free, -" LogiPat.vim is provided *as is* and comes with no warranty -" of any kind, either expressed or implied. By using this -" plugin, you agree that in no event will the copyright -" holder be liable for any damages resulting from the use -" of this software. -" -" Usage: {{{1 -" :LogiPat ... -" -" Boolean logic supported: -" () grouping operators -" ! not the following pattern -" | logical or -" & logical and -" "..pattern.." -" Example: {{{1 -" :LogiPat !("january"|"february") -" would match all strings not containing the strings january -" or february -" GetLatestVimScripts: 1290 1 :AutoInstall: LogiPat.vim -" -" Behold, you will conceive in your womb, and bring forth a son, {{{1 -" and will call his name Jesus. He will be great, and will be -" called the Son of the Most High. The Lord God will give him the -" throne of his father, David, and he will reign over the house of -" Jacob forever. There will be no end to his kingdom. (Luke 1:31-33 WEB) - -" --------------------------------------------------------------------- -" Load Once: {{{1 -if &cp || exists("loaded_logiPat") - finish -endif -let g:loaded_logiPat = "v4" -let s:keepcpo = &cpo -set cpo&vim -"DechoRemOn - -" --------------------------------------------------------------------- -" Public Interface: {{{1 -com! -nargs=* LogiPat call LogiPat(<q-args>,1) -sil! com -nargs=* LP call LogiPat(<q-args>,1) -sil! com -nargs=* LPR call LogiPat(<q-args>,1,"r") -com! -nargs=+ LPE echomsg LogiPat(<q-args>) -com! -nargs=+ LogiPatFlags let s:LogiPatFlags="<args>" -sil! com -nargs=+ LPF let s:LogiPatFlags="<args>" - -" ===================================================================== -" Functions: {{{1 - -" --------------------------------------------------------------------- -" LogiPat: this function interprets the boolean-logic pattern {{{2 -fun! LogiPat(pat,...) -" call Dfunc("LogiPat(pat<".a:pat.">)") - - " LogiPat(pat,dosearch) - if a:0 > 0 - let dosearch= a:1 - else - let dosearch= 0 - endif - if a:0 >= 3 - let s:LogiPatFlags= a:3 - endif - - let s:npatstack = 0 - let s:nopstack = 0 - let s:preclvl = 0 - let expr = a:pat - - " Lexer/Parser - while expr != "" -" call Decho("expr<".expr.">") - - if expr =~ '^"' - " push a Pattern; accept "" as a single " in the pattern - let expr = substitute(expr,'^\s*"','','') - let pat = substitute(expr,'^\(\%([^"]\|\"\"\)\{-}\)"\([^"].*$\|$\)','\1','') - let pat = substitute(pat,'""','"','g') - let expr = substitute(expr,'^\(\%([^"]\|\"\"\)\{-}\)"\([^"].*$\|$\)','\2','') - let expr = substitute(expr,'^\s*','','') -" call Decho("pat<".pat."> expr<".expr.">") - - call s:LP_PatPush('.*'.pat.'.*') - - elseif expr =~ '^[!()|&]' - " push an operator - let op = strpart(expr,0,1) - let expr = strpart(expr,strlen(op)) - " allow for those who can't resist doubling their and/or operators - if op =~ '[|&]' && expr[0] == op - let expr = strpart(expr,strlen(op)) - endif - call s:LP_OpPush(op) - - elseif expr =~ '^\s' - " skip whitespace - let expr= strpart(expr,1) - - else - echoerr "operator<".strpart(expr,0,1)."> not supported (yet)" - let expr= strpart(expr,1) - endif - - endwhile - - " Final Execution - call s:LP_OpPush('Z') - - let result= s:LP_PatPop(1) -" call Decho("result=".result) - - " sanity checks and cleanup - if s:npatstack > 0 - echoerr s:npatstack." patterns left on stack!" - let s:npatstack= 0 - endif - if s:nopstack > 0 - echoerr s:nopstack." operators left on stack!" - let s:nopstack= 0 - endif - - " perform the indicated search - if dosearch - if exists("s:LogiPatFlags") && s:LogiPatFlags != "" -" call Decho("search(result<".result."> LogiPatFlags<".s:LogiPatFlags.">)") - call search(result,s:LogiPatFlags) - else -" call Decho("search(result<".result.">)") - call search(result) - endif - let @/= result - endif - -" call Dret("LogiPat ".result) - return result -endfun - -" --------------------------------------------------------------------- -" s:String: Vim6.4 doesn't have string() {{{2 -func! s:String(str) - return "'".escape(a:str, '"')."'" -endfunc - -" --------------------------------------------------------------------- -" LP_PatPush: {{{2 -fun! s:LP_PatPush(pat) -" call Dfunc("LP_PatPush(pat<".a:pat.">)") - let s:npatstack = s:npatstack + 1 - let s:patstack_{s:npatstack} = a:pat -" call s:StackLook("patpush") "Decho -" call Dret("LP_PatPush : npatstack=".s:npatstack) -endfun - -" --------------------------------------------------------------------- -" LP_PatPop: pop a number/variable from LogiPat's pattern stack {{{2 -fun! s:LP_PatPop(lookup) -" call Dfunc("LP_PatPop(lookup=".a:lookup.")") - if s:npatstack > 0 - let ret = s:patstack_{s:npatstack} - let s:npatstack = s:npatstack - 1 - else - let ret= "---error---" - echoerr "(LogiPat) invalid expression" - endif -" call s:StackLook("patpop") "Decho -" call Dret("LP_PatPop ".ret) - return ret -endfun - -" --------------------------------------------------------------------- -" LP_OpPush: {{{2 -fun! s:LP_OpPush(op) -" call Dfunc("LP_OpPush(op<".a:op.">)") - - " determine new operator's precedence level - if a:op == '(' - let s:preclvl= s:preclvl + 10 - let preclvl = s:preclvl - elseif a:op == ')' - let s:preclvl= s:preclvl - 10 - if s:preclvl < 0 - let s:preclvl= 0 - echoerr "too many )s" - endif - let preclvl= s:preclvl - elseif a:op =~ '|' - let preclvl= s:preclvl + 2 - elseif a:op =~ '&' - let preclvl= s:preclvl + 4 - elseif a:op == '!' - let preclvl= s:preclvl + 6 - elseif a:op == 'Z' - let preclvl= -1 - else - echoerr "expr<".expr."> not supported (yet)" - let preclvl= s:preclvl - endif -" call Decho("new operator<".a:op."> preclvl=".preclvl) - - " execute higher-precdence operators -" call Decho("execute higher-precedence operators") - call s:LP_Execute(preclvl) - - " push new operator onto operator-stack -" call Decho("push new operator<".a:op."> onto stack with preclvl=".preclvl." at nopstack=".(s:nopstack+1)) - if a:op =~ '!' - let s:nopstack = s:nopstack + 1 - let s:opprec_{s:nopstack} = preclvl - let s:opstack_{s:nopstack} = a:op - elseif a:op =~ '|' - let s:nopstack = s:nopstack + 1 - let s:opprec_{s:nopstack} = preclvl - let s:opstack_{s:nopstack} = a:op - elseif a:op == '&' - let s:nopstack = s:nopstack + 1 - let s:opprec_{s:nopstack} = preclvl - let s:opstack_{s:nopstack} = a:op - endif - -" call s:StackLook("oppush") "Decho -" call Dret("LP_OpPush : s:preclvl=".s:preclvl) -endfun - -" --------------------------------------------------------------------- -" LP_Execute: execute operators from opstack using pattern stack {{{2 -fun! s:LP_Execute(preclvl) -" call Dfunc("LP_Execute(preclvl=".a:preclvl.") npatstack=".s:npatstack." nopstack=".s:nopstack) - - " execute all higher precedence operators - while s:nopstack > 0 && a:preclvl < s:opprec_{s:nopstack} - let op= s:opstack_{s:nopstack} -" call Decho("op<".op."> nop=".s:nopstack." [preclvl=".a:preclvl."] < [opprec_".s:nopstack."=".s:opprec_{s:nopstack}."]") - - let s:nopstack = s:nopstack - 1 - - if op == '!' - let n1= s:LP_PatPop(1) - call s:LP_PatPush(s:LP_Not(n1)) - - elseif op == '|' - let n1= s:LP_PatPop(1) - let n2= s:LP_PatPop(1) - call s:LP_PatPush(s:LP_Or(n2,n1)) - - elseif op =~ '&' - let n1= s:LP_PatPop(1) - let n2= s:LP_PatPop(1) - call s:LP_PatPush(s:LP_And(n2,n1)) - endif - -" call s:StackLook("execute") "Decho - endwhile - -" call Dret("LP_Execute") -endfun - -" --------------------------------------------------------------------- -" LP_Not: writes a logical-not for a pattern {{{2 -fun! s:LP_Not(pat) -" call Dfunc("LP_Not(pat<".a:pat.">)") - if a:pat =~ '^\.\*' && a:pat =~ '\.\*$' - let pat= substitute(a:pat,'^\.\*\(.*\)\.\*$','\1','') - let ret= '^\%(\%('.pat.'\)\@!.\)*$' - else - let ret= '^\%(\%('.a:pat.'\)\@!.\)*$' - endif -" call Dret("LP_Not ".ret) - return ret -endfun - -" --------------------------------------------------------------------- -" LP_Or: writes a logical-or branch using two patterns {{{2 -fun! s:LP_Or(pat1,pat2) -" call Dfunc("LP_Or(pat1<".a:pat1."> pat2<".a:pat2.">)") - let ret= '\%('.a:pat1.'\|'.a:pat2.'\)' -" call Dret("LP_Or ".ret) - return ret -endfun - -" --------------------------------------------------------------------- -" LP_And: writes a logical-and concat using two patterns {{{2 -fun! s:LP_And(pat1,pat2) -" call Dfunc("LP_And(pat1<".a:pat1."> pat2<".a:pat2.">)") - let ret= '\%('.a:pat1.'\&'.a:pat2.'\)' -" call Dret("LP_And ".ret) - return ret -endfun - -" --------------------------------------------------------------------- -" StackLook: {{{2 -fun! s:StackLook(description) -" call Dfunc("StackLook(description<".a:description.">)") - let iop = 1 - let ifp = 1 -" call Decho("Pattern Operator") - - " print both pattern and operator - while ifp <= s:npatstack && iop <= s:nopstack - let fp = s:patstack_{ifp} - let op = s:opstack_{iop}." (P".s:opprec_{s:nopstack}.')' - let fplen= strlen(fp) - if fplen < 30 - let fp= fp.strpart(" ",1,30-fplen) - endif -" call Decho(fp.op) - let ifp = ifp + 1 - let iop = iop + 1 - endwhile - - " print just pattern - while ifp <= s:npatstack - let fp = s:patstack_{ifp} -" call Decho(fp) - let ifp = ifp + 1 - endwhile - - " print just operator - while iop <= s:nopstack - let op = s:opstack_{iop}." (P".s:opprec_{s:nopstack}.')' -" call Decho(" ".op) - let iop = iop + 1 - endwhile -" call Dret("StackLook") -endfun - -" --------------------------------------------------------------------- -" Cleanup And Modeline: {{{1 -let &cpo= s:keepcpo -unlet s:keepcpo -" vim: ts=4 fdm=marker |