Plug-in LSP (taalserver)¶

Code-intelligentie aangedreven door het Language Server Protocol — golflijnen bij fouten, navigatie, aanwijshulp, aanvulling, handtekeninghulp, opmaak, verwijzingen zoeken, naam wijzigen en ga naar symbool — voor elke taal die een taalserver heeft. De editor praat met de server over LSP; de plug-in is de cliënt. Welke servers er bestaan is gegevensgestuurd (één klein JSON-bestand per taal), dus C++/clangd hieronder is slechts een van verschillende meegeleverde definities.

De editor levert geen servers mee en downloadt ze niet

Een taalserver is een apart programma dat u één keer installeert. MTE herkent een geïnstalleerde server en wijst hem naar uw project; hij levert er nooit een mee. Zie Een taalserver bemachtigen.

Huidige functies¶

Functie	Hoe
Diagnostiek	Fouten en waarschuwingen van de server verschijnen als golvende onderstrepingen (rood = fout, amber = waarschuwing, blauw = informatie, grijs = hint), bijgewerkt terwijl u typt.
Ga naar definitie	Zet de cursor op een symbool en druk op F12, of gebruik Zoeken ▸ Codenavigatie ▸ Ga naar definitie. Springt naar de definitie en opent zo nodig een ander bestand.
Verwijzingen zoeken	Cursor op een symbool → Shift+F12 (of Zoeken ▸ Codenavigatie ▸ Verwijzingen zoeken). De resultaten openen in een onderpaneel Verwijzingen, gegroepeerd per bestand met een voorbeeld van de bronregel; dubbelklik om ernaartoe te springen.
Aanwijshulp	Laat de aanwijzer op een symbool rusten; een pop-up toont het type of de handtekening en de documentatie (weergegeven uit de Markdown van de server).
Aanvulling	Ctrl+Space vraagt aanvullingen aan de server en voegt ze in de aanvulpop-up van de editor (vóór de ingebouwde suggesties uit trefwoorden en buffer), gefilterd terwijl u typt.
Handtekeninghulp	De `(` of een `,` van een aanroep typen toont een aanroephulp met de handtekening van de functie en de actieve parameter gemarkeerd; `)` sluit hem.
Document opmaken	Alt+Shift+F (`⌃⌥F` op macOS; of Bewerken ▸ Document opmaken) maakt het hele document via de server opnieuw op, in één stap ongedaan maken. De stijl wordt door de eigen configuratie van de server bepaald (voor clangd een bestand `.clang-format`).
Verwijzingen zoeken (hierboven vermeld)	—
Symboolnaam wijzigen	Cursor op een symbool → Shift+F6 (of Bewerken ▸ Symboolnaam wijzigen). Voer een nieuwe naam in; elk gebruik wordt bijgewerkt. Strekt de naamswijziging zich over meerdere bestanden uit, dan wordt u eerst om bevestiging gevraagd — elk bestand wordt geopend, gewijzigd en als gewijzigd achtergelaten zodat u het kunt nakijken en opslaan.
Ga naar symbool (in bestand)	Ctrl+Shift+O opent het Opdrachtenpalet met elk symbool in het huidige bestand (functies, klassen, methoden…); typ om te filteren, Enter springt ernaartoe. Elke rij toont de soort van het symbool en de houder ervan.
Ga naar symbool in de werkruimte	Ctrl+T doorzoekt symbolen in het hele project terwijl u typt (de server vergelijkt de zoekterm); Enter opent het bestand bij het symbool.

De keuzelijsten voor ga-naar-symbool zijn de symboolmodi van het Opdrachtenpalet — zie Opdrachtenpalet.

De opdrachten zijn grijs totdat er een server draait

Ga naar definitie, Verwijzingen zoeken, Document opmaken en Symboolnaam wijzigen zijn alleen ingeschakeld wanneer een taalserver voor de taal van het huidige bestand Gereed is — en wanneer die server in zijn handdruk meldde dat hij het verzoek ondersteunt. Bij een bestand zonder ingestelde server, of terwijl er een start, herstart of het heeft opgegeven, zijn de menu-items grijs in plaats van dat ze bij het indrukken niets doen. De statusaanduiding hieronder vertelt u welk geval het is. Taalservers opnieuw starten is nooit grijs: dat is de uitweg uit een server die het heeft opgegeven.

Verwijzingen en naamswijzigingen over bestanden heen hebben de index van de server nodig

Verwijzingen zoeken en Naam wijzigen bereiken andere bestanden pas zodra de server het project geïndexeerd heeft. Voor C/C++ betekent dat een compile_commands.json (zie hieronder) en de achtergrondindex van clangd; zonder die werken ze alleen op het huidige bestand.

Naam wijzigen is voorlopig per bestand ongedaan te maken

Een naamswijziging over meerdere bestanden wordt bestand voor bestand toegepast, dus elk bestand is zijn eigen stap ongedaan maken (het bevestigingsvenster zegt dat). Kijk de gewijzigde tabbladen na voordat u opslaat.

Klik met de rechtermuisknop op een symbool in de tekst en het menu biedt onder de bewerkingsopdrachten Ga naar definitie, Verwijzingen zoeken, Symboolnaam wijzigen en Document opmaken aan. Elk ervan verschijnt alleen als dezelfde opdracht in het hoofdmenu op dat moment zou werken — er is een taalserver voor het bestand gereed die haar ondersteunt, en voor naamwijzigen en opmaken is het document niet alleen-lezen. In een bestand met platte tekst, in de marge links van de tekst of terwijl de server opstart, verschijnt geen ervan.

