@hsusulist/luc 0.3.0 → 0.3.1

package/install.ps1

@@ -43,6 +43,10 @@ $script:UseAnsi = $false
 $script:InAltScreen = $false
 $script:Interactive = $false
 $script:Version = ''
+$script:MaintenanceAction = 'install'
+$script:ExistingComponents = @()
+$script:ExistingInstall = $null
+$script:ScriptDirectory = if ($PSCommandPath) { Split-Path -Parent $PSCommandPath } else { $null }
 
 # ---------------------------------------------------------------------------
 # Console helpers
@@ -253,6 +257,153 @@ function Show-SourcePage {
     }
 }
 
+function Get-InstalledDetails {
+    param([string]$RequestedPath)
+
+    $state = $null
+    $stateFile = Join-Path (Join-Path $env:LOCALAPPDATA 'LUC') 'state.json'
+    if (Test-Path -LiteralPath $stateFile -PathType Leaf) {
+        try {
+            $state = Get-Content -LiteralPath $stateFile -Raw | ConvertFrom-Json -ErrorAction Stop
+        } catch {
+            Write-Note "Could not read the install state: $($_.Exception.Message)" 'warn'
+        }
+    }
+
+    $path = $RequestedPath
+    if (-not $path -and $script:ScriptDirectory -and
+        (Test-Path -LiteralPath (Join-Path $script:ScriptDirectory 'luc.exe') -PathType Leaf)) {
+        $path = $script:ScriptDirectory
+    }
+    if (-not $path -and $state -and $state.installPath) { $path = [string]$state.installPath }
+    if (-not $path) { $path = $defaultInstallPath }
+    $path = Resolve-InstallPathValue $path
+    if (-not (Test-Path -LiteralPath (Join-Path $path 'luc.exe') -PathType Leaf)) { return $null }
+
+    if ($state -and $state.installPath) {
+        try {
+            $statePath = Resolve-InstallPathValue ([string]$state.installPath)
+            if (-not [string]::Equals($statePath, $path, [StringComparison]::OrdinalIgnoreCase)) {
+                $state = $null
+            }
+        } catch {
+            Write-Note "Could not resolve the install state path: $($_.Exception.Message)" 'warn'
+            $state = $null
+        }
+    } elseif ($RequestedPath) {
+        $state = $null
+    }
+
+    $uninstallKey = 'HKCU:\Software\Microsoft\Windows\CurrentVersion\Uninstall\Luc_is1'
+    $registeredPath = $null
+    $registeredVersion = $null
+    try {
+        $registration = Get-ItemProperty -LiteralPath $uninstallKey -ErrorAction Stop
+        $registeredPath = [string]$registration.InstallLocation
+        $registeredVersion = [string]$registration.DisplayVersion
+    } catch { }
+    $registeredMatches = $false
+    if ($registeredPath) {
+        try {
+            $registeredMatches = [string]::Equals(
+                (Resolve-InstallPathValue $registeredPath), $path, [StringComparison]::OrdinalIgnoreCase)
+            if (-not $registeredMatches) { $registeredVersion = $null }
+        } catch {
+            Write-Note "Could not resolve the Windows installer path: $($_.Exception.Message)" 'warn'
+            $registeredPath = $null
+            $registeredVersion = $null
+        }
+    }
+    $innoStateMatches = $state -and $state.source -eq 'inno' -and $state.installPath
+
+    $rawComponents = @()
+    if ($state -and $state.components) {
+        $rawComponents = @($state.components)
+    } else {
+        $manifestFile = Join-Path $path '.luc-manifest.json'
+        if (Test-Path -LiteralPath $manifestFile -PathType Leaf) {
+            try {
+                $manifest = Get-Content -LiteralPath $manifestFile -Raw | ConvertFrom-Json -ErrorAction Stop
+                if ($manifest.components) { $rawComponents = @($manifest.components) }
+            } catch {
+                Write-Note "Could not read the install manifest: $($_.Exception.Message)" 'warn'
+            }
+        }
+    }
+    if ($rawComponents.Count -eq 0) {
+        if ($registeredMatches -or ($innoStateMatches -and -not $registeredPath)) {
+            try {
+                $saved = (Get-ItemProperty -LiteralPath 'HKCU:\Software\LUC' -Name Components -ErrorAction Stop).Components
+                if ($saved) { $rawComponents = @([string]$saved -split '[,\s]+') }
+            } catch { }
+        }
+    }
+
+    $components = @()
+    foreach ($name in $rawComponents) {
+        $name = ([string]$name).ToLowerInvariant()
+        if ($name -eq 'ailib') { $name = 'ai' }
+        if ($optionalComponents -contains $name -and $components -notcontains $name) {
+            $components += $name
+        }
+    }
+
+    $uninstaller = $null
+    if ($innoStateMatches -or $registeredMatches) {
+        $uninstaller = Get-ChildItem -LiteralPath $path -Filter 'unins*.exe' -File -ErrorAction SilentlyContinue |
+            Select-Object -First 1
+    }
+    return [pscustomobject]@{
+        Path        = $path
+        Version     = if ($state -and $state.version) { [string]$state.version } elseif ($registeredVersion) { $registeredVersion } else { 'unknown' }
+        Components  = $components
+        Uninstaller = $uninstaller
+    }
+}
+
+function Show-MaintenancePage {
+    param($Install)
+
+    $items = @(
+        @{ Action = 'libraries'; Label = 'Install libraries'; Desc = 'Add or remove optional components' },
+        @{ Action = 'repair';    Label = 'Fix / reinstall';   Desc = 'Reinstall the current components' }
+    )
+    if ($Install.Uninstaller) {
+        $items += @{ Action = 'uninstall'; Label = 'Uninstall'; Desc = 'Remove LUC from this computer' }
+    }
+    $items += @{ Action = 'cancel'; Label = 'Cancel'; Desc = 'Exit without making changes' }
+    $index = 0
+    while ($true) {
+        Clear-Tui
+        Write-TuiHeader 'LUC is installed' 'Choose an action'
+        Write-Tui ("  Version   {0}" -f $Install.Version)
+        Write-Tui ("  Folder    {0}" -f $Install.Path) '90'
+        Write-Tui ''
+        for ($i = 0; $i -lt $items.Count; $i++) {
+            $marker = if ($i -eq $index) { '>' } else { ' ' }
+            $code = if ($i -eq $index) { '1;36' } else { '' }
+            Write-Tui ("  $marker " + $items[$i].Label) $code
+            Write-Tui ("      " + $items[$i].Desc) '90'
+            Write-Tui ''
+        }
+        Write-TuiFooter 'Up/Down move   Enter select   q quit'
+        $key = [Console]::ReadKey($true)
+        switch ($key.Key) {
+            'UpArrow'   { $index = ($index - 1 + $items.Count) % $items.Count }
+            'DownArrow' { $index = ($index + 1) % $items.Count }
+            'Enter'     { return $items[$index].Action }
+            'Escape'    { return 'cancel' }
+            'Q'         { return 'cancel' }
+        }
+    }
+}
+
+function Start-InnoUninstaller {
+    param($Install)
+    if (-not $Install.Uninstaller) { throw 'The Windows installer uninstaller was not found.' }
+    Start-Process -FilePath $Install.Uninstaller.FullName -ArgumentList '/NORESTART' | Out-Null
+}
+
 function Show-LicenseEntry {
     param([string]$LicenseText)
     Show-LicensePage $LicenseText
@@ -846,7 +997,7 @@ public static extern bool MoveFileEx(string existingFileName, string newFileName
 }
 
 function Install-ArchivePlan {
-    param([object[]]$Items)
+    param([object[]]$Items, [string[]]$RemovePaths = @())
     $journal = New-Object System.Collections.ArrayList
     try {
         foreach ($item in $Items) {
@@ -865,6 +1016,13 @@ function Install-ArchivePlan {
             try { Move-Item -LiteralPath $item.Staging -Destination $destination -Force }
             catch { throw "Cannot write '$destination': $($_.Exception.Message)" }
         }
+        foreach ($destination in $RemovePaths) {
+            if (-not (Test-Path -LiteralPath $destination -PathType Leaf)) { continue }
+            $old = "$destination.luc-old-$([guid]::NewGuid().ToString('N').Substring(0, 8))"
+            try { Move-Item -LiteralPath $destination -Destination $old -Force }
+            catch { throw "Cannot remove '$destination'. Close the program using it and try again." }
+            [void]$journal.Add([pscustomobject]@{ Destination = $destination; Old = $old })
+        }
     } catch {
         $failure = $_
         for ($i = $journal.Count - 1; $i -ge 0; $i--) {
@@ -966,6 +1124,26 @@ $downloadTemp = $null
 $tempChecksumFile = $null
 $zip = $null
 try {
+    if ($script:Interactive -and -not $LCodeOnly -and -not $Components) {
+        $script:ExistingInstall = Get-InstalledDetails -RequestedPath $InstallPath
+        if ($script:ExistingInstall) {
+            Enter-AltScreen
+            $script:MaintenanceAction = Show-MaintenancePage $script:ExistingInstall
+            Exit-AltScreen
+            if ($script:MaintenanceAction -eq 'cancel') {
+                Write-Note 'Installation cancelled.' 'warn'
+                exit 2
+            }
+            if ($script:MaintenanceAction -eq 'uninstall') {
+                Start-InnoUninstaller $script:ExistingInstall
+                Write-Note 'LUC uninstaller started.' 'ok'
+                exit 0
+            }
+            $InstallPath = $script:ExistingInstall.Path
+            $script:ExistingComponents = @($script:ExistingInstall.Components)
+        }
+    }
+
     $sourceSpecified = $PSBoundParameters.ContainsKey('Source')
     if (-not $Source) {
         if ($ArchivePath) { $Source = 'local' } else { $Source = 'github' }
@@ -1081,7 +1259,13 @@ try {
     $licenseText = Read-ZipEntryText $zip 'LICENCE'
     if (-not $licenseText) { $licenseText = 'LUC is free software released under the Apache License 2.0.' }
 
-    $selected = if ($LCodeOnly) { @('lcode') } else { @() }
+    if ($LCodeOnly) {
+        $selected = @('lcode')
+    } elseif ($script:MaintenanceAction -ne 'install') {
+        $selected = @($script:ExistingComponents)
+    } else {
+        $selected = @()
+    }
     if (-not $LCodeOnly -and $Components) {
         foreach ($item in $Components) {
             foreach ($name in ($item -split '[,\s]+')) {
@@ -1094,7 +1278,8 @@ try {
         }
     }
 
-    if (-not $LCodeOnly -and $script:Interactive -and -not $Components) {
+    if (-not $LCodeOnly -and $script:Interactive -and -not $Components -and
+        $script:MaintenanceAction -ne 'repair') {
         Enter-AltScreen
         $picked = Show-ComponentPage -Preselected $selected -LicenseText $licenseText
         Exit-AltScreen
@@ -1115,6 +1300,14 @@ try {
         $InstallPath = Resolve-InstallPathValue $InstallPath
     }
 
+    if (-not $script:ExistingInstall -or
+        -not [string]::Equals($script:ExistingInstall.Path, $InstallPath, [StringComparison]::OrdinalIgnoreCase)) {
+        $script:ExistingInstall = Get-InstalledDetails -RequestedPath $InstallPath
+    }
+    if ($script:ExistingInstall) {
+        $script:ExistingComponents = @($script:ExistingInstall.Components)
+    }
+
     $vsCodeTarget = Join-Path $env:USERPROFILE '.vscode\extensions\hsusulist.luc'
     $binaryName = if ($LCodeOnly) { 'lcode.exe' } else { 'luc.exe' }
     $upgrade = Test-Path -LiteralPath (Join-Path $InstallPath $binaryName) -PathType Leaf
@@ -1140,6 +1333,10 @@ try {
             Exit-AltScreen
             if ($null -eq $picked -or -not $InstallPath) { Write-Note 'Installation cancelled.' 'warn'; exit 2 }
             $selected = @($picked)
+            $InstallPath = Resolve-InstallPathValue $InstallPath
+            $script:ExistingInstall = Get-InstalledDetails -RequestedPath $InstallPath
+            $script:ExistingComponents = if ($script:ExistingInstall) { @($script:ExistingInstall.Components) } else { @() }
+            $upgrade = Test-Path -LiteralPath (Join-Path $InstallPath $binaryName) -PathType Leaf
         }
     }
 
@@ -1149,10 +1346,24 @@ try {
         throw "Installation archive did not produce $binaryName."
     }
 
+    $removePaths = @()
+    if ($upgrade -and -not $LCodeOnly -and $script:ExistingComponents.Count -gt 0) {
+        $previousPlan = Get-ArchivePlan -Zip $zip -SelectedComponents $script:ExistingComponents -Target $InstallPath -VsCodeTarget $vsCodeTarget
+        $newDestinations = @{}
+        foreach ($item in $archivePlan.Items) { $newDestinations[$item.Destination.ToLowerInvariant()] = $true }
+        foreach ($item in $previousPlan.Items) {
+            if (-not $newDestinations.ContainsKey($item.Destination.ToLowerInvariant()) -and
+                (Test-Path -LiteralPath $item.Destination -PathType Leaf)) {
+                $removePaths += $item.Destination
+            }
+        }
+    }
+
     $roots = @($InstallPath)
-    if ($selected -contains 'vscode') { $roots += $vsCodeTarget }
+    if (($selected -contains 'vscode') -or ($script:ExistingComponents -contains 'vscode')) { $roots += $vsCodeTarget }
+    $lockItems = @($archivePlan.Items) + @($removePaths | ForEach-Object { @{ Destination = $_ } })
     Write-Step 'Checking for running programs and locked files'
-    Test-InstallLocks -Items $archivePlan.Items -Roots $roots
+    Test-InstallLocks -Items $lockItems -Roots $roots
     Write-StepDone 'No running LUC process blocks the install'
 
     Test-DiskSpace $InstallPath $archivePlan.TotalBytes
@@ -1165,17 +1376,19 @@ try {
     Write-StepDone "Extracted $($archivePlan.Items.Count) files"
 
     Write-Step 'Installing files'
-    Install-ArchivePlan $archivePlan.Items
-    Write-StepDone 'Files installed'
+    Install-ArchivePlan -Items $archivePlan.Items -RemovePaths $removePaths
+    if ($removePaths.Count) { Write-StepDone "Files installed; removed $($removePaths.Count) deselected files" }
+    else { Write-StepDone 'Files installed' }
 
     if (-not (Test-Path -LiteralPath (Join-Path $InstallPath $binaryName) -PathType Leaf)) {
         throw "Installation finished without $binaryName. The previous version was restored."
     }
 
     Write-InstallManifest $script:Version $InstallPath $selected -LCodeOnly:$LCodeOnly
-    Write-InstallState $script:Version $InstallPath $selected $Source -LCodeOnly:$LCodeOnly
+    $stateSource = if ($script:ExistingInstall -and $script:ExistingInstall.Uninstaller) { 'inno' } else { $Source }
+    Write-InstallState $script:Version $InstallPath $selected $stateSource -LCodeOnly:$LCodeOnly
 
-    # Keep a copy of this script next to luc.exe so that "luc --install" works
+    # Keep a copy of this script next to luc.exe so that "luc install" works
     # even when the archive was built before install.ps1 was bundled in it.
     if (-not $LCodeOnly) {
         try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hsusulist/luc",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "description": "LUC language installer and launcher",
   "bin": {
     "luc": "bin/luc.js"

package/scripts/postinstall.js

@@ -41,7 +41,7 @@ if (process.platform !== 'win32' || findBinary()) {
 
 const script = path.join(__dirname, '..', 'install.ps1');
 if (!fs.existsSync(script)) {
-  console.warn('luc: install.ps1 is missing; run "luc --install" after installing.');
+  console.warn('luc: install.ps1 is missing; run "luc install" after installing.');
   process.exit(0);
 }
 
@@ -53,6 +53,6 @@ const result = spawnSync(
 );
 
 if (result.error || result.status !== 0) {
-  console.warn('luc: automatic install did not finish. Run "luc --install" to open the installer.');
+  console.warn('luc: automatic install did not finish. Run "luc install" to open the installer.');
 }
 process.exit(0);

package/scripts/prepack.js

@@ -24,7 +24,7 @@ if (fs.existsSync(target)) {
   throw new Error('refusing to overwrite existing npm/src directory');
 }
 fs.mkdirSync(target);
-for (const name of ['luc_core.c', 'luc_libs.c', 'luc_trans.c', 'luc.h']) {
+for (const name of ['luc_core.c', 'luc_libs.c', 'luc_nums.c', 'luc_trans.c', 'luc.h']) {
   const from = path.join(source, name);
   if (!fs.existsSync(from)) throw new Error('missing release source: ' + from);
   fs.copyFileSync(from, path.join(target, name));

package/src/lcode-linux/lcode.c

@@ -63,6 +63,298 @@ static void lc_linux_insert(LcLinuxEditor *e, char c) {
     e->dirty = 1;
 }
 
+static int lc_linux_word_char(unsigned char c) {
+    return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') ||
+           (c >= '0' && c <= '9') || c == '_';
+}
+
+static unsigned char lc_linux_lower(unsigned char c) {
+    return c >= 'A' && c <= 'Z' ? (unsigned char)(c + ('a' - 'A')) : c;
+}
+
+static int lc_linux_starts_word(const char *s, const char *word) {
+    size_t i = 0;
+    while (*s == ' ' || *s == '\t') s++;
+    while (word[i] && lc_linux_lower((unsigned char)s[i]) == lc_linux_lower((unsigned char)word[i])) i++;
+    return word[i] == 0 && !lc_linux_word_char((unsigned char)s[i]);
+}
+
+static int lc_linux_ends_word(const char *s, const char *word) {
+    size_t n = strlen(s), m = strlen(word), i;
+    while (n && (s[n - 1] == ' ' || s[n - 1] == '\t')) n--;
+    if (n < m) return 0;
+    for (i = 0; i < m; i++) {
+        if (lc_linux_lower((unsigned char)s[n - m + i]) != lc_linux_lower((unsigned char)word[i])) return 0;
+    }
+    return n == m || !lc_linux_word_char((unsigned char)s[n - m - 1]);
+}
+
+static int lc_linux_has_word(const char *s, const char *word) {
+    size_t i, n = strlen(s), m = strlen(word), j;
+    if (!m || m > n) return 0;
+    for (i = 0; i + m <= n; i++) {
+        if (i && lc_linux_word_char((unsigned char)s[i - 1])) continue;
+        if (i + m < n && lc_linux_word_char((unsigned char)s[i + m])) continue;
+        for (j = 0; j < m; j++) {
+            if (lc_linux_lower((unsigned char)s[i + j]) != lc_linux_lower((unsigned char)word[j])) break;
+        }
+        if (j == m) return 1;
+    }
+    return 0;
+}
+
+static int lc_linux_ext(const char *path, const char *ext) {
+    const char *dot = strrchr(path, '.');
+    size_t i, n = strlen(ext);
+    if (!dot || strlen(dot + 1) != n) return 0;
+    for (i = 0; i < n; i++) {
+        if (lc_linux_lower((unsigned char)dot[i + 1]) != lc_linux_lower((unsigned char)ext[i])) return 0;
+    }
+    return 1;
+}
+
+static void lc_linux_strip_comment(char *s, const char *path) {
+    int quote = 0, escape = 0;
+    int hash = lc_linux_ext(path, "py") || lc_linux_ext(path, "sh") ||
+               lc_linux_ext(path, "bash") || lc_linux_ext(path, "zsh") ||
+               lc_linux_ext(path, "rb") || lc_linux_ext(path, "pl") ||
+               lc_linux_ext(path, "r") || lc_linux_ext(path, "yaml") ||
+               lc_linux_ext(path, "yml");
+    int dash = !path[0] || lc_linux_ext(path, "luc") || lc_linux_ext(path, "lua") ||
+               lc_linux_ext(path, "sql");
+    int slash = lc_linux_ext(path, "c") || lc_linux_ext(path, "h") ||
+                lc_linux_ext(path, "cpp") || lc_linux_ext(path, "hpp") ||
+                lc_linux_ext(path, "cc") || lc_linux_ext(path, "cxx") ||
+                lc_linux_ext(path, "js") || lc_linux_ext(path, "ts") ||
+                lc_linux_ext(path, "java") || lc_linux_ext(path, "go") ||
+                lc_linux_ext(path, "rs") || lc_linux_ext(path, "cs") ||
+                lc_linux_ext(path, "kt") || lc_linux_ext(path, "swift") ||
+                lc_linux_ext(path, "dart") || lc_linux_ext(path, "scala") ||
+                lc_linux_ext(path, "php") || lc_linux_ext(path, "css") ||
+                lc_linux_ext(path, "scss") || lc_linux_ext(path, "less") ||
+                lc_linux_ext(path, "tf") || lc_linux_ext(path, "hcl");
+    size_t i, n = strlen(s);
+    for (i = 0; i < n; i++) {
+        unsigned char c = (unsigned char)s[i];
+        if (quote) {
+            if (escape) escape = 0;
+            else if (c == '\\') escape = 1;
+            else if (c == (unsigned char)quote) quote = 0;
+            continue;
+        }
+        if (c == '\'' || c == '"' || c == '`') { quote = c; continue; }
+        if (hash && c == '#') { s[i] = 0; return; }
+        if (dash && c == '-' && s[i + 1] == '-') { s[i] = 0; return; }
+        if (slash && c == '/' && s[i + 1] == '/') { s[i] = 0; return; }
+        if (slash && c == '/' && s[i + 1] == '*') { s[i] = 0; return; }
+    }
+}
+
+static int lc_linux_html_block(const char *s, char *closer, size_t cap) {
+    static const char *voids[] = {
+        "area", "base", "br", "col", "embed", "hr", "img", "input",
+        "link", "meta", "param", "source", "track", "wbr", NULL
+    };
+    char tag[128];
+    size_t n = strlen(s), i = 1, j = 0, k;
+    if (n < 3 || s[0] != '<' || s[1] == '/' || s[1] == '!' ||
+        s[1] == '?' || s[n - 1] != '>') return 0;
+    while (i < n - 1 && ((s[i] >= 'a' && s[i] <= 'z') ||
+           (s[i] >= 'A' && s[i] <= 'Z') || (s[i] >= '0' && s[i] <= '9') ||
+           s[i] == ':' || s[i] == '-')) {
+        if (j + 1 >= sizeof tag) return 0;
+        tag[j++] = s[i++];
+    }
+    if (!j || s[n - 2] == '/') return 0;
+    tag[j] = 0;
+    for (k = 0; voids[k]; k++) {
+        size_t a = strlen(tag), b = strlen(voids[k]), x;
+        if (a != b) continue;
+        for (x = 0; x < a; x++) {
+            if (lc_linux_lower((unsigned char)tag[x]) != lc_linux_lower((unsigned char)voids[k][x])) break;
+        }
+        if (x == a) return 0;
+    }
+    return snprintf(closer, cap, "</%s>", tag) < (int)cap;
+}
+
+static int lc_linux_block(const char *path, char *code, char *closer, size_t cap) {
+    static const char *py_blocks[] = {
+        "if", "elif", "else", "for", "while", "def", "class", "try",
+        "except", "finally", "with", "match", "case", NULL
+    };
+    static const char *end_blocks[] = {
+        "def", "class", "module", "if", "unless", "while", "until",
+        "for", "begin", "case", NULL
+    };
+    size_t n = strlen(code), i;
+    const char *p = code;
+    closer[0] = 0;
+    while (n && (code[n - 1] == ' ' || code[n - 1] == '\t' || code[n - 1] == '\r')) code[--n] = 0;
+    if (!n) return 0;
+    if (code[n - 1] == '{') return snprintf(closer, cap, "}") < (int)cap;
+    if ((lc_linux_ext(path, "json") || lc_linux_ext(path, "js") ||
+         lc_linux_ext(path, "py") || lc_linux_ext(path, "c") ||
+         lc_linux_ext(path, "h") || lc_linux_ext(path, "go") ||
+         lc_linux_ext(path, "rs") || lc_linux_ext(path, "java") ||
+         lc_linux_ext(path, "cs") || lc_linux_ext(path, "ts") ||
+         lc_linux_ext(path, "php")) && code[n - 1] == '[') {
+        return snprintf(closer, cap, "]") < (int)cap;
+    }
+    if (lc_linux_ext(path, "html") || lc_linux_ext(path, "htm") ||
+        lc_linux_ext(path, "xml") || lc_linux_ext(path, "svg")) {
+        return lc_linux_html_block(code, closer, cap);
+    }
+    if (lc_linux_ext(path, "py")) {
+        if (code[n - 1] != ':') return 0;
+        if (lc_linux_starts_word(p, "async")) {
+            p += 5;
+            while (*p == ' ' || *p == '\t') p++;
+        }
+        for (i = 0; py_blocks[i]; i++) if (lc_linux_starts_word(p, py_blocks[i])) return 1;
+        return 0;
+    }
+    if (lc_linux_ext(path, "yaml") || lc_linux_ext(path, "yml")) return code[n - 1] == ':';
+    if (!path[0] || lc_linux_ext(path, "luc") || lc_linux_ext(path, "lua")) {
+        if (lc_linux_starts_word(code, "else") || lc_linux_starts_word(code, "elseif")) return 1;
+        if (lc_linux_ext(path, "lua") && lc_linux_ends_word(code, "repeat")) {
+            return snprintf(closer, cap, "until") < (int)cap;
+        }
+        if (lc_linux_ends_word(code, "then") || lc_linux_ends_word(code, "do") ||
+            (lc_linux_has_word(code, "function") && code[n - 1] == ')') ||
+            (lc_linux_starts_word(code, "command") && code[n - 1] == ')')) {
+            return snprintf(closer, cap, "end") < (int)cap;
+        }
+        return 0;
+    }
+    if (lc_linux_ext(path, "rb") || lc_linux_ext(path, "pl")) {
+        if (lc_linux_starts_word(code, "else") || lc_linux_starts_word(code, "elsif") ||
+            lc_linux_starts_word(code, "when") || lc_linux_starts_word(code, "rescue") ||
+            lc_linux_starts_word(code, "ensure") || lc_linux_starts_word(code, "continue")) return 1;
+        for (i = 0; end_blocks[i]; i++) {
+            if (lc_linux_starts_word(code, end_blocks[i])) return snprintf(closer, cap, "end") < (int)cap;
+        }
+        if (lc_linux_ends_word(code, "do") || lc_linux_has_word(code, "do")) {
+            return snprintf(closer, cap, "end") < (int)cap;
+        }
+        if ((lc_linux_ext(path, "pl") && lc_linux_starts_word(code, "sub")) ||
+            (lc_linux_ext(path, "rb") && lc_linux_starts_word(code, "def"))) {
+            return snprintf(closer, cap, "end") < (int)cap;
+        }
+    }
+    if (lc_linux_ext(path, "sh") || lc_linux_ext(path, "bash") || lc_linux_ext(path, "zsh")) {
+        if (lc_linux_starts_word(code, "else") || lc_linux_starts_word(code, "elif")) return 1;
+        if (lc_linux_starts_word(code, "case") && lc_linux_ends_word(code, "in")) {
+            return snprintf(closer, cap, "esac") < (int)cap;
+        }
+        if (lc_linux_ends_word(code, "then")) return snprintf(closer, cap, "fi") < (int)cap;
+        if (lc_linux_ends_word(code, "do")) return snprintf(closer, cap, "done") < (int)cap;
+    }
+    if (lc_linux_ext(path, "sql")) {
+        if (lc_linux_starts_word(code, "else") || lc_linux_starts_word(code, "when")) return 1;
+        if (lc_linux_ends_word(code, "case") || lc_linux_ends_word(code, "begin")) {
+            return snprintf(closer, cap, "END;") < (int)cap;
+        }
+        if (lc_linux_ends_word(code, "then")) {
+            return snprintf(closer, cap, lc_linux_has_word(code, "if") ? "END IF;" : "END;") < (int)cap;
+        }
+        if (lc_linux_ends_word(code, "loop")) return snprintf(closer, cap, "END LOOP;") < (int)cap;
+    }
+    return 0;
+}
+
+static int lc_linux_tail_closer(const char *tail, const char *closer) {
+    size_t i = 0, j, n = strlen(tail), m = strlen(closer);
+    while (i < n && (tail[i] == ' ' || tail[i] == '\t' || tail[i] == '\r')) i++;
+    if (n - i < m) return 0;
+    for (j = 0; j < m; j++) {
+        if (lc_linux_lower((unsigned char)tail[i + j]) != lc_linux_lower((unsigned char)closer[j])) return 0;
+    }
+    i += m;
+    while (i < n && (tail[i] == ' ' || tail[i] == '\t' || tail[i] == '\r')) i++;
+    if (i < n && tail[i] == ';') i++;
+    while (i < n && (tail[i] == ' ' || tail[i] == '\t' || tail[i] == '\r')) i++;
+    return i == n;
+}
+
+static void lc_linux_newline(LcLinuxEditor *e) {
+    size_t start = lc_linux_line_start(e, e->cursor);
+    size_t end = lc_linux_line_end(e, e->cursor);
+    size_t prefix_len = e->cursor - start, tail_len = end - e->cursor;
+    size_t base_len = 0, inner_len, close_len = 0, i, insert_len;
+    char closer[256], *prefix, *code_buf, *code, *tail, *base, *insert;
+    int block, has_closer, tail_blank = 1, make_closer;
+    const char *path = e->path;
+    prefix = (char *)malloc(prefix_len + 1);
+    code_buf = (char *)malloc(prefix_len + 1);
+    tail = (char *)malloc(tail_len + 1);
+    if (!prefix || !code_buf || !tail) {
+        free(prefix); free(code_buf); free(tail);
+        snprintf(e->status, sizeof e->status, "out of memory");
+        return;
+    }
+    memcpy(prefix, e->data + start, prefix_len); prefix[prefix_len] = 0;
+    memcpy(code_buf, prefix, prefix_len + 1); code = code_buf;
+    memcpy(tail, e->data + e->cursor, tail_len); tail[tail_len] = 0;
+    lc_linux_strip_comment(code, path);
+    while (*code == ' ' || *code == '\t') code++;
+    block = lc_linux_block(path, code, closer, sizeof closer);
+    while (e->data[start + base_len] == ' ' || e->data[start + base_len] == '\t') base_len++;
+    base = (char *)malloc(base_len + 1);
+    if (!base) {
+        free(prefix); free(code_buf); free(tail);
+        snprintf(e->status, sizeof e->status, "out of memory");
+        return;
+    }
+    memcpy(base, e->data + start, base_len); base[base_len] = 0;
+    for (i = 0; i < tail_len; i++) {
+        if (tail[i] != ' ' && tail[i] != '\t' && tail[i] != '\r') { tail_blank = 0; break; }
+    }
+    has_closer = block && closer[0] && lc_linux_tail_closer(tail, closer);
+    if (block && !tail_blank && !has_closer) block = 0;
+    make_closer = block && closer[0];
+    inner_len = base_len + (block ? 4 : 0);
+    insert_len = 1 + inner_len;
+    if (make_closer) {
+        if (has_closer) {
+            size_t first = 0, last = tail_len;
+            while (first < last && (tail[first] == ' ' || tail[first] == '\t' || tail[first] == '\r')) first++;
+            while (last > first && (tail[last - 1] == ' ' || tail[last - 1] == '\t' || tail[last - 1] == '\r')) last--;
+            close_len = last - first;
+            memmove(tail, tail + first, close_len);
+        } else {
+            close_len = strlen(closer);
+        }
+        insert_len += 1 + base_len + close_len;
+    }
+    insert = (char *)malloc(insert_len);
+    if (!insert || !lc_linux_reserve(e, insert_len)) {
+        free(prefix); free(code_buf); free(tail); free(base); free(insert);
+        snprintf(e->status, sizeof e->status, "out of memory");
+        return;
+    }
+    i = 0;
+    insert[i++] = '\n';
+    memcpy(insert + i, base, base_len); i += base_len;
+    if (block) { memcpy(insert + i, "    ", 4); i += 4; }
+    if (make_closer) {
+        insert[i++] = '\n';
+        memcpy(insert + i, base, base_len); i += base_len;
+        memcpy(insert + i, has_closer ? tail : closer, close_len); i += close_len;
+    }
+    if (block && tail_len) {
+        memmove(e->data + e->cursor, e->data + end, e->len - end + 1);
+        e->len -= tail_len;
+    }
+    memmove(e->data + e->cursor + insert_len, e->data + e->cursor,
+            e->len - e->cursor + 1);
+    memcpy(e->data + e->cursor, insert, insert_len);
+    e->cursor += 1 + inner_len;
+    e->len += insert_len;
+    e->dirty = 1;
+    free(prefix); free(code_buf); free(tail); free(base); free(insert);
+}
+
 static int lc_linux_save(LcLinuxEditor *e) {
     FILE *f;
     if (!e->path[0]) {
@@ -116,7 +408,7 @@ static void lc_linux_draw(const LcLinuxEditor *e, size_t top, int rows, int cols
     size_t line = 0, i = 0, cursor_line, cursor_col = 0, scan = 0;
     int row = 0;
     cursor_line = lc_linux_line_number(e, e->cursor);
-    while (scan < e.cursor && e->data[scan] != '\n') { cursor_col++; scan++; }
+    while (scan < e->cursor && e->data[scan] != '\n') { cursor_col++; scan++; }
 
     printf("\x1b[H\x1b[2J");
     while (row < rows - 1 && i < e->len + 1) {
@@ -271,7 +563,7 @@ static void lc_code(const char *start) {
                 e.dirty = 1;
             }
         } else if (key == 13) {
-            lc_linux_insert(&e, '\n');
+            lc_linux_newline(&e);
         } else if (key >= 32 && key <= 255) {
             lc_linux_insert(&e, (char)key);
         }