Introduction
Understanding the Automation Context
The Central Challenge
Considerations on Execution Policies
Conclusion
It's very common to use an application for manual and repetitive tasks, especially those with well-defined steps. I myself have faced this challenge with Notepad++ and know how difficult the search for an efficient solution — one that integrates with the utility — can be. Furthermore, when performing repetitive processes manually, errors can go unnoticed, affecting the quality and reliability of the result.
To solve this problem, I found a powerful approach: automating these tasks with PowerShell and regular expressions. This combination is especially effective because PowerShell, by using regular expressions to identify patterns, handles complex operations and processing logic. It optimized my workflows, eliminating human errors and increasing efficiency in both professional and study environments.
The task involves manipulating the text<sup>[number]</sup> pattern, frequently used in footnotes. With over a hundred occurrences to handle, it's evident that manual editing would be impractical due to the volume and repetitiveness.
File Structure:
The document contains multiple lines, each possibly with several instances of the pattern.
The numbering of the notes must be sequential throughout the document.
Tool Limitations:
Regular expressions (regex) are ideal for identifying the pattern but insufficient for performing the necessary sequential renumbering.
It is essential to use a programming language (such as PowerShell or Python) to implement the iteration and automatic renumbering logic.
Envisioning a complete solution, the following approach is suggested as an evaluation criterion:
Regex for extraction: Isolate all existing text<sup>[number]</sup> instances.
Custom script: Reprocess the text, replacing the numbers with an incremental sequence.
The approaches for footnote renumbering, proposed by community members — mklement0, toto and dr-rao —, present distinct characteristics, with advantages and some limitations:
PowerShell-based solution (mklement0)
✔ Pros: Absolute precision in sequential renumbering
✖ Cons:
Execution in an environment external to Notepad++
Lack of native integration (via API)
Need to switch between applications
Python-based solution, via plugin (toto, dr-rao)
✔ Pros: Transparent integration via Notepad++ plugins
✖ Cons:
Partial renumbering (requires additional manual or processing steps)
Dependence on third-party solutions
The central challenge lies in balancing:
Accuracy: Precise numerical sequence, ensuring correctness without introducing formatting issues (like extra characters).
Practicality: Direct implementation within the Notepad++ ecosystem.
To meet this challenge, the adopted solution consists of a hybrid approach that combines the robustness of external scripts (with regular expressions), integration via custom commands with shortcuts, and a continuous workflow that doesn't require context switching.
To renumber footnotes precisely and practically in Notepad++, the workflow is divided into two clear phases: initial environment setup and simplified routine execution. This approach leverages Notepad++'s ability to integrate external commands via keyboard shortcuts.
Note: The script below uses:
$(FULL_CURRENT_PATH): Notepad++ variable providing the full path of the active file.
$(NPP_FULL_FILE_PATH): Notepad++ variable that provides the path to notepad++.exe.
Output: [full path of original file without extension] - processed.txt file in the same folder.
Based on mklement0's solution for sequentially numbering footnotes.
Prepare and Save the PowerShell Script: Save the PowerShell script (.ps1) that will be used for renumbering in an easily accessible location that you intend to keep fixed, as this path will be referenced.
<#
.SYNOPSIS
Footnote Renumbering Script.
.DESCRIPTION
This script automates the sequential renumbering of footnotes
in the `text<sup>[number]</sup>` format in a text file.
It processes the file, generates a new file with the renumbered notes,
and opens this new file in Notepad++.
.PARAMETER FilePath
Full path to the text file containing the footnotes to be processed.
Mandatory and validates if the path points to an existing file.
.PARAMETER AppPath
Full path to the Notepad++ executable (e.g., 'C:\Program Files\Notepad++\notepad++.exe').
Mandatory and validates if the path points to an existing executable file.
.OUTPUTS
A new text file with the suffix ' - processed' in its name, containing the renumbered notes.
This file is created in the same folder as the original file.
.NOTES
Based on mklement0's solution for sequentially numbering footnotes.
[https://stackoverflow.com/questions/79654537/how-do-i-renumber-the-numbers-of-this-superscript](https://stackoverflow.com/questions/79654537/how-do-i-renumber-the-numbers-of-this-superscript)
Works on both PowerShell (pwsh.exe) and Windows PowerShell (powershell.exe).
#>
param(
# Defines the FilePath parameter, which is the path to the input file.
[Parameter(Mandatory=$true)] # Makes the parameter mandatory.
[ValidateScript({ Test-Path -Path $PSItem -PathType 'Leaf' })] # Validates if the path is to an existing file.
[string]$FilePath, # The parameter type is String.
# Defines the AppPath parameter, which is the path to the Notepad++ executable.
[Parameter(Mandatory=$true)] # Makes the parameter mandatory.
[ValidateScript({ Test-Path -Path $PSItem -PathType 'Leaf' })] # Validates if the path is to an existing file.
[string]$AppPath # The parameter type is String.
)
# Gets a FileInfo object for the input file, allowing access to its properties (name, folder, etc.).
$FileInfo = Get-Item -LiteralPath $FilePath -Force
# Constructs the full path for the new output file.
# It will be saved in the same folder as the original file, with "- processed" added to the base name.
$OutputFilePath =
$FileInfo.DirectoryName + '\' + # Adds the original file's directory.
$FileInfo.BaseName + ' - processed' + # Adds the file's base name plus the suffix.
$FileInfo.Extension # Keeps the original file extension.
# Reads the entire content of the input file as a single string.
# The '-Raw' parameter is crucial for regex operations to work on the entire text at once.
$Content = Get-Content -Raw $FilePath
# Defines the regular expression to find numbers within <sup>[number]</sup> tags.
# - `(?<=<sup>\[)`: Positive lookbehind, ensures the number is preceded by '<sup>[' but doesn't include it in the match.
# - `\d+`: Matches one or more digits (the note number).
# - `(?=\]</sup>)`: Positive lookahead, ensures the number is followed by ']</sup>' but doesn't include it in the match.
$RegexPattern = '(?<=<sup>\[)\d+(?=\]</sup>)'
# Checks if the script is being executed in PowerShell (modern, cross-platform version).
If ( $PSEdition -eq 'Core' ) {
# Initializes a counter for renumbering.
$Counter = 0
# Uses the -replace operator to substitute all regex matches.
# The script block { (++$Counter) } is executed for each match,
# incrementing the counter and using its value as the replacement.
$ProcessedContent = $Content -replace $RegexPattern, { (++$Counter) }
} Else {
# If not PowerShell, it's assumed to be Windows PowerShell.
# In Windows PowerShell, the counter needs to be encapsulated in a mutable object (hashtable)
# for its state to persist across replacements.
$Counter = @{ Value = 0 }
# Uses the .NET class [Regex]::Replace to perform the replacement.
# The script block is similar, but accesses the .Value property of the hashtable.
$ProcessedContent = [Regex]::Replace( $Content, $RegexPattern, { (++$Counter.Value) } )
}
# Saves the resulting content (with renumbered notes) to the new output file.
$ProcessedContent > $OutputFilePath
# Pauses execution for 1 second. This can allow time for the file to be fully written
# before Notepad++ attempts to open it, though often not strictly necessary.
Start-Sleep -Seconds 1
# Executes Notepad++ and passes the output file path as an argument.
# This will cause Notepad++ to open the renumbered file.
& $AppPath $OutputFilePath
Create the Custom Command in Notepad++:
In Notepad++, go to Run > Run… (or press F5)
In the "Command" field, enter: powershell.exe -ExecutionPolicy Bypass -File "C:\Path\To\Your\Script.ps1" "$(FULL_CURRENT_PATH)" "$(NPP_FULL_FILE_PATH)"
C:\Path\To\Your\Script.ps1 with the actual path to your PowerShell script.Click Save…
Give the command an intuitive name (e.g., "Renumber Footnotes")
Choose a convenient keyboard shortcut (e.g., Ctrl+F5)
Click OK
Open the File: Open the text file in Notepad++ that contains the footnotes to be renumbered.
Activate the Shortcut: With the file in focus, simply use the keyboard shortcut you configured (e.g., Ctrl+F5).
Check the Result: The script will execute and generate a new renumbered file in the format [original file name] - processed.txt. This new file will automatically open in Notepad++ for review.
Pro Tip (Script Execution and Debugging): For greater flexibility in executing and debugging scripts directly from Notepad++, you can configure the
Runmenu to include options like "Windows PowerShell (powershell.exe)", "PowerShell [cross-platform] (pwsh.exe)" and "Command Prompt (cmd.exe)" in a "Run in terminal" submenu. For complete details on this configuration, consult a detailed answer I elaborated on this Microsoft forum.
In corporate environments, Group Policy Objects (GPOs) may block -ExecutionPolicy Bypass. In this case:
Use -ExecutionPolicy RemoteSigned for digitally signed scripts. For more details, visit the Set-AuthenticodeSignature page.
Consult your IT administrator to adjust group policies, if necessary. For more details, visit the page on PowerShell Execution Policies.
Automating repetitive tasks in Notepad++ with PowerShell proved to be a robust and efficient solution for text manipulation challenges. Throughout this guide, it was demonstrated how identifying manual problems, analyzing existing approaches, and the direct integration between Notepad++ and external scripts is fundamental to optimizing the workflow.
The ability to configure a custom command, associating a PowerShell script with a simple keyboard shortcut, transforms time-consuming processes into a fast and precise action. This not only frees up time and energy for more complex tasks but also ensures the consistency and quality of results, eliminating human errors inherent in manual execution. Furthermore, this integration opens doors for direct script debugging, further enhancing development efficiency.
In summary, the approach detailed in this guide not only solves a specific text manipulation problem but also illustrates the vast potential of automation to elevate productivity and reliability in any work or study environment that uses Notepad++.
More than a simple solution, this methodology represents an invitation to explore new ways of interacting with Notepad++, transforming how you handle repetitive tasks and opening possibilities for future automations.