De items werken op het symbool waarop u met de rechtermuisknop klikte, niet op dat onder de cursor; cursor en selectie blijven waar ze waren. Naamwijzigen stelt de selectie als oude naam voor als u erbinnen klikte, en anders het woord onder de aanwijzer. Document opmaken maakt altijd het hele document op. Een menu dat via het toetsenbord is geopend, werkt op de cursorpositie.

Waar het platform sneltoetsen in contextmenu's toont (Windows), toont elk item zijn sneltoets — de sneltoets die geldt, inclusief uw eigen wijzigingen in Sneltoetsen toewijzen. Op macOS tonen contextmenu's geen sneltoetsen.

Hoe uw bewerkingen de server bereiken¶

Typen verstuurt niet per toetsaanslag een bericht. Bewerkingen worden een fractie van een seconde samengevoegd en dan als één wijziging verstuurd — en als één bewerkt bereik in plaats van het hele bestand, wanneer de server zegt dat hij dat aankan (de meeste kunnen dat). Een groot bestand kost daardoor een paar tientallen bytes per typuitbarsting in plaats van een kopie van zichzelf.

Alles wat de server iets over de tekst vraagt — aanwijshulp, ga naar definitie, verwijzingen zoeken, naam wijzigen, opmaken, aanvulling, handtekeninghulp — verstuurt eerst de hangende bewerking, zodat een antwoord nooit naar een versie verwijst die u al voorbij bent. Een bestand opslaan doet hetzelfde.

Een server starten blokkeert de editor evenmin: het proces wordt op de achtergrond gestart en het statussegment toont … totdat het zijn handdruk afgerond heeft. Een serverprogramma dat bij het starten blijft hangen kost u niets dan die taal.

Een plafond op hoeveel problemen er getekend worden

Er worden hoogstens 2000 golflijnen per document getekend. Daarboven is het bestand toch onleesbaar, en elke extra markering kost de editor echte tijd — dus wanneer een bestand er meer oplevert, worden de eerste 2000 getoond en zegt de statusbalk De eerste 2000 van N problemen in dit bestand worden getoond, in plaats van de telling stilletjes kleiner te laten lijken dan hij is. Meestal is het een teken dat de server verkeerd naar het bestand kijkt: een ontbrekende compilatiedatabase, of een gegenereerd bestand dat niet bedoeld is om op zichzelf te compileren.

De statusaanduiding van de server¶

De statusbalk toont een compact segment LSP: (links van de andere plug-insegmenten) dat elke taalserver samenvat die voor uw geopende bestanden van belang is:

LSP: cpp ✓ · no compile database  python ↻2  rust ✗

Teken	Betekenis
`…`	Bezig met starten — de server is gestart en voert de handdruk uit.
`✓`	Gereed — bedient verzoeken.
`↻n`	Bezig met herstarten — de server stopte onverwacht; automatische herstartpoging n staat gepland.
`✗`	Geen server geïnstalleerd voor deze taal. Installeer er een (zie hieronder) en kies dan Taalservers opnieuw starten.
`⚠`	Opgegeven — de server bleef crashen en de automatische herstarts zijn gestopt. Alleen een handmatige herstart wekt hem weer.

Een taal kan achter het teken een korte nadere aanduiding dragen — de server draait, en iets aan uw project beperkt nog steeds wat hij kan beantwoorden. Er wordt er telkens maar één getoond, de ernstigste eerst:

Nadere aanduiding	Betekenis
`· server not responding`	Meerdere verzoeken op rij bleven onbeantwoord. De server leeft maar zit vast; Logboek van de taalserver tonen, daarna Taalservers opnieuw starten. De aanduiding verdwijnt op het moment dat de server iets beantwoordt.
`· no compile database`	De C/C++-server draait maar kan alleen het bestand zien dat u open hebt staan — zie C/C++-projecten hebben `compile_commands.json` nodig.
`· no Cargo.toml`, `· no go.mod`, `· no tsconfig.json`, …	Het project heeft geen van de bestanden die deze server nodig heeft om het als project te begrijpen. Hij werkt nog steeds op het geopende bestand; antwoorden over bestanden heen blijven onvolledig totdat het bestand bestaat. De precieze naam is die welke de server het liefst wil — zie Wat elke server van uw project nodig heeft.

Het segment verschijnt wanneer het eerste document met een ingestelde taal opengaat, volgt alleen talen waarvoor u werkelijk documenten open hebt staan — het laatste bestand van een taal sluiten verwijdert het item ervan (een bestand heropenen brengt het meteen terug) — en verdwijnt helemaal wanneer er geen zo'n document meer over is.

Zoeken ▸ Codenavigatie ▸ Logboek van de taalserver tonen toont de meest recente uitvoer van elke draaiende server. Daar legt een server zichzelf uit: een ontbrekende toolchain, een onleesbaar configuratiebestand, een project dat hij weigerde te laden. Het venster is een gewoon venster waarvan u de grootte kunt wijzigen — elke taal is een kop die de server noemt die ervoor draait, de tekst is selecteerbaar, Kopiëren zet het hele logboek op het klembord, en de grootte die u het venster geeft wordt onthouden.

Als een server crasht¶

Een taalserver die onverwacht afsluit wordt automatisch herstart met een oplopende vertraging (1 s, 2 s, 4 s… met een plafond van 30 s). Terwijl dat gebeurt toont de aanduiding ↻n en meldt een bericht op de statusbalk de eerste crash. Na een geslaagde herstart worden uw geopende documenten opnieuw bij de server aangemeld en komt de diagnostiek uit zichzelf terug; verouderde golflijnen van de gestorven server worden meteen gewist. Het bewerken wordt nooit geblokkeerd.

