Ticket #9293: 0004-Added-comments-documenting-terminfo-termcap-capabili.patch

File 0004-Added-comments-documenting-terminfo-termcap-capabili.patch, 18.9 KB (added by Ziusudra, 11 years ago)

  • src/apps/terminal/TermParse.cpp 

    From 1ba039397ea6b16f71350eb06f27b033f4ccaf3d Mon Sep 17 00:00:00 2001
From: Ziusudra <ziusudra@gmail.com>
Date: Sat, 15 Dec 2012 21:16:49 -0700
Subject: [PATCH 4/9] Added comments documenting terminfo/termcap capabilities

 - No functional change intended
 - Mainly focused on termcap, so may be missing a few terminfo capabilities
---
 src/apps/terminal/TermParse.cpp |  263 +++++++++++++++++++++++++++------------
 1 file changed, 181 insertions(+), 82 deletions(-)

diff --git a/src/apps/terminal/TermParse.cpp b/src/apps/terminal/TermParse.cpp
index 8b48806..9f02d54 100644
    a b TermParse::EscParse()  
    478478                    break;
    479479
    480480                case CASE_PRINT_GRA:
    481                     /* "Special characters and line drawing" enabled by \E(0 */
     481                    // Special characters and line drawing
     482                    // terminfo smacs=\E(0, rmacs=\E(B, acsc=aajjkk...
     483                    // termcap  as=\E(0:ae=\E(B:ac=aajjkk...
     484                    // acsc/ac should include each letter we have a case for
    482485                    switch (c) {
    483486                        case 'a': // ACS_CKBOARD
    484487                            fBuffer->InsertChar("\xE2\x96\x92",3,fAttr);
    … … TermParse::EscParse()  
    526529                    break;
    527530
    528531                case CASE_CR:
     532                    // terminfo cr=^M, nel=^J
     533                    // termcap  cr=^M:nw=^J
    529534                    fBuffer->InsertCR(fAttr);
    530535                    break;
    531536
    … … TermParse::EscParse()  
    578583                    break;
    579584
    580585                case CASE_MBCS:
    581                     /* ESC $ */
     586                    // ESC $
    582587                    parsestate = gMbcsTable;
    583588                    break;
    584589
    585590                case CASE_GSETS:
    586                     /* ESC $ ? */
     591                    // ESC $ ?
    587592                    parsestate = gCS96GroundTable;
    588593                    //      cs96 = 1;
    589594                    break;
    590595
     596                //case CASE_GSETS:
     597                //  screen->gsets[scstype] = GSET(c) | cs96;
     598                //  parsestate = groundtable;
     599                //  break;
     600
    591601                case CASE_SCS_STATE:
    592602                {
    593603                    char page = _NextParseChar();
    … … TermParse::EscParse()  
    614624                }
    615625
    616626                case CASE_GROUND_STATE:
    617                     /* exit ignore mode */
     627                    // exit ignore mode
    618628                    parsestate = groundtable;
    619629                    break;
    620630
    621631                case CASE_BELL:
     632                    // terminfo bel=^G
     633                    // termcap  bl=^G
    622634                    beep();
    623635                    break;
    624636
    … … TermParse::EscParse()  
    627639                    break;
    628640
    629641                case CASE_TAB:
     642                    // terminfo ht=^I
     643                    // termcap  ta=^I
    630644                    fBuffer->InsertTab(fAttr);
    631645                    break;
    632646
    633647                case CASE_ESC:
    634                     /* escape */
     648                    // escape
    635649                    parsestate = gEscTable;
    636650                    break;
    637651
    638652                case CASE_IGNORE_STATE:
    639                     /* Ies: ignore anything else */
     653                    // Ies: ignore anything else
    640654                    parsestate = gIgnoreTable;
    641655                    break;
    642656
    643657                case CASE_IGNORE_ESC:
    644                     /* Ign: escape */
     658                    // Ign: escape
    645659                    parsestate = gIesTable;
    646660                    break;
    647661
    648662                case CASE_IGNORE:
    649                     /* Ignore character */
     663                    // Ignore character
    650664                    break;
    651665
    652666                case CASE_SI:
    653                     /* shift in (to G1 charset) */
     667                    // shift in (to G1 charset)
    654668                    if (shifted_in == false) {
    655669                        int* tmp = alternateParseTable;
    656670                        alternateParseTable = parsestate;
    … … TermParse::EscParse()  
    659673                    break;
    660674
    661675                case CASE_SO:
    662                     /* shift out (to G0 charset) */
     676                    // shift out (to G0 charset)
    663677                    if (shifted_in == true) {
    664678                        int* tmp = alternateParseTable;
    665679                        alternateParseTable = parsestate;
    … … TermParse::EscParse()  
    667681                    }
    668682                    break;
    669683
    670                 case CASE_SCR_STATE:    // ESC #
    671                     /* enter scr state */
     684                case CASE_SCR_STATE:
     685                    // enter scr state: ESC #
    672686                    parsestate = gScrTable;
    673687                    break;
    674688
    675689                case CASE_ESC_IGNORE:
    676                     /* unknown escape sequence */
     690                    // unknown escape sequence
    677691                    parsestate = gEscIgnoreTable;
    678692                    break;
    679693
    680                 case CASE_ESC_DIGIT:    // ESC [ number
    681                     /* digit in csi or dec mode */
     694                case CASE_ESC_DIGIT:
     695                    // digit in csi or dec mode: ESC [ number
    682696                    if ((row = param[nparam - 1]) == DEFAULT)
    683697                        row = 0;
    684698                    param[nparam - 1] = 10 * row + (c - '0');
    685699                    break;
    686700
    687                 case CASE_ESC_SEMI:     // ESC ;
    688                     /* semicolon in csi or dec mode */
     701                case CASE_ESC_SEMI:
     702                    // semicolon in csi or dec mode: ESC ;
    689703                    if (nparam < NPARAM)
    690704                        param[nparam++] = DEFAULT;
    691705                    break;
    692706
    693707                case CASE_DEC_STATE:
    694                     /* enter dec mode */
     708                    // Enter dec mode: ESC [ ?
    695709                    parsestate = gDecTable;
    696710                    break;
    697711
    698                 case CASE_ICH:      // ESC [@ insert charactor
    699                     /* ICH */
     712                case CASE_ICH:
     713                    // terminfo ich1=\E[@, ich=\E[%p1%d@
     714                    // termcap  ic=\E[@:IC=\E[%d@
     715                    // do not claim, im/ei (CASE_SET/RST) are prefered
    700716                    if ((row = param[0]) < 1)
    701717                        row = 1;
    702718                    fBuffer->InsertSpace(row);
    703719                    parsestate = groundtable;
    704720                    break;
    705721
    706                 case CASE_CUU:      // ESC [A cursor up, up arrow key.
    707                     /* CUU */
     722                case CASE_CUU:
     723                    // terminfo cuu1=\E[A, cuu=\E[%p1%dA
     724                    // termcap  up=\E[A:UP=\E[%dA
    708725                    if ((row = param[0]) < 1)
    709726                        row = 1;
    710727                    fBuffer->MoveCursorUp(row);
    711728                    parsestate = groundtable;
    712729                    break;
    713730
    714                 case CASE_CUD:      // ESC [B cursor down, down arrow key.
    715                     /* CUD */
     731                case CASE_CUD:
     732                    // terminfo cud1=^K, cud=\E[%p1%dB
     733                    // termcap  do=^K:DO=\E[%dB
    716734                    if ((row = param[0]) < 1)
    717735                        row = 1;
    718736                    fBuffer->MoveCursorDown(row);
    719737                    parsestate = groundtable;
    720738                    break;
    721739
    722                 case CASE_CUF:      // ESC [C cursor forword
    723                     /* CUF */
     740                case CASE_CUF:
     741                    // terminfo cuf1=\E[C, cuf=\E[%p1%dC
     742                    // termcap  nd=\E[C:RI=\E[%dC
    724743                    if ((row = param[0]) < 1)
    725744                        row = 1;
    726745                    fBuffer->MoveCursorRight(row);
    727746                    parsestate = groundtable;
    728747                    break;
    729748
    730                 case CASE_CUB:      // ESC [D cursor backword
    731                     /* CUB */
     749                case CASE_CUB:
     750                    // terminfo cub1=^H, cub=\E[%p1%dD
     751                    // termcap  le=^H:LE=\E[%dD
    732752                    if ((row = param[0]) < 1)
    733753                        row = 1;
    734754                    fBuffer->MoveCursorLeft(row);
    735755                    parsestate = groundtable;
    736756                    break;
    737757
    738                 case CASE_CUP:      // ESC [...H move cursor
    739                     /* CUP | HVP */
     758                case CASE_CUP:
     759                    // terminfo home=\E[H, cup=\E[%i%p1%d;%p2%dH
     760                    // termcap  ho=\E[H:cm=\E[%i%d;%dH
    740761                    if ((row = param[0]) < 1)
    741762                        row = 1;
    742763                    if (nparam < 2 || (column = param[1]) < 1)
    … … TermParse::EscParse()  
    746767                    parsestate = groundtable;
    747768                    break;
    748769
    749                 case CASE_ED:       // ESC [ ...J clear screen
    750                     /* ED */
     770                case CASE_ED:
    751771                    switch (param[0]) {
    752772                        case DEFAULT:
    753773                        case 0:
     774                            // terminfo ed=\E[J
     775                            // termcap  cd=\E[J
    754776                            fBuffer->EraseBelow();
    755777                            break;
    756778
    … … TermParse::EscParse()  
    759781                            break;
    760782
    761783                        case 2:
     784                            // terminfo clear=\E[H\E[2J
     785                            // termcap  cl=\E[H\E[2J
    762786                            fBuffer->EraseAll();
    763787                            break;
    764788                    }
    765789                    parsestate = groundtable;
    766790                    break;
    767791
    768                 case CASE_EL:       // ESC [ ...K delete line
    769                     /* EL */
     792                case CASE_EL:
    770793                    switch (param[0]) {
    771794                        case DEFAULT:
    772795                        case 0:
     796                            // clear to end of line
     797                            // terminfo el=\E[K
     798                            // termcap  ce=\E[K
    773799                            fBuffer->DeleteColumns();
    774800                            break;
    775801
    776802                        case 1:
     803                            // clear to begin of line
     804                            // terminfo el1=\E[1K
     805                            // termcap  cb=\E[1K
    777806                            fBuffer->EraseCharsFrom(0, fBuffer->Cursor().x + 1);
    778807                            break;
    779808
    … … TermParse::EscParse()  
    785814                    break;
    786815
    787816                case CASE_IL:
    788                     /* IL */
     817                    // terminfo il1=\E[L, il=\E[%p1%dL
     818                    // termcap  al=\E[L:AL=\E[%dL
    789819                    if ((row = param[0]) < 1)
    790820                        row = 1;
    791821                    fBuffer->InsertLines(row);
    … … TermParse::EscParse()  
    793823                    break;
    794824
    795825                case CASE_DL:
    796                     /* DL */
     826                    // terminfo dl1=\E[M, dl=\E[%p1%dM
     827                    // termcap  dl=\E[M:DL=\E[%dM
    797828                    if ((row = param[0]) < 1)
    798829                        row = 1;
    799830                    fBuffer->DeleteLines(row);
    … … TermParse::EscParse()  
    801832                    break;
    802833
    803834                case CASE_DCH:
    804                     /* DCH */
     835                    // terminfo dch1=\E[P, dch=\E[%p1%dP
     836                    // termcap  dc=\E[P:DC=\E[%dP
    805837                    if ((row = param[0]) < 1)
    806838                        row = 1;
    807839                    fBuffer->DeleteChars(row);
    … … TermParse::EscParse()  
    809841                    break;
    810842
    811843                case CASE_SET:
    812                     /* SET */
     844                    // terminfo smir=\E[4h
     845                    // termcap  im=\E[4h
    813846                    if (param[0] == 4)
    814847                        fBuffer->SetInsertMode(MODE_INSERT);
    815848                    parsestate = groundtable;
    816849                    break;
    817850
    818851                case CASE_RST:
    819                     /* RST */
     852                    // terminfo rmir=\E[4l
     853                    // termcap  ei=\E[4l
    820854                    if (param[0] == 4)
    821855                        fBuffer->SetInsertMode(MODE_OVER);
    822856                    parsestate = groundtable;
    … … TermParse::EscParse()  
    824858
    825859                case CASE_SGR:
    826860                {
    827                     /* SGR */
     861                    // Select graphic rendition: ESC [ ... m
    828862                    for (row = 0; row < nparam; ++row) {
    829863                        switch (param[row]) {
    830864                            case DEFAULT:
    831                             case 0: /* Reset attribute */
     865                            case 0: // Reset attribute
     866                                // terminfo sgr0=\E[0m
     867                                // termcap  me=\E[0m
    832868                                fAttr = FORECOLORED(7);
    833869                                break;
    834870
    835                             case 1: /* Bold     */
    836                             case 5:
     871                            case 1: // Bold
     872                                // terminfo bold=\E[1m
     873                                // termcap  md=\E[1m
     874                            case 5: // Blink
    837875                                fAttr |= BOLD;
    838876                                break;
    839877
    840                             case 4: /* Underline    */
     878                            case 4: // Underline
     879                                // terminfo smul=\E[4m
     880                                // termcap  us=\E[4m
    841881                                fAttr |= UNDERLINE;
    842882                                break;
    843883
    844                             case 7: /* Inverse  */
     884                            case 7: // Inverse
     885                                // terminfo smso=\E[7m
     886                                // termcap  so=\E[7m
    845887                                fAttr |= INVERSE;
    846888                                break;
    847889
    848                             case 22:    /* Not Bold */
     890                            case 22: // Not Bold
    849891                                fAttr &= ~BOLD;
    850892                                break;
    851893
    852                             case 24:    /* Not Underline    */
     894                            case 24: // Not Underline
     895                                // terminfo rmul=\E[24m
     896                                // termcap  ue=\E[24m
    853897                                fAttr &= ~UNDERLINE;
    854898                                break;
    855899
    856                             case 27:    /* Not Inverse  */
     900                            case 27: // Not Inverse
     901                                // terminfo rmso=\E[27m
     902                                // termcap  se=\E[27m
    857903                                fAttr &= ~INVERSE;
    858904                                break;
    859905
    … … TermParse::EscParse()  
    872918
    873919                            case 38:
    874920                            {
     921                                // terminfo setaf=\E[38;5;%p1%dm
     922                                // termcap  AF=\E[38;5;%dm
    875923                                if (nparam != 3 || param[1] != 5)
    876924                                    break;
    877925                                fAttr &= ~FORECOLOR;
    … … TermParse::EscParse()  
    884932                            }
    885933
    886934                            case 39:
     935                                // terminfo op=\E[39;49m
     936                                // termcap  op=\E[39;49m
    887937                                fAttr &= ~FORESET;
    888938                                break;
    889939
    … … TermParse::EscParse()  
    902952
    903953                            case 48:
    904954                            {
     955                                // terminfo setab=\E[48;5;%p1%dm
     956                                // termcap  AB=\E[48;5;%dm
    905957                                if (nparam != 3 || param[1] != 5)
    906958                                    break;
    907959                                fAttr &= ~BACKCOLOR;
    … … TermParse::EscParse()  
    925977                case CASE_CPR:
    926978                    // Q & D hack by Y.Hayakawa 21-JUL-99
    927979                    // (hida@sawada.riec.tohoku.ac.jp)
     980                    // ESC [ %d n
    928981                    _DeviceStatusReport(param[0]);
    929982                    parsestate = groundtable;
    930983                    break;
    931984
    932985                case CASE_DA1:
    933                     // DA - report device attributes
     986                    // Report device attributes: ESC Z or ESC [ c
     987                    // terminfo u9=\E[c
     988                    // termcap  u9=\E[c
    934989                    if (param[0] < 1) {
    935990                        // claim to be a VT102
    936991                        write(fFd, "\033[?6c", 5);
    … … TermParse::EscParse()  
    939994                    break;
    940995
    941996                case CASE_DECSTBM:
    942                     /* DECSTBM - set scrolling region */
     997                    // Set scrolling region
     998                    // terminfo csr=\E[%i%p1%d;%p2%dr
     999                    // termcap  cs=\E[%i%d;%dr
    9431000                    if ((top = param[0]) < 1)
    9441001                        top = 1;
    9451002
    … … TermParse::EscParse()  
    9581015                    break;
    9591016
    9601017                case CASE_DECREQTPARM:
    961                     // DEXREQTPARM - request terminal parameters
     1018                    // Request terminal parameters: ESC [ %d x
    9621019                    _DecReqTermParms(param[0]);
    9631020                    parsestate = groundtable;
    9641021                    break;
    9651022
    9661023                case CASE_DECSET:
    967                     /* DECSET */
     1024                    // DEC Private Mode Reset: ESC [ ? %d h
    9681025                    for (int i = 0; i < nparam; i++)
    9691026                        _DecPrivateModeSet(param[i]);
    9701027                    parsestate = groundtable;
    9711028                    break;
    9721029
    9731030                case CASE_DECRST:
    974                     /* DECRST */
     1031                    // DEC Private Mode Reset: ESC [ ? %d l
    9751032                    for (int i = 0; i < nparam; i++)
    9761033                        _DecPrivateModeReset(param[i]);
    9771034                    parsestate = groundtable;
    9781035                    break;
    9791036
    9801037                case CASE_DECALN:
    981                     /* DECALN */
     1038                    // DEC screen alignment test: ESC # 8
    9821039                    fBuffer->FillScreen(UTF8Char('E'), 1, 0);
    9831040                    parsestate = groundtable;
    9841041                    break;
    9851042
    986                 //case CASE_GSETS:
    987                 //  screen->gsets[scstype] = GSET(c) | cs96;
    988                 //  parsestate = groundtable;
    989                 //  break;
    990 
    9911043                case CASE_DECSC:
    992                     /* DECSC */
     1044                    // Save current cursor state
     1045                    // terminfo sc=\E7
     1046                    // termcap  sc=\E7
    9931047                    _DecSaveCursor();
    9941048                    parsestate = groundtable;
    9951049                    break;
    9961050
    9971051                case CASE_DECRC:
    998                     /* DECRC */
     1052                    // Restore saved cursor state
     1053                    // terminfo rc=\E8
     1054                    // termcap  rc=\E8
    9991055                    _DecRestoreCursor();
    10001056                    parsestate = groundtable;
    10011057                    break;
    10021058
    10031059                case CASE_HTS:
    1004                     /* HTS */
     1060                    // Set tab stop at current column
     1061                    // terminfo hts=\EH
     1062                    // termcap  st=\EH
    10051063                    fBuffer->SetTabStop(fBuffer->Cursor().x);
    10061064                    parsestate = groundtable;
    10071065                    break;
    10081066
    10091067                case CASE_TBC:
    1010                     /* TBC */
     1068                    // Clear all tab stops
     1069                    // terminfo tbc=\E[3g
     1070                    // termcap  ct=\E[3g
    10111071                    if (param[0] < 1)
    10121072                        fBuffer->ClearTabStop(fBuffer->Cursor().x);
    10131073                    else if (param[0] == 3)
    … … TermParse::EscParse()  
    10161076                    break;
    10171077
    10181078                case CASE_RI:
    1019                     /* RI */
     1079                    // Reverse linefeed: ESC M
    10201080                    fBuffer->InsertRI();
    10211081                    parsestate = groundtable;
    10221082                    break;
    10231083
    10241084                case CASE_SS2:
    1025                     /* SS2 */
     1085                    // Single shift 2. (Select G2 character set for the next
     1086                    // character only.): ESC N
    10261087                    curess = c;
    10271088                    parsestate = groundtable;
    10281089                    break;
    10291090
    10301091                case CASE_SS3:
    1031                     /* SS3 */
     1092                    // Single shift 3. (Select G3 character set for the next
     1093                    // character only.): ESC O
    10321094                    curess = c;
    10331095                    parsestate = groundtable;
    10341096                    break;
    10351097
    10361098                case CASE_CSI_STATE:
    1037                     /* enter csi state */
     1099                    // Enter CSI state: ESC [
    10381100                    nparam = 1;
    10391101                    param[0] = DEFAULT;
    10401102                    parsestate = gCsiTable;
    … … TermParse::EscParse()  
    10421104
    10431105                case CASE_OSC:
    10441106                {
    1045                     /* Operating System Command: ESC ] */
     1107                    // Operating System Command: ESC ]
    10461108                    char string[512];
    10471109                    uint32 len = 0;
    10481110                    uchar mode_char = _NextParseChar();
    … … TermParse::EscParse()  
    10741136                    break;
    10751137                }
    10761138
    1077                 case CASE_RIS:      // ESC c ... Reset terminal.
     1139                case CASE_RIS:
     1140                    // Reset terminal
     1141                    // terminfo rs1=\Ec
     1142                    // termcap  r1=\Ec
    10781143                    break;
    10791144
    10801145                case CASE_LS2:
    1081                     /* LS2 */
     1146                    // Invoke the G2 character set: ESC n
    10821147                    //screen->curgl = 2;
    10831148                    parsestate = groundtable;
    10841149                    break;
    10851150
    10861151                case CASE_LS3:
    1087                     /* LS3 */
     1152                    // Invoke the G3 character set: ESC o
    10881153                    //screen->curgl = 3;
    10891154                    parsestate = groundtable;
    10901155                    break;
    10911156
    10921157                case CASE_LS3R:
    1093                     /* LS3R */
     1158                    // Invoke the G3 character set as GR: ESC |
    10941159                    //screen->curgr = 3;
    10951160                    parsestate = groundtable;
    10961161                    break;
    10971162
    10981163                case CASE_LS2R:
    1099                     /* LS2R */
     1164                    // Invoke the G2 character set as GR: ESC }
    11001165                    //screen->curgr = 2;
    11011166                    parsestate = groundtable;
    11021167                    break;
    11031168
    11041169                case CASE_LS1R:
    1105                     /* LS1R */
     1170                    // Invoke the G1 character set as GR: ESC ~
    11061171                    //screen->curgr = 1;
    11071172                    parsestate = groundtable;
    11081173                    break;
    11091174
    1110                 case CASE_VPA:      // ESC [...d move cursor absolute vertical
    1111                     /* VPA (CV) */
     1175                case CASE_VPA:
     1176                    // Move cursor absolute vertical
     1177                    // terminfo vpa=\E[%i%p1%dd
     1178                    // termcap  cv=\E[%i%dd
    11121179                    if ((row = param[0]) < 1)
    11131180                        row = 1;
    11141181
    … … TermParse::EscParse()  
    11171184                    parsestate = groundtable;
    11181185                    break;
    11191186
    1120                 case CASE_HPA:      // ESC [...G move cursor absolute horizontal
    1121                     /* HPA (CH) */
     1187                case CASE_HPA:
     1188                    // Move cursor absolute horizontal
     1189                    // terminfo hpa=\E[%i%p1%dG
     1190                    // termcap  ch=\E[%i%dG
    11221191                    if ((column = param[0]) < 1)
    11231192                        column = 1;
    11241193
    … … TermParse::EscParse()  
    11271196                    parsestate = groundtable;
    11281197                    break;
    11291198
    1130                 case CASE_SU:   // scroll screen up
     1199                case CASE_SU:
     1200                    // Scroll screen up (forward)
     1201                    // terminfo ind=\E[S, indn=\E[%p1%dS
     1202                    // termcap  sf=\E[S:SF=\E[%dS
    11311203                    if ((row = param[0]) < 1)
    11321204                        row = 1;
    11331205                    fBuffer->ScrollBy(row);
    11341206                    parsestate = groundtable;
    11351207                    break;
    11361208
    1137                 case CASE_SD:   // scroll screen down
     1209                case CASE_SD:
     1210                    // Scroll screen down (back)
     1211                    // terminfo ri=\E[T, rin=\E[%p1%dT
     1212                    // termcap  sr=\E[T:SR=\E[%dT
    11381213                    if ((row = param[0]) < 1)
    11391214                        row = 1;
    11401215                    fBuffer->ScrollBy(-row);
    11411216                    parsestate = groundtable;
    11421217                    break;
    11431218
    1144 
    1145                 case CASE_ECH:  // erase characters
     1219                case CASE_ECH:
     1220                    // Erase characters
     1221                    // terminfo ech=\E[%p1%dX
     1222                    // termcap  ec=\E[%dX
    11461223                    if ((column = param[0]) < 1)
    11471224                        column = 1;
    11481225                    fBuffer->EraseChars(column);
    … … TermParse::_DeviceStatusReport(int n)  
    12481325        }
    12491326        case 6:
    12501327            // Cursor position report requested
     1328            // terminfo u7=\E[6n
     1329            // termcap  u7=\E[6n
    12511330            len = sprintf(sbuf, "\033[%" B_PRId32 ";%" B_PRId32 "R",
    12521331                    fBuffer->Cursor().y + 1,
    12531332                    fBuffer->Cursor().x + 1);
    … … TermParse::_DecPrivateModeSet(int value)  
    12901369        case 1:
    12911370            // Application Cursor Keys (whatever that means).
    12921371            // Not supported yet.
     1372            // terminfo smkx=\E[?1h
     1373            // termcap  ks=\E[?1h ? many also do \E= ?
    12931374            break;
    12941375        case 5:
    12951376            // Reverse Video (inverses colors for the complete screen
    12961377            // -- when followed by normal video, that's shortly flashes the
    12971378            // screen).
    12981379            // Not supported yet.
     1380            // terminfo flash=\E[?5h\E[?5l
     1381            // termcap  vb=\E[?5h\E[?5l
    12991382            break;
    13001383        case 6:
    13011384            // Set Origin Mode.
    … … TermParse::_DecPrivateModeSet(int value)  
    13081391        case 12:
    13091392            // Start Blinking Cursor.
    13101393            // Not supported yet.
     1394            // terminfo cvvis=\E[?12;25h
     1395            // termcap  vs=\E[?12;25h
    13111396            break;
    13121397        case 25:
    13131398            // Show Cursor.
    13141399            // Not supported yet.
     1400            // terminfo cnorm=\E[?12l\E[?25h
     1401            // termcap  ve=\E[?12l\E[?25h
    13151402            break;
    13161403        case 47:
    13171404            // Use Alternate Screen Buffer.
    … … TermParse::_DecPrivateModeSet(int value)  
    13331420        case 1034:
    13341421            // TODO: Interprete "meta" key, sets eighth bit.
    13351422            // Not supported yet.
     1423            // terminfo smm=\E[?1034h
     1424            // termcap  mm=\E[?1034h
    13361425            break;
    13371426        case 1036:
    13381427            // TODO: Send ESC when Meta modifies a key
    … … TermParse::_DecPrivateModeSet(int value)  
    13451434        case 1049:
    13461435            // Save cursor as in DECSC and use Alternate Screen Buffer, clearing
    13471436            // it first.
     1437            // terminfo smcup=\E[?1049h
     1438            // termcap  ti=\E[?1049h
    13481439            _DecSaveCursor();
    13491440            fBuffer->UseAlternateScreenBuffer(true);
    13501441            break;
    … … TermParse::_DecPrivateModeReset(int value)  
    13591450        case 1:
    13601451            // Normal Cursor Keys (whatever that means).
    13611452            // Not supported yet.
     1453            // terminfo rmkx=\E[?1l
     1454            // termcap  ke=\E[?1l ? many also do \E> ?
    13621455            break;
    13631456        case 3:
    13641457            // 80 Column Mode.
    … … TermParse::_DecPrivateModeReset(int value)  
    13871480        case 25:
    13881481            // Hide Cursor
    13891482            // Not supported yet.
     1483            // terminfo civis=\E[?25l
     1484            // termcap  vi=\E[?25l
    13901485            break;
    13911486        case 47:
    13921487            // Use Normal Screen Buffer.
    … … TermParse::_DecPrivateModeReset(int value)  
    14081503        case 1034:
    14091504            // Don't interprete "meta" key.
    14101505            // Not supported yet.
     1506            // terminfo rmm=\E[?1034l
     1507            // termcap  mo=\E[?1034l
    14111508            break;
    14121509        case 1036:
    14131510            // TODO: Don't send ESC when Meta modifies a key
    … … TermParse::_DecPrivateModeReset(int value)  
    14191516            break;
    14201517        case 1049:
    14211518            // Use Normal Screen Buffer and restore cursor as in DECRC.
     1519            // terminfo rmcup=\E[?1049l
     1520            // termcap  te=\E[?1049l
    14221521            fBuffer->UseNormalScreenBuffer();
    14231522            _DecRestoreCursor();
    14241523            break;