Sorry, long testpost.

HTML umlauts
Zeichen Beschreibung Name in HTML Unicode in HTML
Ÿ Y Umlaut Ÿ Ã
ÿ y Umlaut ÿ ÿ
Ü U Umlaut Ü Ü
ü u Umlaut ü ü
Ö O Umlaut Ö Ö
ö o Umlaut ö ö
Ï I Umlaut Ï Ï
ï i Umlaut ï ï
Ë E Umlaut Ë Ë
ë e Umlaut ë ë
Ä A Umlaut Ä Ä
ä a Umlaut ä ä
Frequently used special characters HTML
Zeichen Beschreibung Name in HTML Unicode in HTML
Erzwungenes Leerzeichen
& Und-Zeichen, Ampersand & &
ß scharfes S ß ß
© Copyright-Zeichen © ©
® Registriermarke-Zeichen ® ®
™ Trademark ™ ™
« angewinkelte Anf.zeichen links « «
» angewinkelte Anf.zeichen rechts » »
• Bullet (größerer, dickerer Punkt) • •
· Mittelpunkt · ·
¨ Pünktchen oben ¨ ¨
… Ellipsis, Auslassungspunkte … Â
¡ umgekehrtes Ausrufezeichen ¡ ¡
¿ umgekehrtes Fragezeichen ¿ ¿
¦ durchbrochener Strich ¦ ¦
§ Paragraph-Zeichen § §
º Ordinal-Zeichen männlich º º
ª Ordinal-Zeichen weiblich ª ª
kurzer Trennstrich ­ ­
¯ Überstrich ¯ ¯
¶ Absatz-Zeichen ¶ ¶
†einfaches Kreuz (Dagger) ††
‡ doppeltes Kreuz ‡ ‡
° Grad-Zeichen ° °
Currency symbols HTML
Zeichen Beschreibung Name in HTML Unicode in HTML
¢ Cent-Zeichen ¢ ¢
€ Euro-Zeichen € €
£ Pfund-Zeichen £ £
¤ Währungs-Zeichen ¤ ¤
¥ Yen-Zeichen ¥ ¥
ƒ Florin, Gulden ƒ ƒ

The dollar character does not have a name in HTML because it is part of the ASCII character table. The Dollar character (Unicode: $) can be entered easily using the keyboard and does not need to be masked.

Mathematical special characters HTML
Zeichen Beschreibung Name in HTML Unicode in HTML
± Plusminus-Zeichen ±
±
÷ Divisions-Zeichen ÷ ÷
× Mal-Zeichen × ×
√ Quadratwurzel √ √
∫ Integral ∫ ∫
¹ Hoch-1-Zeichen ¹ ¹
² Hoch-2-Zeichen ² ²
³ Hoch-3-Zeichen ³ ³
´ Acute-Zeichen ´ ´
¸ Häkchen unten ¸ ¸
‰ Promille &permill; ‰
µ Mikro-Zeichen µ µ
¬ Verneinungs-Zeichen ¬ ¬
½ ein Halb ½ ½
¼ ein Viertel ¼ ¼
¾ drei Viertel ¾ ¾
∀ für alle ∀ ∀
∂ partiell ∂ ∂
∃ existiert ∃ ∃
∠leere Menge ∠âˆ
⊂ Untermenge von ⊂ ⊂
⊃ Obermenge von ⊃ ⊃
⊄ keine Untermenge von ⊄ ⊄
⊆ Untermenge von oder gleich mit ⊆ ⊆
⊇ Obermenge von oder gleich mit ⊇ ⊇
≡ identisch mit ≡ ≡
≤ kleiner gleich ≤ ≤
≥ größer gleich ≥ ≥
≙ entspricht ≙ ≙
HTML characters for other languages
Zeichen Beschreibung Name in HTML Unicode in HTML
À A mit Accent grave À À
Á A mit Accent acute Á Á
 A mit Circumflex  Â