Na 5 mislukte pogingen op rij geeft de plug-in het op: de aanduiding toont ✗, een bericht wijst u naar de instellingen, en de taal blijft donker totdat u hem handmatig herstart. Een server die ten minste een minuut goed draaide krijgt een verse reeks pogingen wanneer hij later crasht.

Handmatig herstarten — een van beide:

Zoeken ▸ Codenavigatie ▸ Taalservers opnieuw starten (geen standaardsneltoets; ook beschikbaar via het Opdrachtenpalet), of
de knop Opnieuw scannen / servers herstarten in Voorkeuren ▸ Taalserver.

Om te zien waarom een server ontevreden is voordat u hem herstart, gebruikt u Zoeken ▸ Codenavigatie ▸ Logboek van de taalserver tonen.

Beide breken elke server af, voeren de zoektocht met de huidige instellingen opnieuw uit en zetten het foutenbudget terug — gebruik ze na het installeren van een ontbrekende server of het repareren van een kapotte.

Een taalserver bemachtigen¶

Installeer de server voor uw taal en zorg dat hij in uw PATH staat (of stel een uitdrukkelijk pad in bij de instellingen). Wordt er geen gevonden, dan doet de functie eenvoudigweg niets voor die taal — de statusaanduiding toont ✗ en het logboek noteert eenmalig een aanwijzing, maar niets onderbreekt u.

MTE levert serverdefinities mee (niet de servers) voor veel talen, dus voor de meeste hoeft alleen de server geïnstalleerd te worden — geen JSON bewerken. De meegeleverde definities dekken C/C++, Objective-C, Python, Rust, Go, TypeScript, JavaScript, C#, Java, Kotlin, Swift, HTML, CSS/SCSS/Less, JSON, YAML en shellscripts.

Taal	Server	Waar u die vandaan haalt
C/C++	clangd	`winget install LLVM.LLVM` (Windows), het onderdeel «C++ Clang tools» in het installatieprogramma van Visual Studio, `brew install llvm` (macOS), of het pakket `clang-tools-extra` van uw distributie.
Python	pyright of pylsp	`npm i -g pyright` (heeft Node.js nodig), of `pip install python-lsp-server` (heeft alleen Python nodig).
TypeScript/JS	typescript-language-server	`npm i -g typescript-language-server typescript`.
Rust	rust-analyzer	`rustup component add rust-analyzer`.
Go	gopls	`go install golang.org/x/tools/gopls@latest`.
C#	csharp-ls of OmniSharp	`dotnet tool install -g csharp-ls` (één dotnet-gereedschap, als eerste geprobeerd), of download een uitgave van OmniSharp.
Java	jdtls (Eclipse JDT Language Server)	`brew install jdtls` (macOS), of pak een uitgave uit en zet de `bin` ervan in uw `PATH`.

Controleer het in een terminal, bijvoorbeeld met clangd --version of where clangd / which clangd. Voor een taal waarvoor MTE geen definitie meelevert voegt u er zelf een toe, zoals beschreven in Een taal toevoegen.

Python: pyright of pylsp¶

Python heeft twee meegeleverde definities, en OctoEdit draait degene die werkelijk geïnstalleerd is:

pyright (pyright-langserver) wordt als eerste geprobeerd. Het is een npm-pakket, dus het heeft Node.js nodig: npm i -g pyright.
pylsp (python-lsp-server) wordt gebruikt wanneer pyright niet gevonden wordt. Het is een pip-pakket en heeft alleen Python nodig: pip install python-lsp-server.

Zijn beide geïnstalleerd, dan wint pyright. Er is één instellingenrij voor Python (één vlag om in te schakelen, één padoverschrijving), en die geldt voor de server die gebruikt wordt — een uitdrukkelijk pad naar een pylsp-programma instellen draait pylsp met diens startargumenten, niet die van pyright. Logboek van de taalserver tonen noemt de server die werkelijk draait.

Meerdere servers voor één taal

Dit is een algemeen mechanisme, geen bijzonder geval voor Python: een taal mag een willekeurig aantal meegeleverde definities hebben, geordend door een veld priority, en de eerste waarvan het programma op uw machine gevonden wordt is degene die start. C# werkt op dezelfde manier — csharp-ls als eerste, OmniSharp als tweede — omdat de twee verschillende startargumenten nemen en er maar één goed kan zijn.

Java: de eigen werkruimte van de server¶

jdtls weigert te starten zonder een eigen beschrijfbare werkruimtemap (-data). OctoEdit levert die automatisch, per project, onder zijn plug-ingegevensmap:

<user data>/plugins/org.mte.lsp/jdtls-workspaces/<project id>/

U hoeft die nooit te maken of te benoemen. De map verwijderen is veilig — jdtls bouwt hem opnieuw op, ten koste van één herindexering.

Opzetten op Windows¶

Een verse Windows-machine heeft doorgaans geen van clangd, cmake, ninja, node of python in zijn PATH. Dit onderdeel zegt waar elk ervan vandaan komt en hoe u het controleert. Normaal hoeft u het PATH niet zelf te bewerken — OctoEdit doorzoekt ook de ecosysteemmappen die hieronder opgesomd staan.

U wilt	Installeren	Waar het belandt
clangd (C/C++)	`winget install LLVM.LLVM`	`C:\Program Files\LLVM\bin\clangd.exe`
cmake en ninja	Het onderdeel «C++ CMake tools for Windows» in de Visual Studio Installer	`…\Microsoft Visual Studio\2022\<edition>\Common7\IDE\CommonExtensions\Microsoft\CMake\CMake\bin` en `…\CMake\Ninja` — niet in uw `PATH`, maar bereikbaar via de ontwikkelaarsomgeving van Visual Studio (zie hieronder). Een losstaande `winget install Kitware.CMake` / `winget install Ninja-build.Ninja` zet ze in plaats daarvan in het `PATH`.
pyright (Python)	`winget install OpenJS.NodeJS.LTS`, daarna `npm i -g pyright`	`%APPDATA%\npm\pyright-langserver.cmd`
pylsp (Python, geen Node nodig)	Python uit de Microsoft Store of van python.org, daarna `pip install python-lsp-server`	`%LOCALAPPDATA%\Packages\PythonSoftwareFoundation.Python.3._\LocalCache\local-packages\Python3\Scripts\pylsp.exe` (Store) of `%APPDATA%\Python\Python3\Scripts\pylsp.exe`

