Thank you for your donation and support DerekZiemba,
In most cases I'm not sure if what I'm using:
Things have changed quite a bit from the original preprocessor implementation.
Perhaps I need to reword a few things.
Here is the order in which Everything parses your search:
Preprocessor always looks like:
#[function:...#]:
-or-
#function:
These are expanded before anything else.
This was the only method available in the first preprocessor implementation.
With the first preprocessor implementation, #[quote:...#]: was designed to convert text to a search term.
Search modifiers are always before search functions / macros:
modifier:function:parameters
Macros:
macro:parameter
Macros override search functions.
Can expand into multiple search functions.
Search functions always look like:
function:parameter
property-name: is treated the same as search-function:
Almost all properties have an associated search function with the same name.
For example:
date-modified:
The search function
parameter can include the following preprocessor style:
[function:...]
This style was recently added.
You no longer need to use the awkward #[quote:...#]: style.
The expanded text is treated as quoted text.
I will refer to this style as the "termprocessor".
Parameters can also include references to your macros.
Expanded macros are treated as quoted text.
There are shortcuts for the preprocessor and termprocessor.
A good example of this is the clipboard preprocessor function:
#clipboard: is the same as #[clipboard:#]:
clipboard: is the same as [clipboard:]
#clipboard: will treat spaces as AND
clipboard: will treat spaces literally
clipboard: preprocessor.
There are conflicting search functions and termprocessor functions.
For example, the year: search function and the year: termprocessor function.
Search functions are always used first, so:
year:year:"2023-09-09"
is the same as:
year:[year:"2023-09-09"]
=> year:2023
(The year: search function is then called with 2023)
year: preprocessor.
year: search function.
Since there's no clipboard: search function, clipboard: on its own is treated as a termprocessor function.
Eval scripts always include the following (anywhere in the term):
$property:
For example:
len($stem:)%3==0
=> match filenames where the stem length is a multiple of 3.
In short:
#[function:...#]: = preprocessor.
#function: = preprocessor.
[function:] = termprocessor.
$property: = eval script.
function: = modifier > macro > search function > termprocessor.
Is the built in thing I'm using any of the above, or is it actually a macro? What actually constitutes a macro?
#[define:...#]: or #define: or [define:] is a
preprocessor define.
This is different to a filter macro, bookmark macro or just a macro.
The preprocessor does not have access to bookmarks/filters/macros.
Only use #define: if you want to access these defines from the preprocessor.
Is anything built in considered a macro? Or do the things listed above avoid the expansion issue?
No, there are no macros if you delete all your filters.
The default filters contain a few macros, for example: exe:
Are macros only user defined? With the term only being used to reference things like: Filters & Bookmarks?
Yes.
(Besides the default filters macros which can be deleted or changed)
How does `[define:definition]` fit into all of this? The syntax to call it is different (requiring a # hashtag) & documentation refers to it as a user defined function.
Defines can be a simple string or complex functions.
You can reference your defines with either #[define-name:#]: or #define-name: or [define-name:]
You can call your defined functions with either #[define-name:...#]: or #define-name:<parameters> #define-name:parameters or [define-name:parameters]
Is this effectively just a Macro? Or is it a Function & somehow fundamentally different? How do they differ?
Defines are fundamentally different to macros.
Defines can be called or referenced from the preprocessor.
The preprocessor does not have access to filters/bookmarks/macros.
Does it differ from macros defined using `/define name=search`?
My poor choice of naming here.
/define creates a macro.
It has nothing to do with the preprocessor define.
Does a user defined function (of either the `[define:definition]` or `/define name=search` variant) undergo expansion the same way macros (as in Filters & Bookmarks) do?
Yes and no.
Depends on how they are called.
#[mydefine:#]: or #mydefine: will expand spaces as AND.
[mydefine:] will expand as quoted text.
mymacro: outside a search function will expand spaces as AND
mymacro: inside a search function will expand as quoted text.
I recommend using macros over preprocessor defines.
I will consider search syntax highlighting.
Thank you for the suggestion.
Just noticed the `$param`. In what scenario do we get parameters and can use them in that form?
Support for $param: was very recently added. (
1355a)
Previously, macros would have to define the parameter name.
Now you can reference the parameter without defining a parameter name.
A filter macro example:
Name: Upper Case Example
Search: case:[upper:paramname:]
Macro: up<paramname>
up:abc
=>
case:ABC
The preferred syntax is now:
Name: Upper Case Example
Search: case:[upper:$param:]
Macro: up
up:abc
=>
case:ABC
Preprocessor defines must define the parameter names.
Preprocessor defines can have more than one parameter.
In macros, AFAIK you can't really operate on the passed in argument & it can only be passed to other things.
The search in macros are expanded twice.
Once with the preprocessor and again with the termprocessor.
(exactly the same as if you had typed the macro search into the search box)
$param: is only available inside the macro search.
I do want to add support for LUA at some stage.
However, I am really trying to avoid having the user enter in syntactically correct searches.
The Everything search syntax is flexible to allow searches like: size:>128mb (don't treat > as a closing the search group) -no one will want to escape the >
Each search function has it's own syntax.
Generally, most search functions all following the basic search syntax standard.
Space is always AND.
I am considering more aliases for operators.
for example:
::and::
::or::
::not::
::group-start::
::group-end::
This might make it easier to build complex macros.
Column Formulas are different again.
Column Formulas are C expressions which evaluate to a string or number.
Column Formulas are evaluated for each result -after the search.
Use $property: to reference the property values for the current result.
You can use column-a - column-f to define custom values and reference them with $a: - $f:
column-a - column-f can also be set from your search.
You can also use regex group captures and reference them with $0: - $9:
.)
those bookmarks are expanding to something like an 8mb query??? That blows my mind. It's magic that it can still be so fast.
Already reworked all my macros (Filters & Bookmarks) after you last mentioned this. Some things that have always stumped me as to why it wasn't working, now work!