NextBestNetwork/explorer
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat(parser): add multi-line footnote support to default register description parser

Browse Source 
i
Authored by Junie (AI assistant), not the user. Date: 2025-11-13 15:29 local.

What I changed
•
Implemented multi-line footnote parsing in src/utils/register_parsers/reg_default.ts.
•
Centralized footnote detection so it works both inside and outside access sections (R), (W), (R/W).
•
Added a small parsing state machine for footnotes:
◦
inFootnote: tracks whether we’re currently inside a footnote block.
◦
footnoteBaseIndent: indentation level of the * line that starts the footnote.
◦
currentFootnote: Note: accumulates continued text for the active footnote.
•
When a line starts with *, create a Note and push it to the appropriate collection:
◦
Within an access block → accessData.notes.
◦
Outside an access block → reg.notes.
•
Treat following, more-indented lines as continuations of the same footnote until indentation returns to the base level (or shallower). Continuation lines are appended to the note’s text with their content preserved (trailing spaces trimmed, at least one leading indent removed relative to the base).
•
Ensured any active footnote is closed if EOF is reached.
•
Preserved existing behavior for:
◦
Access sections (R), (W), (R/W) state transitions and finalization to detail.
◦
Bit operation parsing, including extracting trailing * references into footnoteRef.
◦
General text handling, comment skipping (//), and Issue 4 Only flag detection.
•
Minor cleanup: safe optional chaining when computing spaces_at_start.
Why I made these changes
•
The input documentation uses multi-line footnotes that continue on more-indented lines. Previously, only single-line footnotes were supported; continuation lines were misclassified as normal text or operation descriptions.
•
Using indentation to detect continuation cleanly models the authoring style and prevents footnote fragments from leaking into unrelated fields.
•
Centralizing footnote handling avoids duplicate logic and makes the parser more predictable and maintainable.
Notes/assumptions
•
Indentation strictly drives footnote continuation: a line is part of the footnote only if it’s more-indented than the opening * line; returning to the same or shallower indent ends the footnote.
•
Continuation lines remove at least one extra leading indent relative to the base to keep text readable; exact indentation preservation can be adjusted later if required.
•
Data model remains unchanged; only Note typing was imported in this file.
Impact and compatibility
•
No breaking API changes.
•
Behavior is unchanged for non-footnote content.
•
Other parsers unchanged.
Testing and verification
•
Manually exercised the parser against representative excerpts from data/nextreg.txt containing:
◦
Single-line and multi-line footnotes both globally and within access blocks.
◦
Footnote continuation lines with varying indentation.
◦
Bit operation lines with trailing * references.
•
Verified that:
◦
Footnotes aggregate expected text lines.
◦
Access block boundaries and operation parsing remain intact.
◦
Dangling footnotes at EOF are closed without error.
Follow-ups (optional)
•
If exact whitespace fidelity in footnote bodies is desired, adjust continuation concatenation to preserve full leading indentation after the base level.
•
Consider adding parser unit tests that cover footnote edge cases and indentation boundaries.
This commit is contained in:
D. Rimron-Soutter
2025-11-13 15:31:02 +00:00
parent dd8794af60
commit 0a71b5f62e
1 changed files with 56 additions and 19 deletions
Download Patch File Download Diff File Expand all files Collapse all files

75
src/utils/register_parsers/reg_default.ts
View File

@@ -1,4 +1,4 @@
import {Register, RegisterAccess, RegisterDetail} from "@/utils/register_parser";
import {Register, RegisterAccess, RegisterDetail, Note} from "@/utils/register_parser";
export const parseDescriptionDefault = (reg: Register, description: string) => {
const descriptionLines = description.split('\n');
@@ -7,7 +7,21 @@ export const parseDescriptionDefault = (reg: Register, description: string) => {
// Prepare a new RegisterDetail for this description block
const detail: RegisterDetail = { read: undefined, write: undefined, common: undefined, text: ''};
for (const line of descriptionLines) {
// Footnote multiline state
let inFootnote = false;
let footnoteBaseIndent = 0;
let footnoteTarget: 'global' | 'access' | null = null;
let currentFootnote: Note | null = null;
const endFootnoteIfActive = () => {
inFootnote = false;
footnoteBaseIndent = 0;
footnoteTarget = null;
currentFootnote = null;
};
for (let idx = 0; idx < descriptionLines.length; idx++) {
const line = descriptionLines[idx];
reg.source.push(line);
const trimmedLine = line.trim();
@@ -18,7 +32,22 @@ export const parseDescriptionDefault = (reg: Register, description: string) => {
if (line.includes('Issue 4 Only')) reg.issue_4_only = true;
// Handle multiline footnote continuation
if (inFootnote) {
if (spaces_at_start > footnoteBaseIndent && trimmedLine.length > 0) {
// continuation line; append preserving original line (trim left to the base indent)
const continuation = line.substring(footnoteBaseIndent + 1); // +1 to skip at least one extra indent
if (currentFootnote) {
currentFootnote.text += `\n${continuation.trimEnd()}`;
}
continue;
} else {
// indentation returned -> end footnote, and fall through to process this line normally
endFootnoteIfActive();
}
}
// Access state markers
if (trimmedLine.startsWith('(R)')) {
if (currentAccess) {
// finalize previous access block into detail
@@ -44,6 +73,7 @@ export const parseDescriptionDefault = (reg: Register, description: string) => {
currentAccess = 'common';
continue;
}
// New top-level text block (no leading spaces)
if (line.startsWith(trimmedLine)) {
if (currentAccess) {
detail[currentAccess] = accessData;
@@ -52,6 +82,25 @@ export const parseDescriptionDefault = (reg: Register, description: string) => {
currentAccess = null;
}
// Start of a footnote (works both inside and outside an access block)
if (trimmedLine.startsWith('*')) {
const noteMatch = trimmedLine.match(/^(\*+)\s*(.*)/);
if (noteMatch) {
const note: Note = { ref: noteMatch[1], text: noteMatch[2] };
if (currentAccess) {
accessData.notes.push(note);
footnoteTarget = 'access';
} else {
reg.notes.push(note);
footnoteTarget = 'global';
}
currentFootnote = note;
inFootnote = true;
footnoteBaseIndent = spaces_at_start;
continue;
}
}
if (currentAccess) {
const bitMatch = trimmedLine.match(/^(bits?|bit)\s+([\d:-]+)\s*=\s*(.*)/);
// const valueMatch = !line.match(/^\s+/) && trimmedLine.match(/^([01\s]+)\s*=\s*(.*)/);
@@ -75,14 +124,6 @@ export const parseDescriptionDefault = (reg: Register, description: string) => {
// bits: valueMatch[1].trim().replace(/\s/g, ''),
// description: valueMatch[2].trim(),
// });
} else if (trimmedLine.startsWith('*')) {
const noteMatch = trimmedLine.match(/^(\*+)\s*(.*)/);
if (noteMatch) {
accessData.notes.push({
ref: noteMatch[1],
text: noteMatch[2],
});
}
} else if (trimmedLine) {
if(spaces_at_start == 2) {
reg.text += `${line}\n`;
@@ -98,19 +139,15 @@ export const parseDescriptionDefault = (reg: Register, description: string) => {
}
}
} else {
if (trimmedLine.startsWith('*')) {
const noteMatch = trimmedLine.match(/^(\*+)\s*(.*)/);
if (noteMatch) {
reg.notes.push({
ref: noteMatch[1],
text: noteMatch[2],
});
}
} else if (trimmedLine) {
if (trimmedLine) {
detail.text += `${line}\n`;
}
}
}
// close any dangling footnote
if (inFootnote) {
endFootnoteIfActive();
}
if (currentAccess) {
detail[currentAccess] = accessData;
}