Nagaan wat er zichtbaar is. In een gewone opdrachtprompt of PowerShell:

where clangd
where cmake
where ninja
where pyright-langserver
where pylsp

where doorzoekt alleen uw PATH. Een gereedschap dat het niet kan vinden kan alsnog door OctoEdit gevonden worden, omdat de zoektocht ook de ecosysteemmappen hierboven omvat — de Python-scriptmappen staan in het bijzonder nooit in het PATH. Blijft een taal na het installeren van zijn server op ✗, gebruik dan Zoeken ▸ Codenavigatie ▸ Taalservers opnieuw starten, wat de hele zoektocht opnieuw uitvoert.

Het genereren van de compilatiedatabase draait binnen de ontwikkelaarsomgeving van Visual Studio. Wanneer OctoEdit CMake voor u draait (zie hieronder), zoekt hij eerst Visual Studio op — via VSINSTALLDIR, anders via vswhere.exe — en verpakt hij de aanroep in de VsDevCmd.bat -arch=x64 van die installatie. Dat is wat cl, de Windows SDK en de eigen cmake/ninja van Visual Studio voor die ene opdracht op het pad zet, zodat de editor ze helemaal niet in uw PATH nodig heeft. Zonder Visual Studio (een machine met alleen clang of MinGW) wordt de aanroep gewoon in de eigen omgeving van de editor gedaan, en het logboek zegt dat; u hebt dan zelf cmake en ninja bereikbaar nodig, en een compiler die CMake kan herkennen.

Op verzoek opnieuw genereren. Zoeken ▸ Codenavigatie ▸ Compilatiedatabase genereren… voert dezelfde generatie op elk moment uit — ook wanneer er al een database bestaat (die wordt ter plekke opnieuw geconfigureerd) en wanneer u eerder Niet vragen voor dit project antwoordde. Het item is altijd beschikbaar — kan het niet genereren, dan zegt het op de statusbalk waarom (geen C/C++-document, geen projectmap, geen CMakeLists.txt in de wortel van het project, geen cmake, of geen generator hier die er een kan uitvoeren) in plaats van grijs te zijn om een reden die u niet kunt zien.

Waar het antwoord «niet vragen» bewaard wordt. Niet vragen voor dit project wordt per projectwortel bewaard in %APPDATA%\7-bits\OctoEdit.ini, onder plugins/org.mte.lsp/noCompileDbPrompt/<hash> (het projectpad wordt gehasht omdat een pad geen geldige instellingensleutel is). Compilatiedatabase genereren… uitvoeren wist het voor dat project.

Waar OctoEdit naar een server zoekt¶

U zou niets hoeven in te stellen. Na het installeren van een server is een map en een bronbestand openen genoeg. De editor probeert, op volgorde:

een uitdrukkelijk pad dat u in de instellingen hebt ingesteld — dat is gezaghebbend: lost het niet op, dan blijft de taal donker in plaats van stilzwijgend op iets anders terug te vallen;
uw PATH, voor de opdracht van de server en elk bekend alias (clangd-20, clangd-19, …);
de installatielocaties in de definitie van de server voor uw besturingssysteem;
een ingebouwde lijst met ecosysteemmappen.

	Doorzochte ecosysteemmappen
Windows	het globale npm-voorvoegsel en `%APPDATA%\npm`, `%LOCALAPPDATA%\Microsoft\WinGet\Links`, `%USERPROFILE%\.cargo\bin`, `%USERPROFILE%\go\bin` en `%LOCALAPPDATA%\go\bin`, `%USERPROFILE%\.dotnet\tools`, `%ProgramFiles%\LLVM\bin`, `%ProgramFiles%\nodejs`, en de scriptmappen van Python per gebruiker: `%APPDATA%\Python\Python3\Scripts`, `%LOCALAPPDATA%\Packages\PythonSoftwareFoundation.Python.3._\LocalCache\local-packages\Python3\Scripts` (Python uit de Microsoft Store) en `%LOCALAPPDATA%\Programs\Python\Python3*\Scripts`
macOS	`/opt/homebrew/bin` en `/opt/homebrew/opt/llvm/bin` (de clangd van Homebrew woont in de tweede — hij wordt nooit in de eerste gekoppeld), `/usr/local/bin`, `/usr/local/opt/llvm/bin`, `~/.cargo/bin`, `~/go/bin`, `~/.local/bin`, `~/.npm-global/bin`, `~/.dotnet/tools`, `~/Library/Python/3.*/bin`
Linux	`/usr/local/bin`, `/usr/lib/llvm*/bin`, Linuxbrew, en dezelfde `~/.cargo/bin`, `~/go/bin`, `~/.local/bin`, `~/.npm-global/bin`, `~/.dotnet/tools`

De vermeldingen met * zijn echte jokertekens: de versiemap die Python aanmaakt (Python313, 3.13, of de …Python.3.13_qbz5n2kfra8p0 van de Store) wordt vergeleken met wat er werkelijk op de schijf staat, de nieuwste eerst. Daar zet pip install python-lsp-server de pylsp neer, en dat is waarom het installeren ervan geen wijziging van het PATH vergt.