à A mit Tilde à Ã
à A mit Ring à Ã
Æ AE-Ligatur Æ Æ
Ç C mit Häkchen Ç Ç
È E mit Accent grave È È
É E mit Accent acute É É
Ê E mit Circumflex Ê Ê
Ì I mit Accent grave Ì Ë
Í I mit Accent acute Í Ì
Î I mit Circumflex Î Í
Ð Eth (isländisch) Ð Ð
Ñ N mit Tilde Ñ Ñ
Ã’ O mit Accent grave Ã’ Ã’
Ó O mit Accent acute Ó Ó
Ô O mit Circumflex Ô Ô
Õ O mit Tilde Õ Õ
Ø O mit Schrägstrich Ø Ø
Œ OE-Ligatur Œ Œ
Ù U mit Accent grave Ù Ù
Ú U mit Accent acute Ú Ú
Û U mit Circumflex Û Û
Ý Y mit Accent acute Ý Ý
Þ THORN (isländisch) Þ Þ
à a mit Accent grave à Ã
á a mit Accent acute á á
â a mit Circumflex â â
ã a mit Tilde ã ã
å a mit Ring å å
æ ae-Ligatur æ æ
ç c mit Häkchen ç ç
è e mit Accent grave è è
é e mit Accent acute é é
ê e mit Circumflex ê ê
ì i mit Accent grave ì ì
í i mit Accent acute í í
ð eth (isländisch) ð ð
ñ n mit Tilde ñ ñ
ò o mit Accent grave ò ò
ó o mit Accent acute ó ó
ô o mit Circumflex ô ô
õ o mit Tilde õ õ
ø o mit Schrägstrich ø ø
œ oe-Ligatur œ œ
ù u mit Accent grave ù ù
ú u mit Accent acute ú ú
û u mit Circumflex û û
ý y mit Accent acute ý ý
þ thorn (isländisch) þ þ
ŠS mit Hacek ŠŠ
š s mit Hacek š š
ÄŒ C mit Hacek Č ÄŒ
č c mit Hacek č č
Greek alphabet
Zeichen Beschreibung Name in HTML Unicode in HTML
A großes griechisches Alpha α Α
B großes griechisches Beta Β Β
Γ großes griechisches Gamma Γ Γ
Δ großes griechisches Delta Δ Δ
Ε großes griechisches Epsilon Ε Ε
Z großes griechisches Zeta Ζ Ζ
H großes griechisches Eta Η Η
Θ großes griechisches Theta Θ Θ
I großes griechisches Iota Ι Ι
K großes griechisches Kappa Κ Κ
Λ großes griechisches Lambda Λ Λ
M großes griechisches Mu Μ Μ
N großes griechisches Nu Ν Ν
Ξ großes griechisches Xi Ξ Ξ
Ο großes griechisches Omicron Ο Ο
Î großes griechisches Pi Î Î
P großes griechisches Rho Ρ Ρ
Σ großes griechisches Sigma Σ Σ
T großes griechisches Tau Τ Τ
Υ großes griechisches Ypsilon Υ Υ
Φ großes griechisches Phi Φ Φ
Χ großes griechisches Chi Χ Χ
Ψ großes griechisches Psi Ψ Ψ
Ω großes griechisches Omega Ω Ω
α kleines griechisches alpha α α
β kleines griechisches beta β β
γ kleines griechisches gamma γ γ
δ kleines griechisches delta δ δ
ε kleines griechisches epsilon ε ε
ζ kleines griechisches zeta ζ ζ
η kleines griechisches eta η η
θ kleines griechisches theta θ θ
ι kleines griechisches iota ι ι
κ kleines griechisches kappa κ κ
λ kleines griechisches lambda λ λ
μ kleines griechisches mu μ μ
ν kleines griechisches nu ν ν
ξ kleines griechisches xi ξ ξ
o kleines griechisches omicron ο ο
π kleines griechisches pi π π
ρ kleines griechisches rho ρ ρ
Ï‚ kleines griechisches finales sigma Ï‚ Ï‚
σ kleines griechisches sigma σ σ
Ï„ kleines griechisches tau Ï„ Ï„
Ï kleines griechisches ypsilon Ï Ï
φ kleines griechisches tau φ φ
χ kleines griechisches chi χ χ
ψ kleines griechisches psi ψ ψ
ω kleines griechisches omega ω ω

