====== std.html ======

Werkzeuge für den Umgang mit HTML als Text: Sonderzeichen maskieren, Tags erkennen und entfernen, Verschachtelung grob prüfen, Leerzeichen für Formularparameter kodieren. Die Unit ist **kein Parser** — sie arbeitet zeichenweise über den Eingabetext und hat kein Dokumentmodell.

→ [[lyx_-_programmiersprache:units:xml|std.xml]] · [[lyx_-_programmiersprache:units:string|std.string]] · [[lyx_-_programmiersprache:units|Standard Library]]

Alle Beispiele dieser Seite sind mit ''lyxc 1.0.21A'' übersetzt und ausgeführt; die gezeigten Ausgaben sind echte Programmausgaben.

**Einsatz:** Template-Ausgabe, HTML-Erzeugung, Textextraktion aus Webseiten, SEO- und Feed-Auswertung.

<box gh>
> **Nicht für Sicherheitsentscheidungen verwenden.** Frühere Fassungen dieser Seite nannten „HTML-Sanitisierung (XSS-Schutz)" als Einsatzbereich — dafür taugt die Unit nicht:
>
>   * ''StripTags'' entfernt die **Tags**, nicht deren Inhalt: aus ''&lt;script&gt;alert(1)&lt;/script&gt;'' wird ''alert(1)''.
>   * ''Unescape'' löst derzeit fast keine Entity auf (siehe unten), eine darauf gestützte Prüfung sieht also etwas anderes als der Browser.
>   * Es gibt keine Attributprüfung: ''%%onclick%%'', ''%%javascript:%%''-URLs und Data-URLs bleiben unangetastet, solange sie in einem Tag stehen, das entfernt wird — der Text dahinter aber bleibt.
>
> Zum Schutz vor XSS ist **''Escape'' beim Ausgeben** das richtige Mittel, nicht das Filtern beim Einlesen.
</box>

----

===== Maskieren =====

^ Signatur ^ Beschreibung ^
| ''Escape(input: pchar, output: pchar): int64'' | Ersetzt ''&'', ''<'', ''>'', ''"'', ''%%'%%'' und Byte 160 durch Entities. Rückgabe: Länge ohne Nullbyte. |
| ''Unescape(input: pchar, output: pchar): int64'' | Soll Entities zurückwandeln — **funktioniert derzeit nur für ''&quot;''**. |
| ''NeedsEscape(s: pchar): bool'' | Meldet, ob überhaupt ein zu maskierendes Zeichen vorkommt. |

^ Zeichen ^ Wird zu ^
| ''&'' | ''&amp;'' |
| ''<'' | ''&lt;'' |
| ''>'' | ''&gt;'' |
| ''"'' | ''&quot;'' |
| ''%%'%%'' | ''&#39;'' (numerisch, nicht ''&apos;'') |
| Byte 160 | ''&nbsp;'' — **problematisch, siehe Kasten** |

Der Ausgabepuffer gehört dem Aufrufer. Sechs Byte je Eingabezeichen sind sicher (''&quot;'' und ''&nbsp;'' sind die längsten Ersetzungen), plus ein Byte für den Abschluss.

<code lyx>
import std.html;
import std.alloc;
import std.string;

fn main(): int64 {
    var o: pchar := alloc(512) as pchar;

    Escape("<a href=\"x\">Tom & Jerry's</a>"c, o);
    PrintLn(StrConcat("Escape:   ", o));

    var back: pchar := alloc(512) as pchar;
    Unescape(o, back);
    PrintLn(StrConcat("Rueckweg: ", back));

    // Einzelne Entities durch den Dekoder
    Unescape("&amp; &lt; &gt; &quot; &apos; &#39; &#x41; &nbsp; &unknown;"c, o);
    PrintLn(StrConcat("Entities: ", o));

    // UTF-8: 'à' ist C3 A0 - das zweite Byte ist 160
    Escape("Caf\xc3\xa0 Grand-M\xc3\xa8re"c, o);
    PrintLn(StrConcat("UTF-8:    ", o));
    return 0;
}
</code>