macOS: starten vanuit Finder tegenover een terminal

Een toepassing die vanuit Finder of het Dock gestart wordt erft het PATH van uw shell-profiel niet — macOS geeft haar een minimaal PATH (/usr/bin:/bin:/usr/sbin:/sbin). Homebrew, Cargo, Go en npm zouden dan allemaal onzichtbaar zijn. OctoEdit vraagt daarom aan uw aanmeldshell wat zijn PATH is en doorzoekt dat ook, en geeft de daaruit volgende omgeving mee aan de server die hij start — zodat een server die met een van die gereedschappen geïnstalleerd is gevonden wordt, hoe u de editor ook start.

De server wordt per taal één keer gestart en samen met de editor afgesloten.

C/C++-projecten hebben `compile_commands.json` nodig¶

clangd begrijpt uw code alleen nauwkeurig wanneer hij de compilatievlaggen kent, uit een compilatiedatabase (compile_commands.json). Zonder die valt clangd terug op gissen en blijven functies over bestanden heen (verwijzingen zoeken, naam wijzigen) beperkt tot het geopende bestand. clangd wordt hoe dan ook gestart.

Een C/C++-project telt als ingesteld wanneer het een van deze heeft:

een compile_commands.json in de wortel van het project of in een van de bouwmappen die OctoEdit doorloopt (build/, Build/, out/, out/build/, cmake-build-debug/, cmake-build-release/, .mte-compile-commands/);
een compile_flags.txt in de wortel van het project;
een configuratiebestand .clangd in de wortel van het project.

clangd leest de laatste twee zelf, dus daarover wordt niets gemeld.

Is geen daarvan aanwezig — voor elk C/C++-project, welk bouwsysteem het ook gebruikt — dan toont het statussegment · no compile database en zegt een bericht op de statusbalk dat eenmalig. Er wordt niets geblokkeerd; geen venster onderbreekt uw getyp.

OctoEdit hem laten genereren (CMake-projecten)¶

Heeft de wortel van het project een CMakeLists.txt en een CMake die werkelijk een database zou opleveren, dan krijgt u dit per project één keer aangeboden:

Genereren — draait CMake op de achtergrond, alleen configureren: er wordt niets gecompileerd en uw eigen bouwmappen blijven onaangeroerd. Het resultaat gaat naar <project>/.mte-compile-commands/. Bij succes wordt clangd tegen de nieuwe database herstart; bij mislukking worden de laatste regels van het CMake-logboek getoond, samen met de precieze opdracht die geprobeerd werd, zodat u die zelf kunt herhalen.
Zo doet u het handmatig — toont diezelfde opdracht zonder hem uit te voeren.
Niet vragen voor dit project — onthouden per projectwortel.

Zowel het venster «hoe u het handmatig doet» als het mislukkingsvenster toont de precieze opdrachtregel in een selecteerbaar codevak, boven één knop Kopiëren waarvan de tekstballon zegt wat er meegaat: de opdracht op zichzelf, of de opdracht samen met de staart van het CMake-logboek wanneer er een is. Het mislukkingsvenster is in grootte aanpasbaar en onthoudt de grootte die u het geeft — elk van deze vensters onthoudt zijn eigen grootte, zodat het vergroten van het serverlogboek niet maakt dat een instructievenster van twee regels even groot opengaat.

U bent niet beperkt tot dat ene aanbod: Zoeken ▸ Codenavigatie ▸ Compilatiedatabase genereren… start dezelfde generatie wanneer u maar wilt — na het toevoegen van bestanden, na het wijzigen van bouwopties, of nadat u Niet vragen voor dit project geantwoord hebt (wat het wist). Een bestaande database wordt ter plekke opnieuw geconfigureerd. Het item is altijd beschikbaar; kan het niet genereren, dan zegt het op de statusbalk waarom.

Uw voorinstellingen komen eerst. Heeft het project een CMakePresets.json (of een CMakeUserPresets.json), dan configureert OctoEdit met een van uw voorinstellingen in plaats van een opdrachtregel te verzinnen — cmake --preset <name> -B <project>/.mte-compile-commands -DCMAKE_EXPORT_COMPILE_COMMANDS=ON. Zo zijn de generator, de toolset en het blok environment van de voorinstelling (een QT6_DIR, een SDK-pad) die waarop het project al steunt, en past CMake ze zelf toe. Voorinstellingen die verborgen zijn, die een condition op uw besturingssysteem uitsluit, of die configureren met een generator die niet kan uitvoeren, worden overgeslagen; een naam met debug erin krijgt de voorkeur. Uw eigen bouwmap wordt nooit aangeraakt — de editor leidt de uitvoer altijd om met -B.

Op Windows wordt CMake binnen een ontwikkelaarsomgeving van Visual Studio gedraaid. Een editor die vanuit Verkenner of het Startmenu gestart is heeft geen cl in zijn PATH, en CMake zou dan stilletjes genoegen nemen met welke andere compiler het ook vindt — inclusief de clang.exe die binnen een Visual Studio-installatie meekomt, die prompt struikelt over MSVC-specifieke instellingen. OctoEdit zoekt daarom Visual Studio op met vswhere en verpakt de aanroep in VsDevCmd.bat -arch=x64. Is er geen Visual Studio geïnstalleerd (een machine met MinGW of alleen clang), dan wordt de aanroep gewoon gedaan en zegt het logboek dat.

Een eerdere mislukte poging wordt vóór een nieuwe poging opgeruimd: de CMakeCache.txt ervan zou anders de compiler vastzetten die mislukte. Een map die al een werkende compile_commands.json bevat wordt ter plekke opnieuw geconfigureerd, nooit verwijderd.

