*pi_logipat.txt*	Logical Patterns			May 01, 2019

Author:  Charles E. Campbell  <NcampObell@SdrPchip.AorgM-NOSPAM>
Copyright: (c) 2004-2016 by Charles E. Campbell	*logiPat-copyright*
           The VIM LICENSE applies to LogiPat.vim and LogiPat.txt
           (see |copyright|) except use "LogiPat" instead of "Vim"
	   No warranty, express or implied.  Use At-Your-Own-Risk.

==============================================================================
1. Contents					*logiPat* *logiPat-contents*

	1. Contents.................: |logiPat-contents|
	2. LogiPat Manual...........: |logiPat-manual|
	3. LogiPat Examples.........: |logiPat-examples|
	4. Caveat...................: |logiPat-caveat|
	5. LogiPat History..........: |logiPat-history|


==============================================================================
2. LogiPat Manual			*logiPat-manual* *logiPat-man*

	*logiPat-arg* *logiPat-input* *logiPat-pattern* *logiPat-operators*
	Boolean logic patterns are composed of

			operators  ! = not
			           | = logical-or
			           & = logical-and
			grouping   ( ... )
			patterns   "pattern"

	*logiPat-cmd*
	:LogiPat {boolean-logic pattern}		*:LogiPat*
		:LogiPat is a command which takes a boolean-logic
		argument (|logiPat-arg|).

	:LP {boolean-logic pattern}			*:LP*
		:LP is a shorthand command version of :LogiPat
		(|logiPat-cmd|).

	:LPE {boolean-logic pattern}			*:LPE*
		No search is done, but the conversion from the
		boolean logic pattern to the regular expression
		is performed and echoed onto the display.

	:LogiPatFlags {search flags}			*LogiPat-flags*
		LogiPat uses the |search()| command.  The flags
		passed to that call to search() may be specified
		by the :LogiPatFlags command.

	:LPF {search flags}				*:LPF*
		:LPF is a shorthand version of :LogiPatFlags.

	:let pat=LogiPat({boolean-logic pattern})	*LogiPat()*
		If one calls LogiPat() directly, no search
		is done, but the transformation from the boolean
		logic pattern into a regular expression pattern
		is performed and returned.

	To get a " inside a pattern, as opposed to having it delimit
	the pattern, double it.


==============================================================================
3. LogiPat Examples					*logiPat-examples*

	LogiPat takes Boolean logic arguments and produces a regular
	expression which implements the choices.  A series of examples
	follows:
>
	:LogiPat "abc"
<		will search for lines containing the string  :abc:
>
	:LogiPat "ab""cd"
<		will search for lines containing the string  :ab"cd:
>
	:LogiPat !"abc"
<		will search for lines which don't contain the string  :abc:
>
	:LogiPat "abc"|"def"
<		will search for lines which contain either the string
		:abc:  or the string  :def:
>
	:LogiPat !("abc"|"def")
<		will search for lines which don't contain either
		of the strings  :abc:  or  :def:
>
	:LogiPat "abc"&"def"
<		will search for lines which contain both of the strings
		:abc:  and  :def:
>
	:let pat= LogiPat('!"abc"')
<		will return the regular expression which will match
		all lines not containing  :abc: .  The double quotes
		are needed to pass normal patterns to LogiPat, and
		differentiate such patterns from boolean logic
		operators.


==============================================================================
4. Caveat						*logiPat-caveat*

	The "not" operator may be fragile; ie. it may not always play well
	with the & (logical-and) and | (logical-or) operators.  Please try out
	your patterns, possibly with :set hls, to insure that what is matching
	is what you want.


==============================================================================
5. LogiPat History					*logiPat-history*

	v4 Jun 22, 2015 * LogiPat has been picked up by Bram M for standard
			  plugin distribution; hence the name change
	v3 Sep 25, 2006 * LP_Or() fixed; it now encapsulates its output
	                  in \%(...\) parentheses
	   Dec 12, 2011 * |:LPE| added
			* "" is mapped to a single " and left inside patterns
	v2 May 31, 2005	* LPF and LogiPatFlags commands weren't working
	v1 May 23, 2005	* initial release


==============================================================================
vim:tw=78:ts=8:noet:ft=help
