|
|
@@ -0,0 +1,539 @@
|
|
|
+/** Token-based Pascal document formatter with user-settable rules.
|
|
|
+ *
|
|
|
+ * Twin of the Modula-2 formatter: line structure is preserved
|
|
|
+ * (statements are never joined or split), while indentation, keyword
|
|
|
+ * case, intra-line spacing, blank lines and trailing whitespace are
|
|
|
+ * normalised per `FormatOptions`. Comments are preserved verbatim
|
|
|
+ * (only repositioned); continuation lines of multi-line comments are
|
|
|
+ * emitted as-is. Best-effort on broken code: always terminates and
|
|
|
+ * never drops tokens.
|
|
|
+ */
|
|
|
+
|
|
|
+import * as path from 'path';
|
|
|
+import { parsePascal, parseUses, PasSymbol } from './pascalSymbols';
|
|
|
+import { resolveAt } from './pascalResolve';
|
|
|
+
|
|
|
+export type KeywordCase = 'upper' | 'preserve';
|
|
|
+
|
|
|
+export interface FormatOptions {
|
|
|
+ indentSize: number;
|
|
|
+ useTabs: boolean;
|
|
|
+ keywordCase: KeywordCase;
|
|
|
+ spaceAroundOperators: boolean;
|
|
|
+ spaceAfterComma: boolean;
|
|
|
+ spaceBeforeColon: boolean;
|
|
|
+ spaceAroundRange: boolean;
|
|
|
+ emptyLineLimit: number;
|
|
|
+ trimTrailingWhitespace: boolean;
|
|
|
+ insertFinalNewline: boolean;
|
|
|
+}
|
|
|
+
|
|
|
+export const DEFAULT_FORMAT_OPTIONS: FormatOptions = {
|
|
|
+ indentSize: 2,
|
|
|
+ useTabs: false,
|
|
|
+ keywordCase: 'upper',
|
|
|
+ spaceAroundOperators: true,
|
|
|
+ spaceAfterComma: true,
|
|
|
+ spaceBeforeColon: false,
|
|
|
+ spaceAroundRange: true,
|
|
|
+ emptyLineLimit: 1,
|
|
|
+ trimTrailingWhitespace: true,
|
|
|
+ insertFinalNewline: true,
|
|
|
+};
|
|
|
+
|
|
|
+/** Sanitise arbitrary settings JSON into valid options (never throws). */
|
|
|
+export function normalizeFormatOptions(raw: unknown): FormatOptions {
|
|
|
+ const r = (raw ?? {}) as Partial<FormatOptions>;
|
|
|
+ const num = (v: unknown, lo: number, hi: number, dflt: number): number => {
|
|
|
+ const n = typeof v === 'number' && Number.isFinite(v) ? Math.round(v) : dflt;
|
|
|
+ return Math.min(hi, Math.max(lo, n));
|
|
|
+ };
|
|
|
+ const bool = (v: unknown, dflt: boolean): boolean =>
|
|
|
+ typeof v === 'boolean' ? v : dflt;
|
|
|
+ return {
|
|
|
+ indentSize: num(r.indentSize, 0, 8, DEFAULT_FORMAT_OPTIONS.indentSize),
|
|
|
+ useTabs: bool(r.useTabs, false),
|
|
|
+ keywordCase: r.keywordCase === 'preserve' || r.keywordCase === 'upper'
|
|
|
+ ? r.keywordCase : 'upper',
|
|
|
+ spaceAroundOperators: bool(r.spaceAroundOperators, true),
|
|
|
+ spaceAfterComma: bool(r.spaceAfterComma, true),
|
|
|
+ spaceBeforeColon: bool(r.spaceBeforeColon, false),
|
|
|
+ spaceAroundRange: bool(r.spaceAroundRange, true),
|
|
|
+ emptyLineLimit: num(r.emptyLineLimit, 0, 10, DEFAULT_FORMAT_OPTIONS.emptyLineLimit),
|
|
|
+ trimTrailingWhitespace: bool(r.trimTrailingWhitespace, true),
|
|
|
+ insertFinalNewline: bool(r.insertFinalNewline, true),
|
|
|
+ };
|
|
|
+}
|
|
|
+
|
|
|
+type TokenKind = 'keyword' | 'ident' | 'number' | 'string' | 'symbol';
|
|
|
+
|
|
|
+interface RichToken {
|
|
|
+ text: string;
|
|
|
+ kind: TokenKind;
|
|
|
+ comment?: boolean;
|
|
|
+ line: number; ch: number; endLine: number; endCh: number;
|
|
|
+ offset: number; endOffset: number;
|
|
|
+}
|
|
|
+
|
|
|
+/** Reserved words matched case-insensitively by the formatter lexer. */
|
|
|
+const PASCAL_KEYWORDS = new Set([
|
|
|
+ 'AND', 'ARRAY', 'BEGIN', 'CASE', 'CONST', 'DIV', 'DO', 'DOWNTO',
|
|
|
+ 'ELSE', 'END', 'EXCEPT', 'EXPORTS', 'FILE', 'FINALIZATION', 'FINALLY',
|
|
|
+ 'FOR', 'FORWARD', 'FUNCTION', 'GOTO', 'IF', 'IMPLEMENTATION', 'IN',
|
|
|
+ 'INHERITED', 'INITIALIZATION', 'INTERFACE', 'LABEL', 'LIBRARY', 'MOD',
|
|
|
+ 'NIL', 'NOT', 'OF', 'OR', 'PACKED', 'PROCEDURE', 'PROGRAM', 'RECORD',
|
|
|
+ 'REPEAT', 'RESOURCESTRING', 'SET', 'SHL', 'SHR', 'THEN', 'THREADVAR',
|
|
|
+ 'TO', 'TRY', 'TYPE', 'UNIT', 'UNTIL', 'USES', 'VAR', 'WHILE', 'WITH', 'XOR',
|
|
|
+]);
|
|
|
+
|
|
|
+const isWordStart = (c: string) => /[A-Za-z_]/.test(c);
|
|
|
+const isWordChar = (c: string) => /[A-Za-z0-9_]/.test(c);
|
|
|
+const isDigit = (c: string) => /[0-9]/.test(c);
|
|
|
+
|
|
|
+/** Lex code tokens (comments land in `comments`, strings are skipped). */
|
|
|
+function lexCode(text: string): { tokens: RichToken[]; comments: RichToken[] } {
|
|
|
+ const tokens: RichToken[] = [];
|
|
|
+ const comments: RichToken[] = [];
|
|
|
+ let i = 0;
|
|
|
+ let line = 0;
|
|
|
+ let col = 0;
|
|
|
+ const push = (t: string, kind: TokenKind, sl: number, sc: number, so: number): void => {
|
|
|
+ tokens.push({ text: t, kind, line: sl, ch: sc, endLine: line, endCh: col, offset: so, endOffset: i });
|
|
|
+ };
|
|
|
+ const pushComment = (t: string, sl: number, sc: number, so: number): void => {
|
|
|
+ comments.push({ text: t, kind: 'ident', comment: true, line: sl, ch: sc, endLine: line, endCh: col, offset: so, endOffset: i });
|
|
|
+ };
|
|
|
+ const step = (n: number): void => {
|
|
|
+ for (let k = 0; k < n; k++) {
|
|
|
+ if (text[i] === '\n') { line++; col = 0; }
|
|
|
+ else if (text[i] !== '\r') { col++; }
|
|
|
+ else { col = 0; }
|
|
|
+ i++;
|
|
|
+ }
|
|
|
+ };
|
|
|
+ while (i < text.length) {
|
|
|
+ const c = text[i];
|
|
|
+ const nx = i + 1 < text.length ? text[i + 1] : '';
|
|
|
+ if (c === '\n' || c === '\r' || c === ' ' || c === '\t') { step(1); continue; }
|
|
|
+ // Nested (* *) comment.
|
|
|
+ if (c === '(' && nx === '*') {
|
|
|
+ const sl = line; const sc = col; const so = i;
|
|
|
+ let level = 1;
|
|
|
+ step(2);
|
|
|
+ while (i < text.length && level > 0) {
|
|
|
+ if (text[i] === '(' && text[i + 1] === '*') { level++; step(2); continue; }
|
|
|
+ if (text[i] === '*' && text[i + 1] === ')') { level--; step(2); continue; }
|
|
|
+ step(1);
|
|
|
+ }
|
|
|
+ pushComment(text.slice(so, i), sl, sc, so);
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+ // { } comment (possibly multi-line, e.g. {$directives}).
|
|
|
+ if (c === '{') {
|
|
|
+ const sl = line; const sc = col; const so = i;
|
|
|
+ step(1);
|
|
|
+ while (i < text.length && text[i] !== '}') step(1);
|
|
|
+ if (i < text.length) step(1);
|
|
|
+ pushComment(text.slice(so, i), sl, sc, so);
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+ // // comment to end of line.
|
|
|
+ if (c === '/' && nx === '/') {
|
|
|
+ const sl = line; const sc = col; const so = i;
|
|
|
+ while (i < text.length && text[i] !== '\n' && text[i] !== '\r') step(1);
|
|
|
+ pushComment(text.slice(so, i), sl, sc, so);
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+ // '...' string with '' escape (unterminated runs to end of line).
|
|
|
+ if (c === "'") {
|
|
|
+ const sl = line; const sc = col; const so = i;
|
|
|
+ step(1);
|
|
|
+ while (i < text.length && text[i] !== '\n' && text[i] !== '\r') {
|
|
|
+ if (text[i] === "'") {
|
|
|
+ if (text[i + 1] === "'") { step(2); continue; }
|
|
|
+ step(1);
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ step(1);
|
|
|
+ }
|
|
|
+ push(text.slice(so, i), 'string', sl, sc, so);
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+ if (isWordStart(c)) {
|
|
|
+ const sl = line; const sc = col; const so = i;
|
|
|
+ while (i < text.length && isWordChar(text[i])) step(1);
|
|
|
+ const word = text.slice(so, i);
|
|
|
+ push(word, PASCAL_KEYWORDS.has(word.toUpperCase()) ? 'keyword' : 'ident', sl, sc, so);
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+ // Numbers: $hex, &octal, %binary, decimal with optional fraction/exponent.
|
|
|
+ if (isDigit(c) || ((c === '$' || c === '&' || c === '%') && /[0-9A-Fa-f]/.test(nx))) {
|
|
|
+ const sl = line; const sc = col; const so = i;
|
|
|
+ if (c === '$' || c === '&' || c === '%') {
|
|
|
+ step(1);
|
|
|
+ while (i < text.length && /[0-9A-Fa-f]/.test(text[i])) step(1);
|
|
|
+ } else {
|
|
|
+ while (i < text.length && isDigit(text[i])) step(1);
|
|
|
+ if (text[i] === '.' && text[i + 1] !== '.' && isDigit(text[i + 1] ?? '')) {
|
|
|
+ step(1);
|
|
|
+ while (i < text.length && isDigit(text[i])) step(1);
|
|
|
+ }
|
|
|
+ if (text[i] === 'E' || text[i] === 'e') {
|
|
|
+ let j = i + 1;
|
|
|
+ if (text[j] === '+' || text[j] === '-') j++;
|
|
|
+ if (isDigit(text[j] ?? '')) {
|
|
|
+ while (j < text.length && isDigit(text[j])) j++;
|
|
|
+ const span = j - i;
|
|
|
+ step(span);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ push(text.slice(so, i), 'number', sl, sc, so);
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+ // Multi-char symbols.
|
|
|
+ const sl = line; const sc = col; const so = i;
|
|
|
+ const two = text.slice(i, i + 2);
|
|
|
+ if (two === ':=' || two === '<=' || two === '>=' || two === '<>' || two === '..') {
|
|
|
+ step(2);
|
|
|
+ push(two, 'symbol', sl, sc, so);
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+ step(1);
|
|
|
+ push(c, 'symbol', sl, sc, so);
|
|
|
+ }
|
|
|
+ return { tokens, comments };
|
|
|
+}
|
|
|
+
|
|
|
+/** Structural words for indentation (matched case-insensitively). */
|
|
|
+const STRUCT = new Set([
|
|
|
+ 'END', 'ELSE', 'UNTIL', 'EXCEPT', 'FINALLY',
|
|
|
+ 'THEN', 'BEGIN', 'RECORD', 'REPEAT', 'DO', 'CASE', 'OF', 'TRY',
|
|
|
+]);
|
|
|
+const DISPLAY_DEDENT = new Set(['END', 'ELSE', 'UNTIL', 'EXCEPT', 'FINALLY']);
|
|
|
+const OPENERS = new Set(['THEN', 'BEGIN', 'RECORD', 'REPEAT', 'DO', 'TRY']);
|
|
|
+const CLOSERS = new Set(['END', 'UNTIL']);
|
|
|
+const UNARY_AFTER = new Set([
|
|
|
+ '(', '[', ',', ';', ':=', '=', '..', 'THEN', 'DO', 'OF',
|
|
|
+ 'NOT', 'AND', 'OR', 'DIV', 'MOD', 'IN', '+', '-', '*', '/', '<', '<=',
|
|
|
+ '>', '>=', '<>', '@', 'BY', 'TO', 'DOWNTO',
|
|
|
+]);
|
|
|
+
|
|
|
+function wordOf(t: RichToken): string {
|
|
|
+ return t.kind === 'keyword' && STRUCT.has(t.text.toUpperCase()) ? t.text.toUpperCase() : '';
|
|
|
+}
|
|
|
+
|
|
|
+function applyCase(text: string, mode: KeywordCase): string {
|
|
|
+ return mode === 'upper' ? text.toUpperCase() : text;
|
|
|
+}
|
|
|
+
|
|
|
+/** Promote keyword-shaped identifiers to keywords unless they resolve.
|
|
|
+ *
|
|
|
+ * Lowercase keywords lex as identifiers, but real code also uses words
|
|
|
+ * like `to` or `in` as identifiers. An identifier that is declared here
|
|
|
+ * or resolves (qualifier-aware) stays an identifier; anything else
|
|
|
+ * shaped like a reserved word is a keyword. This keeps formatting
|
|
|
+ * token-exact.
|
|
|
+ */
|
|
|
+function classifyKeywords(tokens: RichToken[], text: string, filePath: string, docDir: string): void {
|
|
|
+ let symbols: PasSymbol[];
|
|
|
+ try {
|
|
|
+ symbols = parsePascal(text);
|
|
|
+ } catch {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ const uses = parseUses(text);
|
|
|
+ const declared = new Set<string>();
|
|
|
+ const flatten = (ss: PasSymbol[]): void => {
|
|
|
+ for (const s of ss) {
|
|
|
+ if (s.name) declared.add(`${s.line}:${s.ch}`);
|
|
|
+ flatten(s.children);
|
|
|
+ }
|
|
|
+ };
|
|
|
+ flatten(symbols);
|
|
|
+ const prevCode = (i: number): { tok: RichToken; idx: number } | null => {
|
|
|
+ for (let j = i - 1; j >= 0; j--) {
|
|
|
+ const t = tokens[j];
|
|
|
+ if (!t.comment) return { tok: t, idx: j };
|
|
|
+ }
|
|
|
+ return null;
|
|
|
+ };
|
|
|
+ tokens.forEach((t, i) => {
|
|
|
+ if (t.comment || t.kind !== 'ident' || !PASCAL_KEYWORDS.has(t.text.toUpperCase())) return;
|
|
|
+ if (declared.has(`${t.line}:${t.ch}`)) return;
|
|
|
+ let qualifier: string | null = null;
|
|
|
+ const dot = prevCode(i);
|
|
|
+ if (dot && dot.tok.text === '.') {
|
|
|
+ const head = prevCode(dot.idx);
|
|
|
+ if (!head || head.tok.kind !== 'ident') return;
|
|
|
+ qualifier = head.tok.text;
|
|
|
+ }
|
|
|
+ const r = resolveAt(symbols, uses, filePath, docDir, t.line, t.ch, qualifier, t.text);
|
|
|
+ if (!r) t.kind = 'keyword';
|
|
|
+ });
|
|
|
+}
|
|
|
+
|
|
|
+export function formatDocument(
|
|
|
+ text: string, rawOptions?: Partial<FormatOptions>, filePath = '', docDir = '',
|
|
|
+): string {
|
|
|
+ const opts = normalizeFormatOptions(rawOptions ?? {});
|
|
|
+ const { entries, eol } = formatLineEntries(text, opts, filePath, docDir);
|
|
|
+ const joined = entries.map(l => l.text).join('\n');
|
|
|
+ if (!opts.insertFinalNewline) return joined.split('\n').join(eol);
|
|
|
+ return (joined.length > 0 ? joined + '\n' : '').split('\n').join(eol);
|
|
|
+}
|
|
|
+
|
|
|
+/** One formatted output line and the 0-based input line it came from. */
|
|
|
+export interface FormattedLine {
|
|
|
+ src: number;
|
|
|
+ text: string;
|
|
|
+}
|
|
|
+
|
|
|
+/** One edit for `textDocument/rangeFormatting`, directly mappable to LSP. */
|
|
|
+export interface RangeEdit {
|
|
|
+ startLine: number;
|
|
|
+ startCh: number;
|
|
|
+ endLine: number;
|
|
|
+ endCh: number;
|
|
|
+ newText: string;
|
|
|
+}
|
|
|
+
|
|
|
+/** Format a line range with full-document context. Never throws. */
|
|
|
+export function formatRangeEdits(
|
|
|
+ text: string, startLine: number, endLine: number,
|
|
|
+ rawOptions?: Partial<FormatOptions>, filePath = '', docDir = '',
|
|
|
+): RangeEdit[] {
|
|
|
+ if (text.length === 0) return [];
|
|
|
+ const opts = normalizeFormatOptions(rawOptions ?? {});
|
|
|
+ const srcLines = text.split('\n');
|
|
|
+ const srcCount = srcLines.length;
|
|
|
+ const from = Math.min(Math.max(0, Math.min(startLine, endLine)), srcCount - 1);
|
|
|
+ const to = Math.min(Math.max(Math.max(startLine, endLine), from), srcCount - 1);
|
|
|
+ const { entries } = formatLineEntries(text, rawOptions, filePath, docDir);
|
|
|
+ const bySrc = new Map<number, string>();
|
|
|
+ for (const e of entries) {
|
|
|
+ if (e.src >= from && e.src <= to && !bySrc.has(e.src)) bySrc.set(e.src, e.text);
|
|
|
+ }
|
|
|
+ const edits: RangeEdit[] = [];
|
|
|
+ let runFrom = -1;
|
|
|
+ const parts: string[] = [];
|
|
|
+ let tailNewlined = false;
|
|
|
+ const flush = (endExclusive: number): void => {
|
|
|
+ if (runFrom < 0) return;
|
|
|
+ const atEof = endExclusive >= srcCount;
|
|
|
+ if (atEof && parts.length === 0 && runFrom > 0) {
|
|
|
+ const prevLen = srcLines[runFrom - 1].length;
|
|
|
+ edits.push({
|
|
|
+ startLine: runFrom - 1, startCh: prevLen,
|
|
|
+ endLine: srcCount - 1, endCh: srcLines[srcCount - 1].length,
|
|
|
+ newText: opts.insertFinalNewline && entries.length > 0 ? '\n' : '',
|
|
|
+ });
|
|
|
+ runFrom = -1;
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ let newText = parts.join('\n');
|
|
|
+ if (parts.length > 0 && (atEof ? opts.insertFinalNewline : true)) newText += '\n';
|
|
|
+ if (atEof && newText.endsWith('\n')) tailNewlined = true;
|
|
|
+ const end = atEof
|
|
|
+ ? { line: srcCount - 1, ch: srcLines[srcCount - 1].length }
|
|
|
+ : { line: endExclusive, ch: 0 };
|
|
|
+ edits.push({
|
|
|
+ startLine: runFrom, startCh: 0,
|
|
|
+ endLine: end.line, endCh: end.ch, newText,
|
|
|
+ });
|
|
|
+ runFrom = -1;
|
|
|
+ parts.length = 0;
|
|
|
+ };
|
|
|
+ for (let s = from; s <= to; s++) {
|
|
|
+ const want = bySrc.get(s);
|
|
|
+ if (want !== undefined && want === srcLines[s]) {
|
|
|
+ flush(s);
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+ if (runFrom < 0) runFrom = s;
|
|
|
+ if (want !== undefined) parts.push(want);
|
|
|
+ }
|
|
|
+ flush(to + 1);
|
|
|
+ if (to === srcCount - 1 && opts.insertFinalNewline && !text.endsWith('\n') &&
|
|
|
+ entries.length > 0 && !tailNewlined) {
|
|
|
+ const last = srcLines[srcCount - 1].length;
|
|
|
+ edits.push({
|
|
|
+ startLine: srcCount - 1, startCh: last,
|
|
|
+ endLine: srcCount - 1, endCh: last, newText: '\n',
|
|
|
+ });
|
|
|
+ }
|
|
|
+ return edits;
|
|
|
+}
|
|
|
+
|
|
|
+function formatLineEntries(
|
|
|
+ text: string, rawOptions?: Partial<FormatOptions>, filePath = '', docDir = '',
|
|
|
+): { entries: FormattedLine[]; eol: string } {
|
|
|
+ const opts = normalizeFormatOptions(rawOptions ?? {});
|
|
|
+ if (text.length === 0) return { entries: [], eol: '\n' };
|
|
|
+ const eol = text.includes('\r\n') ? '\r\n' : '\n';
|
|
|
+ const dir = docDir || (filePath ? path.dirname(filePath) : '');
|
|
|
+ const { tokens, comments } = lexCode(text);
|
|
|
+ const all: RichToken[] = [...tokens, ...comments].sort((a, b) => a.offset - b.offset);
|
|
|
+ classifyKeywords(all, text, filePath, dir);
|
|
|
+
|
|
|
+ const byLine = new Map<number, RichToken[]>();
|
|
|
+ let maxLine = 0;
|
|
|
+ for (const t of all) {
|
|
|
+ maxLine = Math.max(maxLine, t.endLine);
|
|
|
+ const list = byLine.get(t.line) ?? [];
|
|
|
+ list.push(t);
|
|
|
+ byLine.set(t.line, list);
|
|
|
+ }
|
|
|
+ const srcLines = text.split(/\r?\n/);
|
|
|
+ const lastLine = Math.max(maxLine, srcLines.length - 1);
|
|
|
+
|
|
|
+ const verbatim = new Set<number>();
|
|
|
+ for (const t of all) {
|
|
|
+ if (t.comment && t.endLine > t.line) {
|
|
|
+ for (let l = t.line + 1; l <= t.endLine; l++) verbatim.add(l);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ const indentOf = (level: number): string =>
|
|
|
+ opts.useTabs ? '\t'.repeat(level) : ' '.repeat(opts.indentSize * level);
|
|
|
+
|
|
|
+ const entries: FormattedLine[] = [];
|
|
|
+ let level = 0;
|
|
|
+ let casePending = false;
|
|
|
+ let blanks = 0;
|
|
|
+
|
|
|
+ for (let i = 0; i <= lastLine; i++) {
|
|
|
+ const lineToks = (byLine.get(i) ?? []).filter(t => !t.comment || t.line === i);
|
|
|
+ const code = lineToks.filter(t => !t.comment);
|
|
|
+ const startsHere = lineToks.filter(t => t.comment && t.line === i);
|
|
|
+
|
|
|
+ if (verbatim.has(i)) {
|
|
|
+ entries.push({ src: i, text: opts.trimTrailingWhitespace ? srcLines[i]?.replace(/[ \t]+$/, '') ?? '' : srcLines[i] ?? '' });
|
|
|
+ const applied = applyDelta(code, level, { casePending });
|
|
|
+ level = applied.level;
|
|
|
+ casePending = applied.casePending;
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (code.length === 0 && startsHere.length === 0) {
|
|
|
+ blanks++;
|
|
|
+ if (blanks <= opts.emptyLineLimit) entries.push({ src: i, text: '' });
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+ blanks = 0;
|
|
|
+
|
|
|
+ if (code.length === 0) {
|
|
|
+ const parts = startsHere.map(c => firstFragment(c));
|
|
|
+ entries.push({ src: i, text: indentOf(level) + parts.join(' ') });
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+
|
|
|
+ const first = wordOf(code[0]);
|
|
|
+ const emitLevel = Math.max(0, level - (DISPLAY_DEDENT.has(first) ? 1 : 0));
|
|
|
+ let body = emitTokens(code, opts);
|
|
|
+ const trailing = startsHere.filter(c => code[0].offset < c.offset);
|
|
|
+ for (const c of trailing) body += ' ' + firstFragment(c);
|
|
|
+ let lineText = indentOf(emitLevel) + body;
|
|
|
+ if (opts.trimTrailingWhitespace) lineText = lineText.replace(/[ \t]+$/, '');
|
|
|
+ entries.push({ src: i, text: lineText });
|
|
|
+
|
|
|
+ const applied = applyDelta(code, level, { casePending });
|
|
|
+ level = applied.level;
|
|
|
+ casePending = applied.casePending;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (!opts.insertFinalNewline) return { entries, eol };
|
|
|
+ while (entries.length > 0 && /^[ \t]*$/.test(entries[entries.length - 1].text)) {
|
|
|
+ entries.pop();
|
|
|
+ }
|
|
|
+ if (entries.length > 0) {
|
|
|
+ entries[entries.length - 1].text = entries[entries.length - 1].text.replace(/[ \t]+$/, '');
|
|
|
+ }
|
|
|
+ return { entries, eol };
|
|
|
+}
|
|
|
+
|
|
|
+function firstFragment(c: RichToken): string {
|
|
|
+ const idx = c.text.search(/\r?\n/);
|
|
|
+ return idx < 0 ? c.text : c.text.slice(0, idx);
|
|
|
+}
|
|
|
+
|
|
|
+function applyDelta(
|
|
|
+ code: RichToken[], level: number, state: { casePending: boolean },
|
|
|
+): { level: number; casePending: boolean } {
|
|
|
+ let opens = 0;
|
|
|
+ let closes = 0;
|
|
|
+ let casePending = state.casePending;
|
|
|
+ for (const t of code) {
|
|
|
+ const w = wordOf(t);
|
|
|
+ if (!w) continue;
|
|
|
+ if (w === 'CASE') {
|
|
|
+ casePending = true;
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+ if (w === 'OF') {
|
|
|
+ if (casePending) {
|
|
|
+ opens++;
|
|
|
+ casePending = false;
|
|
|
+ }
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+ if (OPENERS.has(w)) {
|
|
|
+ opens++;
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+ if (CLOSERS.has(w)) {
|
|
|
+ closes++;
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return { level: Math.max(0, level + opens - closes), casePending };
|
|
|
+}
|
|
|
+
|
|
|
+function isWordish(t: RichToken): boolean {
|
|
|
+ return t.kind === 'ident' || t.kind === 'keyword' || t.kind === 'number' || t.kind === 'string';
|
|
|
+}
|
|
|
+
|
|
|
+function emitTokens(code: RichToken[], opts: FormatOptions): string {
|
|
|
+ let out = '';
|
|
|
+ const gap = (prev: RichToken | null, cur: RichToken): string => {
|
|
|
+ if (!prev) return '';
|
|
|
+ const pt = prev.text;
|
|
|
+ const ct = cur.text;
|
|
|
+ if (ct === '(') return prev.kind === 'keyword' ? ' ' : '';
|
|
|
+ if (ct === '[') return prev.kind === 'keyword' ? ' ' : '';
|
|
|
+ if (pt === '(' || pt === '[') return '';
|
|
|
+ if (pt === '.' || pt === '^' || pt === '@') return '';
|
|
|
+ if (ct === ')' || ct === ']') return '';
|
|
|
+ if (ct === '.' || ct === '^') return '';
|
|
|
+ if (ct === ',') return '';
|
|
|
+ if (ct === ';') return '';
|
|
|
+ if (pt === ')' || pt === ']' || pt === ';') {
|
|
|
+ return isWordish(cur) ? ' ' : '';
|
|
|
+ }
|
|
|
+ if (ct === ':=') return opts.spaceAroundOperators ? ' ' : '';
|
|
|
+ if (pt === ':=') return opts.spaceAroundOperators ? ' ' : '';
|
|
|
+ if (pt === ',') return opts.spaceAfterComma ? ' ' : '';
|
|
|
+ if (ct === ':') return opts.spaceBeforeColon ? ' ' : '';
|
|
|
+ if (pt === ':') return ' ';
|
|
|
+ if (ct === '..' || pt === '..') return opts.spaceAroundRange ? ' ' : '';
|
|
|
+ if (ct === '+' || ct === '-') return isUnary(prev) ? '' : (opts.spaceAroundOperators ? ' ' : '');
|
|
|
+ if (cur.kind === 'symbol' || prev.kind === 'symbol') {
|
|
|
+ return opts.spaceAroundOperators ? ' ' : '';
|
|
|
+ }
|
|
|
+ return ' ';
|
|
|
+ };
|
|
|
+ let prev: RichToken | null = null;
|
|
|
+ for (const t of code) {
|
|
|
+ const text = t.kind === 'keyword' ? applyCase(t.text, opts.keywordCase) : t.text;
|
|
|
+ out += gap(prev, t) + text;
|
|
|
+ prev = t;
|
|
|
+ }
|
|
|
+ return out;
|
|
|
+}
|
|
|
+
|
|
|
+function isUnary(prev: RichToken | null): boolean {
|
|
|
+ if (!prev) return true;
|
|
|
+ if (prev.kind === 'keyword') return UNARY_AFTER.has(prev.text.toUpperCase());
|
|
|
+ if (prev.kind !== 'symbol') return false;
|
|
|
+ return UNARY_AFTER.has(prev.text);
|
|
|
+}
|