Waarom het aanbod soms niet verschijnt

CMAKE_EXPORT_COMPILE_COMMANDS wordt alleen door de generatoren Ninja en Makefile gehonoreerd; de Visual Studio-generator negeert het en schrijft geen database. Op Windows verschijnt het aanbod voor een project zonder bruikbare voorinstelling dus alleen wanneer ninja in uw PATH staat. Zijn de enige toepasselijke voorinstellingen van een project die van Visual Studio en is er ook geen Ninja, dan zegt OctoEdit welke voorinstelling in de weg stond in plaats van aan te bieden iets te draaien dat niet zou kunnen werken.

Hem zelf genereren (CMake)¶

CMAKE_EXPORT_COMPILE_COMMANDS wordt alleen door de generatoren Ninja en Makefile gehonoreerd — de Visual Studio-generator negeert het (hij levert zelfs met de vlag gezet geen compile_commands.json op). Genereer de database dus met Ninja, in een eigen map, los van de map waarin u normaal bouwt: CMake weigert een bestaande bouwmap met een andere generator opnieuw te configureren, dus een project dat u gewoonlijk met Visual Studio bouwt heeft een eigen Ninja-map nodig.

Dit is een stap van alleen configureren (er is geen volledige bouwsessie nodig). Vanuit de wortel van het project:

cmake -S . -B .mte-compile-commands -G Ninja -DCMAKE_EXPORT_COMPILE_COMMANDS=ON

.mte-compile-commands/ is een van de mappen die MTE doorloopt, dus de resulterende compile_commands.json wordt automatisch gevonden. Elke doorlopen map werkt ook (build/, out/, cmake-build-*, of de wortel van het project) — houd hem alleen los van een map die met een andere generator geconfigureerd is.
Voer hem uit vanuit een omgeving waarin het project werkelijk configureert: de juiste compiler in het PATH (bijvoorbeeld een x64 Native Tools Command Prompt op Windows) en alle variabelen die uw project nodig heeft (zoals QT6_DIR voor een Qt-project). Kan cmake uw compiler of SDK niet vinden, dan eindigt de database leeg of met ontbrekende include-paden en indexeert clangd niet goed.
Heropen de map daarna. Het logboek zou niet langer «no compile_commands.json» moeten zeggen; geef clangd even de tijd om zijn achtergrondindex op te bouwen voordat verwijzingen en naamswijzigingen zich over bestanden uitstrekken.

Andere bouwsystemen: Bear (bear -- make), compiledb, Meson, Bazel en andere kunnen allemaal een compile_commands.json opleveren die de plug-in vindt.

Welke server welk bestand bedient¶

De bestandsnaam beslist. Elke serverdefinitie somt de extensies op die zij bedient, en de eerste definitie die de extensie van een bestand opeist is degene die start. Het vergelijken negeert hoofdletters, en alleen de laatste punt telt — Deploy.Prod.SH is een shellscript.

Dit staat met opzet los van de syntaxiskleuring. De kleuring uitzetten, of een bestand openen dat groter is dan de groottelimiet van de kleuring, kost u niet langer ook de taalserver.

De colorizer-id blijft een terugvalspoor

Eist geen enkele definitie de extensie op, dan valt OctoEdit terug op de taal-id die de kleurmotor heeft toegekend. Zo blijft een met de hand geschreven definitie werken wanneer die wel een taal noemt maar geen extensies opsomt.

De naam die de server verteld wordt is een tweede, aparte zaak: LSP heeft zijn eigen vocabulaire van taal-id's, en verschillende daarvan komen niet met die van OctoEdit overeen. Een .sh-bestand wordt als shellscript aangekondigd, een .scss als scss, een .jsx als javascriptreact, een .mm als objective-cpp. Servers die zich per taal anders gedragen — de CSS-server, de TypeScript-server — hebben nodig dat dit klopt.

Extensie	Bediend door	Aangekondigd als
`.cpp` `.cxx` `.cc` `.h` `.hpp` `.hh` `.hxx` `.ipp` `.inl`	clangd	`cpp`
`.c`	clangd	`c`
`.m` / `.mm`	clangd	`objective-c` / `objective-cpp`
`.sh` `.bash` `.zsh` `.ksh`	bash-language-server	`shellscript`
`.css` / `.scss` / `.less`	vscode-css-language-server	`css` / `scss` / `less`
`.ts` `.mts` `.cts` / `.tsx`	typescript-language-server	`typescript` / `typescriptreact`
`.js` `.mjs` `.cjs` / `.jsx`	typescript-language-server	`javascript` / `javascriptreact`
`.json` / `.jsonc` `.json5`	vscode-json-language-server	`json` / `jsonc`

.h wordt door de C/C++-definitie opgeëist in plaats van door die van Objective-C — beide draaien clangd, die zelf beslist wat een header bevat.

Wat elke server van uw project nodig heeft¶

Verschillende servers werken alleen goed wanneer er een bepaald bestand in de wortel van het project staat. Ontbreekt het, dan zegt de statusaanduiding dat, in plaats van te doen alsof alles in orde is:

Taal	Wil	Zonder dat
Rust	`Cargo.toml`	laadt rust-analyzer de crate helemaal niet.
Go	`go.mod`	kan gopls de module niet oplossen.
TypeScript	`tsconfig.json` (of `package.json`)	zijn antwoorden over het hele project niet beschikbaar.
JavaScript	`jsconfig.json` (of `package.json`)	als hierboven.
Python (pyright)	`pyproject.toml` / `pyrightconfig.json` / `setup.py`	werkt pyright nog steeds; hij gebruikt alleen standaarden voor importwortels en strengheid.
Java	`pom.xml` / `build.gradle`	kan jdtls geen classpath bouwen.
C/C++	`compile_commands.json`	zie het onderdeel hierboven.