#153 #149 #133 #134 #135 #131 #036 #137 #140 #248 #156 #138 #154

SUTOM #248 2/6

🟥🟥🟥🟡🟦🟡🟡🟡🟦
🟥🟥🟥🟥🟥🟥🟥🟥🟥

https://sutom.nocle.fr

Full Circle Weekly News #248

https://fullcirclemagazine.org/podcast/full-circle-weekly-news-248/

cc// @Dr. Roy Schestowitz (罗伊)

Cramming a C64 BASIC program into 32 bytes (and my 23 byte version)

Here's a video showing how someone crammed a BASIC program into 32 bytes:

0 PRINTMID$("XXXX-|",RAND(0)*6+1,1);:GOTO

https://www.youtube.com/watch?v=oPtjcSsS2MI

Normally this would save to a 35 byte file, but certain tricks and a possibly dubious assumption (that works on emulators but not necessarily real hardware) shave off a few bytes.

Anyway, inspired by this I crammed my own version into only 23 bytes using machine code instead of BASIC. I had never written an autostarting prg so that was an interesting learning experience.

There are a few ways to autorun, but most require a lot of bytes of boiler plate. In order to cram my version into 23 bytes, I had to figure out a method that I eventually reduced to zero bytes of boiler plate (by reusing bytes that would become part of my lookup table). This stack overwrite method involves locating the program on the 6502 stack, such that it overwrites the pending JSR return address. I had to figure out how to ensure both of these bytes would be non-printing character codes. Furthermore, the program requires calling the CHROUT routine, meaning it would ALSO be pushing an address onto the stack. I needed this address to also consist of non-printing characters.

I also saved a byte by finding some place in zero page guaranteed to have a pointer I could use for an indirect table lookup (one byte zero page address indirect lookup rather than two byte address direct lookup). That was a crazy wild goose chase, but I did eventually find a couple bytes guaranteed to have 255, 0 in them. At that point, all I needed to do was refactor things to generate 248...255 randomly rather than 0...7 randomly.

So basically, I started off with something I fit in 27 bytes, with reasonably elegant comprehensible code. And then I shrunk it down to 23 bytes with increasingly obtuse hacks.

; Program: maze23byte.asm
; About: 23 byte print maze

; machine code version of 32 byte BASIC maze program:

; Size Optimizing Tricks in 10 PRINT Orthogonal for Commodore 64
; Jul 28, 2021
; https://www.youtube.com/watch?v=oPtjcSsS2MI

; autorun ref https://www.pagetable.com/?p=568

; target processor
  processor 6502

; code origin
  .org $01F8-1          ; Writing to stack for JSR return

table:                  ; PETSCII print code table at 255+248 ... 255+255
                        ; This is because I found PEEK(58)+PEEK(59)*256 = 255 in zero page.
                        ; Thus, letting me replace a 3 byte table lookup with a 2 byte indirect lookup

  .byte 96              ; horizontal bar - located here to align $01F8 JSR return address as needed

  .word autostart-1     ; JSR return will increment by 1
                        ; autostart-1 is non-printing chars
                        ; Also important is that JSR return address will also be non-printing chars

  .byte 171,177,178,179 ; T shapes
  .byte 125             ; vertical bar

CHROUT = $FFD2     ; KERNAL CHROUT
RASTER = $D012     ; Raster counter

loop:
  lda (58),y       ; shaves a byte compared to normal table lookup PEEK(58)=255, PEEK(59)=0

  jsr CHROUT       ; location of this JSR needs to end on address that will be non-printing chars

autostart:         ; autostart starts here, address chosen to be non-printing chars

  eor RASTER       ; generate kinda random byte
  ora #248         ; modulo 8 + 248
  tay
  bmi loop         ; branch shaves a byte compared to JMP

Source and prg here: http://isaackuo.cloudapp.net/stuff/maze27byte/

#RetroComputing #6502 #C64 #Commodore64 #Commodore