<code>
Escape:   &lt;a href=&quot;x&quot;&gt;Tom &amp; Jerry&#39;s&lt;/a&gt;
Rueckweg: <a href="x">Tom & Jerry's</a>
Entities: & < > " ' ' A M-BM-  &unknown;
UTF-8:    CafM-CM-  Grand-MM-CM-(re
</code>

Die letzte Zeile ist durch ''cat -v'' sichtbar gemacht: ''M-C'' steht für das Byte 0xC3, ''M-'' + Leerzeichen für 0xA0. ''à'' (C3 A0) und ''è'' (C3 A8) kommen beide unversehrt durch — die frühere Latin-1-Regel „Byte 160 → ''&nbsp;''" ist weg (#1419). Der Rückweg löst inzwischen **alle** Entities auf, ein unbekanntes ''&unknown;'' bleibt stehen. Gemessen mit 1.1.14A; ältere Fassungen dieser Seite zeigen die halb zerlegte Ausgabe.

<box gh>
> **''Unescape'' beherrscht seit 1.0.20F den vollen Umfang** ([[https://github.com/SEOLizer/LyX-Compiler/issues/1418|#1418]]): benannte Entities und numerische Angaben. Gemessen wird ''&lt;a&gt; &amp; &#65; &nbsp;'' zu ''&lt;a&gt; & A'' samt geschütztem Leerzeichen aufgelöst.
</box>

<box gh>
> **''Escape'' lässt UTF-8 unangetastet** ([[https://github.com/SEOLizer/LyX-Compiler/issues/1419|#1419]] behoben, 1.0.21A). Die frühere Latin-1-Regel „Byte 160 → ''&nbsp;''" zerlegte Zeichen wie ''à'' (C3 A0); nachgemessen bleibt ''à Grüße'' jetzt unverändert.
</box>

----

===== Tags erkennen =====

^ Signatur ^ Beschreibung ^
| ''GetTagName(html: pchar, output: pchar): int64'' | Liest den Tag-Namen ab ''<''; funktioniert auch für ''&lt;/tag&gt;'' und ''&lt;tag/&gt;''. ''0'', wenn das erste Zeichen kein ''<'' ist. |
| ''IsClosingTag(html: pchar): bool'' | ''true'' bei ''&lt;/…&gt;''. |
| ''IsSelfClosing(html: pchar): bool'' | ''true'' bei ''<…/>'' — **nicht** bei Void-Elementen wie ''&lt;br&gt;''. |
| ''HasTags(s: pchar): bool'' | Sucht ein ''<'' mit passendem ''>'' irgendwo im Text. |
| ''ValidateBalance(html: pchar): int64'' | Bilanz aus öffnenden und schließenden Tags: ''0'' = ausgeglichen, positiv = offen, negativ = zu viele schließende. Leere Elemente (''%%<br>%%'', ''%%<img …/>%%'') zählen nicht mit, und ein ''<'' in gewöhnlichem Text (''5 < 7'') ebenfalls nicht — beides gemessen mit 1.1.14A |

<code lyx>
import std.html;
import std.alloc;
import std.string;

fn J(b: bool): pchar { if (b) { return "ja"; } return "nein"; }

fn main(): int64 {
    var o: pchar := alloc(512) as pchar;

    // Tag-Analyse
    GetTagName("<div class=\"x\">"c, o); PrintLn(StrConcat("GetTagName('<div class=..>'): ", o));
    GetTagName("</span>"c, o);           PrintLn(StrConcat("GetTagName('</span>'):        ", o));
    GetTagName("<br/>"c, o);             PrintLn(StrConcat("GetTagName('<br/>'):          ", o));
    PrintLn(StrConcat("IsClosingTag('</p>'):  ", J(IsClosingTag("</p>"c))));
    PrintLn(StrConcat("IsSelfClosing('<br/>'):", J(IsSelfClosing("<br/>"c))));
    PrintLn(StrConcat("IsSelfClosing('<br>'): ", J(IsSelfClosing("<br>"c))));
    PrintLn(StrConcat("HasTags('a < b'):      ", J(HasTags("a < b"c))));
    PrintLn(StrConcat("NeedsEscape('a & b'):  ", J(NeedsEscape("a & b"c))));

    // Verschachtelung
    PrintLn(StrConcat("Balance('<p><b>x</b></p>'): ", IntToStr(ValidateBalance("<p><b>x</b></p>"c))));
    PrintLn(StrConcat("Balance('<p><b>x</p>'):     ", IntToStr(ValidateBalance("<p><b>x</p>"c))));
    PrintLn(StrConcat("Balance('<p>a<br>b</p>'):   ", IntToStr(ValidateBalance("<p>a<br>b</p>"c))));
    PrintLn(StrConcat("Balance('<img src=x/>'):    ", IntToStr(ValidateBalance("<img src=x/>"c))));
    PrintLn(StrConcat("Balance('5 < 7 und 9 > 2'): ", IntToStr(ValidateBalance("5 < 7 und 9 > 2"c))));

    // StripTags
    StripTags("<p>Hallo <b>Welt</b></p>"c, o);      PrintLn(StrConcat("Strip normal:  ", o));
    StripTags("<script>alert(1)</script>"c, o);      PrintLn(StrConcat("Strip script:  ", o));
    StripTags("5 < 7 und 9 > 2"c, o);                PrintLn(StrConcat("Strip Text:    ", o));
    StripTags("<p onclick=\"evil()\">Text</p>"c, o); PrintLn(StrConcat("Strip Attribut:", o));

    // URL-Leerzeichen
    EncodeSpaces("a b c"c, o); PrintLn(StrConcat("EncodeSpaces('a b c'): ", o));
    DecodeSpaces(o, o);        PrintLn(StrConcat("DecodeSpaces zurueck:  ", o));
    return 0;
}
</code>

<code>
GetTagName('<div class=..>'): div
GetTagName('</span>'):        span
GetTagName('<br/>'):          br
IsClosingTag('</p>'):  ja
IsSelfClosing('<br/>'):ja
IsSelfClosing('<br>'): nein
HasTags('a < b'):      ja
NeedsEscape('a & b'):  ja
Balance('<p><b>x</b></p>'): 0
Balance('<p><b>x</p>'):     1
Balance('<p>a<br>b</p>'):   0
Balance('<img src=x/>'):    0
Balance('5 < 7 und 9 > 2'): 0
Strip normal:  Hallo Welt
Strip script:  alert(1)
Strip Text:    5  2
Strip Attribut:Text
EncodeSpaces('a b c'): a+b+c
DecodeSpaces zurueck:  a b c
</code>

<box gh>
> **''ValidateBalance'' unterscheidet Markup und Text** ([[https://github.com/SEOLizer/LyX-Compiler/issues/1420|#1420]], nachgemessen mit lyxc 1.2.2B):
>
>   * ''%%<p>a<br>b</p>%%'' → **0** (ausgeglichen): Void-Elemente zählen nicht als offen.
>   * ''%%<p>3 < 5</p>%%'' → **0**: ein ''<'' im Fließtext zählt nicht mit.
>   * ''%%<p>a%%'' → **1**: der fehlende Schluss-Tag wird gemeldet.
>
> Frühere Fassungen zählten jedes ''<'' als geöffnet, unabhängig davon, ob überhaupt ein Tag vorlag.
</box>

----

===== Tags entfernen =====

''StripTags'' kopiert alles, was außerhalb von ''<…>'' steht. Das Verfahren ist bewusst einfach — und hat zwei Folgen, die man kennen muss:

  * **Der Inhalt bleibt.** Ein ''&lt;script&gt;''-Block verliert seine Tags, der Code darin steht anschließend im Text.
  * **Ein ''<'' im Text frisst mit.** Aus ''5 < 7 und 9 > 2'' wird ''5  2'' — alles zwischen ''<'' und dem nächsten ''>'' gilt als Tag. Wer Text mit Vergleichszeichen verarbeitet, maskiert ihn vorher mit ''Escape''.

Für die Textextraktion aus wohlgeformtem HTML — der eigentliche Zweck — arbeitet die Funktion zuverlässig.

----

===== Leerzeichen für Formularparameter =====

^ Signatur ^ Beschreibung ^
| ''EncodeSpaces(input: pchar, output: pchar): int64'' | Ersetzt Leerzeichen durch ''+''. |
| ''DecodeSpaces(input: pchar, output: pchar): int64'' | Ersetzt ''+'' durch Leerzeichen. |

<box tip>
> **Das ist ''+'', nicht ''%%%20%%''.** Frühere Fassungen dieser Seite sprachen von „''%%%20%%'' für URLs" — tatsächlich erzeugt ''EncodeSpaces'' die Form aus ''application/x-www-form-urlencoded'', wie sie in Formulardaten und Abfrageparametern üblich ist. ''DecodeSpaces'' kennt umgekehrt nur ''+'' und lässt ''%%%20%%'' unverändert stehen.
>
> Beide Funktionen behandeln **ausschließlich das Leerzeichen**. ''&'', ''='', ''?'', ''#'' und Nicht-ASCII bleiben unangetastet — für vollständige URL-Kodierung ist ''std.net.http'' zuständig.
</box>

----

===== Fallstricke =====

  * **Ausgabepuffer selbst anlegen und großzügig bemessen** — keine Funktion prüft die Zielgröße. Für ''Escape'' sind sechs Byte je Eingabezeichen sicher.
  * **''Unescape'' löst benannte und numerische Entities auf** (#1418 behoben).
  * **''Escape'' lässt UTF-8 unangetastet** (#1419 behoben).
  * **Doppelte Maskierung** merkt niemand: ''%%Escape(Escape(x))%%'' ergibt ''&amp;lt;'' statt ''&lt;''. Nur einmal maskieren, unmittelbar vor der Ausgabe.
  * **Kein Dokumentmodell.** ''GetTagName'' und Verwandte erwarten einen Text, der **am** ''<'' beginnt; einen Tag-Iterator gibt es nicht. Wer Struktur braucht, nimmt [[lyx_-_programmiersprache:units:xml|std.xml]].
  * **Kommentare, CDATA und Skriptinhalte** kennt die Unit nicht — ''&lt;!-- a &gt; b --&gt;'' endet für ''StripTags'' beim ersten ''>''.
  * Die exportierten Entity-Konstanten sind unit-privat; von außen sichtbar sind nur die elf Funktionen.

----

**Weiterführend:** [[lyx_-_programmiersprache:units:xml|std.xml — Parser mit Dokumentmodell]] · [[lyx_-_programmiersprache:units:string|std.string]] · [[lyx_-_programmiersprache:units:net:http|std.net.http]] · [[lyx_-_programmiersprache:units|Standard Library]]

**Quelle:** ''std/html.lyx'' (459 Zeilen) · **Autor:** Andreas Röne · **Copyright:** 2024–2025 Andreas Röne

Letzte Aktualisierung: 2026-09-05 ([[https://github.com/SEOLizer/LyX-Compiler/issues/1420|#1420]], nachgemessen mit lyxc 1.2.2B) — ''ValidateBalance''-Kasten auf den behobenen Stand gezogen.

Vorherige letzte Aktualisierung: 2026-08-13 — Seite gegen ''std/html.lyx'' überarbeitet: leere Konstanten-Tabelle entfernt, zwei lauffähige Beispiele mit echter Ausgabe, Entity-Tabelle, Fallstricke. Die Nennung als Mittel zur „HTML-Sanitisierung (XSS-Schutz)" ist gestrichen — ''StripTags'' entfernt Tags, nicht deren Inhalt. Belegt und als Issue erfasst: ''Unescape'' erkennt nur ''&quot;'' ([[https://github.com/SEOLizer/LyX-Compiler/issues/1418|#1418]]), ''Escape'' zerstört UTF-8-Zeichen mit Folgebyte 0xA0 ([[https://github.com/SEOLizer/LyX-Compiler/issues/1419|#1419]]), ''ValidateBalance'' zählt Void-Elemente und Text-Kleinerzeichen mit ([[https://github.com/SEOLizer/LyX-Compiler/issues/1420|#1420]]). ''EncodeSpaces'' erzeugt ''+'', nicht ''%%%20%%''. Geprüft mit ''lyxc 1.0.21A''.

Codebeispiele geprüft: gegen **lyxc 1.2.5C** übersetzt (Prüflauf 2026-09-08 über die gesamte Doku: 574 Vollprogramme, 0 echte Fehler; zusätzlich 5159 Aufrufe gegen die ''pub fn''-Signaturen in ''aurum/std'' gehalten, 0 Abweichungen).

Letzte Aktualisierung: 2026-08-30 — Beispielausgaben gegen ''lyxc 1.1.14A'' nachgezogen: ''Unescape'' löst alle Entities auf, ''Escape'' lässt UTF-8 unangetastet (#1418, #1419) und ''ValidateBalance'' zählt leere Elemente sowie ein ''<'' im Text nicht mehr als offenes Tag.