Een taal toevoegen¶

Servers worden beschreven door JSON-bestanden die de plug-in bij het starten laadt uit <editor>/lsp-servers/*.json, plus uw eigen map. Elk item koppelt een taal aan haar opdracht plus aanwijzingen voor het zoeken:

{
    "language":    "cpp",
    "languageId":  "cpp",
    "languageIds": { ".c": "c" },
    "command":     "clangd",
    "aliases":     ["clangd-20", "clangd-19"],
    "args":        ["--background-index", "--log=verbose"],
    "extensions":  [".cpp", ".h", ".hpp", ".c"],
    "projectMarkers": [],
    "searchDirs":      ["${LLVM}/bin", "${ProgramFiles}/LLVM/bin"],
    "searchDirsMac":   ["/opt/homebrew/opt/llvm/bin"],
    "searchDirsLinux": ["/usr/lib/llvm-20/bin"],
    "docsAnchor":  "cpp-clangd",
    "compileCommandsArg": "--compile-commands-dir=${dir}"
}

language is de eigen id van OctoEdit voor de taal — de sleutel waarop de instellingenpagina, het statussegment en de verbinding gegroepeerd worden. command/aliases zijn de programmanamen die in het PATH geprobeerd worden.
extensions is de primaire koppeling van bestand naar taal (zie hierboven). Neem de punt mee.
args is één arrayelement per argument. ["--background-index", "--log=verbose"] geeft twee argumenten mee; ["--background-index --log=verbose"] geeft één argument mee dat toevallig een spatie bevat, wat elke server afwijst — en omdat hij dan meteen afsluit, ziet het resultaat eruit als een crashlus in plaats van als een typefout. OctoEdit waarschuwt over die vorm in het diagnostieklogboek wanneer hij uw bestand laadt.
languageId (optioneel) is de id die in didOpen naar de server gestuurd wordt; standaard is die gelijk aan language. Gebruik hem wanneer de naam uit de LSP-specificatie van de onze afwijkt (bash → shellscript, objc → objective-c).
languageIds (optioneel) overschrijft languageId per extensie, voor één server die meerdere talen uit de specificatie bedient.
projectMarkers (optioneel) zijn de bestandsnamen die de server in de wortel van het project wil hebben. Is geen ervan aanwezig, dan zegt het statussegment geen <first marker>; het stopt de server nooit.
searchDirs is de lijst met installatielocaties voor Windows; searchDirsMac en searchDirsLinux zijn de tegenhangers per platform. Alle drie vouwen ${VAR} uit, en de POSIX-lijsten vouwen ook een ~ aan het begin uit. Een item waarvan de variabelen niet gezet zijn wordt overgeslagen in plaats van tot een onzinnig pad gemaakt.
args mag twee tijdelijke aanduidingen gebruiken: ${dataDir}, de beschrijfbare gegevensmap van de plug-in, en ${rootHash}, een korte stabiele id voor het huidige project. Zo krijgt jdtls zijn -data <dir>. Een aanduiding die niet opgelost kan worden blijft letterlijk in het argument staan in plaats van tot niets uit te vouwen.
compileCommandsArg (optioneel) wordt achteraan toegevoegd, met ${dir} vervangen door de gevonden databasemap — zo wordt clangd naar compile_commands.json gewezen.
priority (optioneel, standaard 0) ordent meerdere definities van dezelfde taal: het laagste getal wordt eerst geprobeerd, en de eerste definitie waarvan het programma gevonden wordt is degene die start. Zo krijgt Python pyright (priority: 0) met pylsp (priority: 10) als terugvalspoor.

Uw eigen serverdefinities¶

De meegeleverde definities wonen binnen de installatiemap, die niet van u is om te bewerken (Program Files op Windows, een ondertekende toepassingsbundel op macOS). Zet de uwe er in plaats daarvan naast: Voorkeuren ▸ Taalserver ▸ Map met serverdefinities van de gebruiker openen maakt en opent

<user data>/plugins/org.mte.lsp/lsp-servers/

Elke *.json daarin wordt na de meegeleverde set geladen, en:

een bestand waarvan language en command overeenkomen met een meegeleverde definitie vervangt die — zo wijzigt u de argumenten van clangd of voegt u een zoekmap toe;
al het andere wordt toegevoegd — een tweede server voor een taal die wij meeleveren, of een taal waarvoor OctoEdit helemaal niets meelevert.

Een bestand dat geen geldige JSON is, of waarin language of command ontbreekt, wordt overgeslagen en in het diagnostieklogboek gemeld in plaats van u stilzwijgend een taal te kosten.

Definities worden één keer gelezen, bij het starten: herstart de editor nadat u ze bewerkt hebt (de knop Servers opnieuw doorzoeken / herstarten voert de zoektocht opnieuw uit, niet het laden).

Een minimale eigen definitie: <user data>/…/lsp-servers/zig.json

{
    "language":   "zig",
    "command":    "zls",
    "extensions": [".zig", ".zon"],
    "projectMarkers": ["build.zig"],
    "searchDirs":      ["${LOCALAPPDATA}/zls"],
    "searchDirsMac":   ["/opt/homebrew/bin", "~/.local/bin"],
    "searchDirsLinux": ["~/.local/bin"]
}

Welke map de server krijgt¶

Een taalserver moet weten waar het project staat: rust-analyzer laadt zonder dat geen crate, gopls heeft de wortel van de module nodig, pyright leest pyrightconfig.json eruit, en clangd zoekt daar naar zijn database.

Met een map open (Bestand ▸ Map openen) horen bestanden daarbinnen bij die map.
Voor een bestand buiten de geopende map, of helemaal zonder geopende map, loopt OctoEdit vanaf het bestand omhoog op zoek naar compile_commands.json, compile_flags.txt, .clangd, CMakeLists.txt, Cargo.toml, go.mod, pyrightconfig.json, pyproject.toml, setup.py, tsconfig.json, package.json, pom.xml, build.gradle, een .sln, .git, en ten slotte een .editorconfig die root = true verklaart. De eigen map van het bestand is het terugvalspoor, zodat een server nooit zonder project blijft.
De map na het bestand openen werkt. Servers die wijzigingen van werkruimtemappen begrijpen krijgen de nieuwe map te horen; de rest wordt herstart, en uw geopende documenten worden automatisch bij hen opnieuw aangemeld. Een handmatige herstart is niet nodig.

Problemen oplossen¶

Symptoom	Wat u nagaat
Het segment `LSP:` verschijnt nooit	Geen serverdefinitie eist de extensie van dit bestand op. Zie welke server welk bestand bedient, of voeg een definitie toe.
`· server not responding`	De server is gestopt met antwoorden. Logboek van de taalserver tonen, daarna Taalservers opnieuw starten.
`✗` voor een taal waarvoor u een server geïnstalleerd hebt	Bevestig dat het programma er werkelijk staat: `where clangd` (Windows) / `which clangd` (macOS, Linux). Kies dan Zoeken ▸ Codenavigatie ▸ Taalservers opnieuw starten, wat de hele zoektocht opnieuw uitvoert.
`⚠`	De server startte en bleef daarna crashen. Logboek van de taalserver tonen noemt meestal de reden; verhelp die en kies dan Taalservers opnieuw starten.
`· no compile database` bij een C/C++-project	Zie hierboven. Verwijzingen zoeken en Naam wijzigen zien alleen het geopende bestand totdat het verholpen is.
Aanvulling levert bij één C++-bestand niets op	Dat bestand ontbreekt waarschijnlijk in `compile_commands.json` (een header die door geen enkele vertaaleenheid wordt ingevoegd, of een bestand dat sinds het genereren van de database is toegevoegd). Genereer hem opnieuw.
Alles werkt bij starten vanuit een terminal maar niet vanuit Finder	Meld het — de opzoeking van het `PATH` van de aanmeldshell hoort de twee identiek te maken. Logboek van de taalserver tonen en het diagnostieklogboek noteren wat er doorzocht is.
Een server heeft een projectbestand nodig dat u niet hebt	`typescript-language-server` heeft het pakket `typescript` nodig, gopls een `go.mod`, rust-analyzer een `Cargo.toml`, pyright een `pyrightconfig.json`/`pyproject.toml` voor antwoorden over het hele project.

Instellingen voor de taalserver¶

Voorkeuren ▸ Taalserver somt elke taal op waarvoor een serverdefinitie bestaat. Per taal kunt u:

de server in- of uitschakelen (een uitgeschakelde taal start er nooit een).
een uitdrukkelijk programmapad instellen (met Bladeren…). Deze overschrijving wint van de zoektocht in PATH/searchDirs hierboven — nuttig wanneer de server niet in het PATH staat of wanneer u een bepaalde bouwsessie wilt.
Extra argumenten toevoegen, achter die van de definitie zelf — bijvoorbeeld --log=verbose voor clangd. De regel wordt gesplitst zoals een opdrachtregel dat wordt, dus zet aanhalingstekens om een waarde met spaties erin.

Het padveld is een pad, geen opdrachtregel

C:\tools\clangd.exe --log=verbose in Pad naar het programma typen vraagt OctoEdit een bestand te vinden waarvan de naam op .exe --log=verbose eindigt, wat niet bestaat — de taal meldt dan helemaal geen server. Zet het programma in het padveld en de argumenten ervan in Extra argumenten. Gebeurt het toch, dan zegt het diagnostieklogboek dat met zoveel woorden.

Wijzigingen worden van kracht wanneer u op OK / Toepassen drukt: is er werkelijk een schakelaar of een pad veranderd, dan worden de servers automatisch met de nieuwe instellingen herstart (een onaangeroerde pagina verstoort de draaiende servers nooit). De knop Opnieuw scannen / servers herstarten dwingt daar bovenop een afbreken-en-opnieuw-zoeken met de huidige instellingen af — nuttig na het installeren van een server die de editor eerder niet kon vinden, en hij zet ook het crash-herstartbudget terug.

Map met serverdefinities van de gebruiker openen maakt en opent de map die beschreven is in Uw eigen serverdefinities.

Beperkingen¶

Het kleuren van code binnen pop-ups met aanwijshulp wordt niet toegepast (de tekst wordt wel opgemaakt — vet, koppen, vaste breedte voor code — maar niet syntaxisgekleurd).
De nauwkeurigheid hangt van de server af: voor C/C++ valt clangd zonder compile_commands.json terug op vuistregels en kunnen de resultaten onvolledig zijn.
OctoEdit installeert of downloadt nooit een server. Hij vindt er een die u geïnstalleerd hebt en start die; is er geen, dan blijft de functie donker en zegt het statussegment dat.
Eén serverproces per taal, gedeeld door elk geopend project van die taal. Een tweede project wordt als werkruimtemap toegevoegd wanneer de server dat ondersteunt; anders wordt het onder de wortel van het eerste project bediend.
Kotlin, Swift en Objective-C krijgen code-intelligentie maar geen syntaxiskleuring — de editor heeft er nog geen kleurgever voor. De twee staan nu los van elkaar, dus de server werkt hoe dan ook.
Serverdefinities worden bij het starten één keer gelezen; ze bewerken (de uwe of de meegeleverde) vereist een herstart van de editor.