home *** CD-ROM | disk | FTP | other *** search
/ Amiga Times / AmigaTimes.iso / internet / Term / Extras / Source / term-source.lha / Console.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-10-20  |  25.4 KB  |  1,427 lines
  1. /*
  2. **    Console.c
  3. **
  4. **    High-level terminal console routines
  5. **
  6. **    Copyright © 1990-1996 by Olaf `Olsen' Barthel
  7. **        All Rights Reserved
  8. **
  9. **    :ts=4
  10. */
  11.  
  12. #ifndef _GLOBAL_H
  13. #include "Global.h"
  14. #endif
  15.  
  16.     /* Temporary console working buffer. */
  17.  
  18. STATIC UBYTE ConTempBuffer[512];
  19.  
  20. typedef VOID (* CALLBACK)(STRPTR,LONG);
  21.  
  22. /* How this stuff works:
  23.  *
  24.  *    This file holds the text output routines. The main entry point is
  25.  *    ConTransfer (actually a function pointer). This routine feeds the
  26.  *    input buffer into XProtocolHostMon(), a callback routine of the
  27.  *    currently active XPR library. Control then passes to ConProcess().
  28.  *    The incoming data is filtered through the flow scanner (FlowFilter),
  29.  *    passed through the capture routines (CaptureData), the script recorder
  30.  *    (RememberOutputText) and the trap scanner (TrapFilter). The data then
  31.  *    goes through the text processing routine ConProcessData (another
  32.  *    function pointer) which processes the embedded control sequences and
  33.  *    eventually feeds the raw text into ConDump (yet another function
  34.  *    pointer). This routine does the final text output.
  35.  */
  36.  
  37.     /* GfxText(struct RastPort *RPort,STRPTR Buffer,LONG Length):
  38.      *
  39.      *    Text output, if necessary switching from gfx font
  40.      *    to current default font.
  41.      */
  42.  
  43. STATIC VOID
  44. GfxText(struct RastPort *RPort,STRPTR Buffer,LONG Length)
  45. {
  46.         /* Character set modes. */
  47.  
  48.     enum { MODE_STANDARD,MODE_GFX };
  49.  
  50.     struct TextFont *Font;
  51.     WORD TextMode;
  52.     LONG SameMode;
  53.  
  54.         /* Determine current text rendering mode. */
  55.  
  56.     TextMode = GfxTable[Buffer[0]];
  57.  
  58.     if(TextMode == MODE_GFX)
  59.         Font = GFX;
  60.     else
  61.         Font = TextFont;
  62.  
  63.     SetFont(RPort,Font);
  64.  
  65.         /* Reset number of characters in common mode. */
  66.  
  67.     SameMode = 0;
  68.  
  69.         /* Scan until all input is processed. */
  70.  
  71.     do
  72.     {
  73.             /* Scan for characters in the current mode. */
  74.  
  75.         while(GfxTable[Buffer[SameMode]] == TextMode && SameMode < Length)
  76.             SameMode++;
  77.  
  78.             /* Output the text found. */
  79.  
  80.         Text(RPort,Buffer,SameMode);
  81.  
  82.             /* Decrement number of remaining bytes. */
  83.  
  84.         Length -= SameMode;
  85.  
  86.             /* Anything left? */
  87.  
  88.         if(Length > 0)
  89.         {
  90.                 /* Skip to next character. */
  91.  
  92.             Buffer += SameMode;
  93.             SameMode = 0;
  94.  
  95.                 /* Change text output mode. */
  96.  
  97.             if(TextMode == MODE_GFX)
  98.             {
  99.                 TextMode = MODE_STANDARD;
  100.                 Font = TextFont;
  101.             }
  102.             else
  103.             {
  104.                 TextMode = MODE_GFX;
  105.                 Font = GFX;
  106.             }
  107.  
  108.             SetFont(RPort,Font);
  109.         }
  110.     }
  111.     while(Length > 0);
  112.  
  113.         /* Reset font type. */
  114.  
  115.     if(TextMode == MODE_GFX)
  116.         SetFont(RPort,TextFont);
  117. }
  118.  
  119. /****************************************************************************/
  120.  
  121.     /* ConTranslateSetup():
  122.      *
  123.      *    Set up for buffer translation.
  124.      */
  125.  
  126. STATIC VOID
  127. ConTranslateSetup(struct TranslationHandle *Handle,STRPTR SourceBuffer,LONG SourceLen,STRPTR DestinationBuffer,LONG DestinationLen,struct TranslationEntry **Table)
  128. {
  129.     Handle->LocalBuffer            = NULL;
  130.     Handle->LocalLen            = 0;
  131.  
  132.     Handle->SourceBuffer        = SourceBuffer;
  133.     Handle->SourceLen            = SourceLen;
  134.  
  135.     Handle->DestinationBuffer    = DestinationBuffer;
  136.     Handle->DestinationLen        = DestinationLen;
  137.  
  138.     Handle->Table                = Table;
  139. }
  140.  
  141.     /* ConTranslateBuffer(struct TranslationHandle *Handle):
  142.      *
  143.      *    Translate buffer contents according to
  144.      *    translation table contents.
  145.      */
  146.  
  147. STATIC LONG
  148. ConTranslateBuffer(struct TranslationHandle *Handle)
  149. {
  150.     struct TranslationEntry *Entry;
  151.     LONG BytesWritten;
  152.     STRPTR Data;
  153.  
  154.     Data = Handle->DestinationBuffer;
  155.     BytesWritten = 0;
  156.  
  157.         /* Are we to return any translated data? */
  158.  
  159.     while(Handle->LocalLen && BytesWritten < Handle->DestinationLen)
  160.     {
  161.             /* Decrement number of bytes in buffer. */
  162.  
  163.         Handle->LocalLen--;
  164.  
  165.             /* Return next character. */
  166.  
  167.         *Data++ = *Handle->LocalBuffer++;
  168.  
  169.             /* Add another byte. */
  170.  
  171.         BytesWritten++;
  172.     }
  173.  
  174.         /* Loop until done. */
  175.  
  176.     while(Handle->SourceLen && BytesWritten < Handle->DestinationLen)
  177.     {
  178.             /* Another byte eaten. */
  179.  
  180.         Handle->SourceLen--;
  181.  
  182.             /* Get table entry. */
  183.  
  184.         if(Entry = Handle->Table[*Handle->SourceBuffer++])
  185.         {
  186.                 /* Copy to local data area. */
  187.  
  188.             Handle->LocalBuffer    = Entry->String;
  189.             Handle->LocalLen    = Entry->Len;
  190.  
  191.                 /* Translate the data. */
  192.  
  193.             while(Handle->LocalLen && BytesWritten < Handle->DestinationLen)
  194.             {
  195.                     /* Decrement number of bytes in buffer. */
  196.  
  197.                 Handle->LocalLen--;
  198.  
  199.                     /* Return next character. */
  200.  
  201.                 *Data++ = *Handle->LocalBuffer++;
  202.  
  203.                     /* Add another byte. */
  204.  
  205.                 BytesWritten++;
  206.             }
  207.         }
  208.     }
  209.  
  210.     return(BytesWritten);
  211. }
  212.  
  213.     /* ConOutputTranslate(STRPTR Buffer,LONG Size):
  214.      *
  215.      *    Frontend for ConOutput(), including character translation.
  216.      */
  217.  
  218. STATIC VOID
  219. ConOutputTranslate(STRPTR Buffer,LONG Size)
  220. {
  221.     struct TranslationHandle Handle;
  222.     UBYTE LocalBuffer[256];
  223.  
  224.         /* Set up for translation. */
  225.  
  226.     ConTranslateSetup(&Handle,Buffer,Size,LocalBuffer,sizeof(LocalBuffer),ReceiveTable);
  227.  
  228.         /* Process and output the data. */
  229.  
  230.     while(Size = ConTranslateBuffer(&Handle))
  231.         (* ConOutput)(LocalBuffer,Size);
  232. }
  233.  
  234. /****************************************************************************/
  235.  
  236.     /* ConOutputPrinter(STRPTR Buffer,LONG Size):
  237.      *
  238.      *    Raw text output routine, printer capture flavour.
  239.      */
  240.  
  241. STATIC VOID
  242. ConOutputPrinter(STRPTR Buffer,LONG Size)
  243. {
  244.     if(Write(PrinterCapture,Buffer,Size) != Size)
  245.     {
  246.         BlockWindows();
  247.  
  248.         if(!ShowRequest(NULL,LocaleString(MSG_CONSOLE_ERROR_WRITING_TO_PRINTER_TXT),LocaleString(MSG_CONSOLE_IGNORE_CLOSE_PRINTER_TXT)))
  249.             ClosePrinterCapture(TRUE);
  250.  
  251.         ReleaseWindows();
  252.     }
  253. }
  254.  
  255.     /* ConOutputGFX(STRPTR Buffer,LONG Size):
  256.      *
  257.      *    Raw text output routine, GFX text flavour.
  258.      */
  259.  
  260. STATIC VOID
  261. ConOutputGFX(STRPTR Buffer,LONG Size)
  262. {
  263.     LONG Offset;
  264.  
  265.         /* Do we still have a character in the
  266.          * magnificient buffer?
  267.          */
  268.  
  269.     while(Size)
  270.     {
  271.             /* Cursor is positioned at
  272.              * the right hand side of the
  273.              * display. If auto-wrap is
  274.              * enabled, perform some
  275.              * kind of CR/LF, else leave
  276.              * the cursor where it is and
  277.              * quit the show.
  278.              */
  279.  
  280.         if(CursorX > LastPrintableColumn)
  281.         {
  282.                 /* Wrap cursor. */
  283.  
  284.             if(Config->EmulationConfig->LineWrap)
  285.             {
  286.                     /* Move to beginning of next line. */
  287.  
  288.                 CursorX = 0;
  289.  
  290.                 DownLine();
  291.  
  292.                     /* Reposition cursor, don't redraw it. */
  293.  
  294.                 RepositionCursor();
  295.             }
  296.             else
  297.             {
  298.                     /* Stop the cursor. */
  299.  
  300.                 CursorX = LastPrintableColumn;
  301.  
  302.                     /* Make it reappear. */
  303.  
  304.                 RepositionCursor();
  305.  
  306.                 return;
  307.             }
  308.         }
  309.  
  310.         if((Offset = LastPrintableColumn + 1 - CursorX) > Size)
  311.             Offset = Size;
  312.  
  313.         if(Config->EmulationConfig->InsertMode)
  314.         {
  315.             RasterShiftChar(Offset);
  316.  
  317.             ScrollLineShiftChar(Offset);
  318.  
  319.             ShiftChar(Offset);
  320.         }
  321.  
  322.         RasterPutString(Buffer,Offset);
  323.  
  324.         ScrollLinePutString(Offset);
  325.  
  326.         if(FontScalingRequired)
  327.             PrintScaled(Buffer,Offset,CurrentFontScale);
  328.         else
  329.             GfxText(RPort,Buffer,Offset);
  330.  
  331.         Buffer    += Offset;
  332.  
  333.         Size    -= Offset;
  334.  
  335.         CursorX    += Offset;
  336.     }
  337.  
  338.     RepositionCursor();
  339. }
  340.  
  341.     /* ConOutputNormal(STRPTR Buffer,LONG Size):
  342.      *
  343.      *    Raw text output routine, normal text flavour.
  344.      */
  345.  
  346. STATIC VOID
  347. ConOutputNormal(STRPTR Buffer,LONG Size)
  348. {
  349.     LONG Offset;
  350.  
  351.     while(Size)
  352.     {
  353.         if(CursorX > LastPrintableColumn)
  354.         {
  355.             if(Config->EmulationConfig->LineWrap)
  356.             {
  357.                 CursorX = 0;
  358.  
  359.                 DownLine();
  360.  
  361.                 RepositionCursor();
  362.             }
  363.             else
  364.             {
  365.                 CursorX = LastPrintableColumn;
  366.  
  367.                 RepositionCursor();
  368.  
  369.                 return;
  370.             }
  371.         }
  372.  
  373.         if((Offset = LastPrintableColumn + 1 - CursorX) > Size)
  374.             Offset = Size;
  375.  
  376.         if(Config->EmulationConfig->InsertMode)
  377.         {
  378.             RasterShiftChar(Offset);
  379.  
  380.             ScrollLineShiftChar(Offset);
  381.  
  382.             ShiftChar(Offset);
  383.         }
  384.  
  385.         RasterPutString(Buffer,Offset);
  386.  
  387.         ScrollLinePutString(Offset);
  388.  
  389.         if(FontScalingRequired)
  390.             PrintScaled(Buffer,Offset,CurrentFontScale);
  391.         else
  392.             Text(RPort,Buffer,Offset);
  393.  
  394.         Buffer    += Offset;
  395.         Size    -= Offset;
  396.         CursorX    += Offset;
  397.     }
  398.  
  399.     RepositionCursor();
  400. }
  401.  
  402. /****************************************************************************/
  403.  
  404.     /* ConProcessDataTransExternal(STRPTR String,LONG Size):
  405.      *
  406.      *    Process data, external emulation including translation flavour.
  407.      */
  408.  
  409. STATIC VOID
  410. ConProcessDataTransExternal(STRPTR String,LONG Size)
  411. {
  412.     struct TranslationHandle Handle;
  413.  
  414.         /* Set up for translation. */
  415.  
  416.     ConTranslateSetup(&Handle,String,Size,ConTempBuffer,sizeof(ConTempBuffer) / 2,ReceiveTable);
  417.  
  418.     if(StripBuffer)
  419.     {
  420.         LONG Len;
  421.  
  422.             /* Process and output the data. */
  423.  
  424.         while(Size = ConTranslateBuffer(&Handle))
  425.         {
  426.             XEmulatorWrite(XEM_IO,ConTempBuffer,Size);
  427.  
  428.             XEM_HostData.Source            = ConTempBuffer;
  429.             XEM_HostData.Destination    = StripBuffer;
  430.  
  431.             if(Len = XEmulatorHostMon(XEM_IO,&XEM_HostData,Size))
  432.             {
  433.                 if(CaptureData)
  434.                     (*CaptureData)(StripBuffer,Len);
  435.             }
  436.         }
  437.     }
  438.     else
  439.     {
  440.             /* Process and output the data. */
  441.  
  442.         while(Size = ConTranslateBuffer(&Handle))
  443.             XEmulatorWrite(XEM_IO,ConTempBuffer,Size);
  444.     }
  445. }
  446.  
  447.     /* ConProcessDataExternal(STRPTR String,LONG Size):
  448.      *
  449.      *    Process data, external emulation flavour.
  450.      */
  451.  
  452. STATIC VOID
  453. ConProcessDataExternal(STRPTR String,LONG Size)
  454. {
  455.     XEmulatorWrite(XEM_IO,String,Size);
  456.  
  457.         /* Build another string to contain
  458.          * the pure ASCII contents, i.e.
  459.          * not including any ESC control
  460.          * sequences.
  461.          */
  462.  
  463.     if(StripBuffer)
  464.     {
  465.         LONG Len;
  466.  
  467.         XEM_HostData.Source            = String;
  468.         XEM_HostData.Destination    = StripBuffer;
  469.  
  470.         if(Len = XEmulatorHostMon(XEM_IO,&XEM_HostData,Size))
  471.         {
  472.             if(CaptureData)
  473.                 (*CaptureData)(StripBuffer,Len);
  474.         }
  475.     }
  476. }
  477.  
  478.     /* ConProcessDataGeneric(STRPTR String,LONG Size,Mask):
  479.      *
  480.      *    Process data, generic flavour.
  481.      */
  482.  
  483. STATIC VOID
  484. ConProcessDataGeneric(STRPTR String,LONG Size,UBYTE Mask)
  485. {
  486.     LONG    Len = 0;
  487.     UBYTE    c;
  488.  
  489.         /* If still parsing a sequence,
  490.          * continue with it.
  491.          */
  492.  
  493.     if(InSequence)
  494.     {
  495.         while(Size--)
  496.         {
  497.             c = *String++ & Mask;
  498.  
  499.             if(!(*AbortTable[c])(c))
  500.             {
  501.                 InSequence = FALSE;
  502.  
  503.                 break;
  504.             }
  505.         }
  506.     }
  507.  
  508.         /* Check which font we are in, if other than Topaz
  509.          * the only invalid char is a Null (0) which will
  510.          * display as a space if let to continue.
  511.          */
  512.  
  513.     if(Config->TerminalConfig->FontMode == FONT_STANDARD)
  514.     {
  515.         while(Size-- > 0)
  516.         {
  517.             if(IsPrintable[c = *String++ & Mask])
  518.             {
  519.                     /* This character is associated with a
  520.                      * special function (bell, xon, xoff, etc.).
  521.                      */
  522.  
  523.                 if(SpecialTable[c])
  524.                 {
  525.                     if(Len)
  526.                     {
  527.                         (*ConDump)(ConTempBuffer,Len);
  528.  
  529.                         Len = 0;
  530.                     }
  531.  
  532.                         /* Does this character start
  533.                          * a control sequence?
  534.                          */
  535.  
  536.                     if(InSequence = (*SpecialTable[c])(c))
  537.                     {
  538.                         while(Size-- > 0)
  539.                         {
  540.                             c = *String++ & Mask;
  541.  
  542.                             if(!(*AbortTable[c])(c))
  543.                             {
  544.                                 InSequence = FALSE;
  545.  
  546.                                 break;
  547.                             }
  548.                         }
  549.                     }
  550.                 }
  551.                 else
  552.                 {
  553.                         /* Put the character into the buffer
  554.                          * and flush it if necessary.
  555.                          */
  556.  
  557.                     ConTempBuffer[Len] = c;
  558.  
  559.                     if(Len++ == sizeof(ConTempBuffer))
  560.                     {
  561.                         (*ConDump)(ConTempBuffer,Len);
  562.  
  563.                         Len = 0;
  564.                     }
  565.                 }
  566.             }
  567.         }
  568.     }
  569.     else
  570.     {
  571.         while(Size-- > 0)
  572.         {
  573.             if(c = (*String++ & Mask))
  574.             {
  575.                     /* This character is associated with a
  576.                      * special function (bell, xon, xoff, etc.).
  577.                      */
  578.  
  579.                 if(SpecialTable[c])
  580.                 {
  581.                     if(Len)
  582.                     {
  583.                         (*ConDump)(ConTempBuffer,Len);
  584.  
  585.                         Len = 0;
  586.                     }
  587.  
  588.                     if(InSequence = (*SpecialTable[c])(c))
  589.                     {
  590.                         while(Size-- > 0)
  591.                         {
  592.                             c = *String++ & Mask;
  593.  
  594.                             if(!(*AbortTable[c])(c))
  595.                             {
  596.                                 InSequence = FALSE;
  597.  
  598.                                 break;
  599.                             }
  600.                         }
  601.                     }
  602.                 }
  603.                 else
  604.                 {
  605.                         /* Put the character into the buffer
  606.                          * and flush it if necessary.
  607.                          */
  608.  
  609.                     ConTempBuffer[Len] = c;
  610.  
  611.                     if(Len++ == sizeof(ConTempBuffer))
  612.                     {
  613.                         (*ConDump)(ConTempBuffer,Len);
  614.  
  615.                         Len = 0;
  616.                     }
  617.                 }
  618.             }
  619.         }
  620.     }
  621.  
  622.     if(Len)
  623.         (*ConDump)(ConTempBuffer,Len);
  624. }
  625.  
  626.     /* ConProcessData7(STRPTR String,LONG Size):
  627.      *
  628.      *    Process data, 7 bit flavour.
  629.      */
  630.  
  631. STATIC VOID
  632. ConProcessData7(STRPTR String,LONG Size)
  633. {
  634.     ConProcessDataGeneric(String,Size,0x7F);
  635. }
  636.  
  637.     /* ConProcessData8(STRPTR String,LONG Size):
  638.      *
  639.      *    Process data, 8 bit flavour.
  640.      */
  641.  
  642. STATIC VOID
  643. ConProcessData8(STRPTR String,LONG Size)
  644. {
  645.     LONG    Len = 0;
  646.     UBYTE    c;
  647.  
  648.     if(InSequence)
  649.     {
  650.         while(Size--)
  651.         {
  652.             c = *String++;
  653.  
  654.             if(!(*AbortTable[c])(c))
  655.             {
  656.                 InSequence = FALSE;
  657.  
  658.                 break;
  659.             }
  660.         }
  661.     }
  662.  
  663.     if(Config->TerminalConfig->FontMode == FONT_STANDARD)
  664.     {
  665.         while(Size-- > 0)
  666.         {
  667.             if(IsPrintable[c = *String++])
  668.             {
  669.                 if(SpecialTable[c])
  670.                 {
  671.                     if(Len)
  672.                     {
  673.                         (*ConDump)(ConTempBuffer,Len);
  674.  
  675.                         Len = 0;
  676.                     }
  677.  
  678.                     if(InSequence = (*SpecialTable[c])(c))
  679.                     {
  680.                         while(Size-- > 0)
  681.                         {
  682.                             c = *String++;
  683.  
  684.                             if(!(*AbortTable[c])(c))
  685.                             {
  686.                                 InSequence = FALSE;
  687.  
  688.                                 break;
  689.                             }
  690.                         }
  691.                     }
  692.                 }
  693.                 else
  694.                 {
  695.                     ConTempBuffer[Len] = c;
  696.  
  697.                     if(Len++ == sizeof(ConTempBuffer))
  698.                     {
  699.                         (*ConDump)(ConTempBuffer,Len);
  700.  
  701.                         Len = 0;
  702.                     }
  703.                 }
  704.             }
  705.         }
  706.     }
  707.     else
  708.     {
  709.         while(Size-- > 0)
  710.         {
  711.             if(c = *String++)
  712.             {
  713.                 if(SpecialTable[c])
  714.                 {
  715.                     if(Len)
  716.                     {
  717.                         (*ConDump)(ConTempBuffer,Len);
  718.  
  719.                         Len = 0;
  720.                     }
  721.  
  722.                     if(InSequence = (*SpecialTable[c])(c))
  723.                     {
  724.                         while(Size-- > 0)
  725.                         {
  726.                             c = *String++;
  727.  
  728.                             if(!(*AbortTable[c])(c))
  729.                             {
  730.                                 InSequence = FALSE;
  731.  
  732.                                 break;
  733.                             }
  734.                         }
  735.                     }
  736.                 }
  737.                 else
  738.                 {
  739.                     ConTempBuffer[Len] = c;
  740.  
  741.                     if(Len++ == sizeof(ConTempBuffer))
  742.                     {
  743.                         (*ConDump)(ConTempBuffer,Len);
  744.  
  745.                         Len = 0;
  746.                     }
  747.                 }
  748.             }
  749.         }
  750.     }
  751.  
  752.     if(Len)
  753.         (*ConDump)(ConTempBuffer,Len);
  754. }
  755.  
  756.     /* ConProcessDataHexGeneric(STRPTR String,LONG Size,UBYTE Mask):
  757.      *
  758.      *    Process data, hex mode flavour, generic version.
  759.      */
  760.  
  761. STATIC VOID
  762. ConProcessDataHexGeneric(STRPTR String,LONG Size,UBYTE Mask)
  763. {
  764.     UBYTE    DummyBuffer[40],c;
  765.     LONG    Fit,Spaces,Current;
  766.  
  767.         /* How many characters will fit into the line? */
  768.  
  769.     Fit    = (LastColumn + 1) / 4;
  770.  
  771.         /* Which position are we currently in? */
  772.  
  773.     Current    = CursorX / 3;
  774.  
  775.         /* Weird cursor position? */
  776.  
  777.     if(Current >= Fit || (CursorX % 3))
  778.     {
  779.         ConProcessDataGeneric("\r\n",2,Mask);
  780.  
  781.         Current = 0;
  782.     }
  783.  
  784.         /* Check the font type. */
  785.  
  786.     if(Config->TerminalConfig->FontMode == FONT_STANDARD)
  787.     {
  788.         while(Size-- > 0)
  789.         {
  790.             c = (*String++) & Mask;
  791.  
  792.             Spaces = (Fit - Current) * 3 + Current - 3;
  793.  
  794.             if(c > ' ' && c < 127)
  795.                 LimitedSPrintf(sizeof(DummyBuffer),DummyBuffer,"%02lx \33[%ldC%lc\33[%ldD",c,Spaces,c,Spaces + 1);
  796.             else
  797.                 LimitedSPrintf(sizeof(DummyBuffer),DummyBuffer,"%02lx \33[%ldC.\33[%ldD",c,Spaces,Spaces + 1);
  798.  
  799.             ConProcessDataGeneric(DummyBuffer,strlen(DummyBuffer),Mask);
  800.  
  801.             if(Current++ == Fit - 1)
  802.             {
  803.                 Current = 0;
  804.  
  805.                 ConProcessDataGeneric("\r\n",2,Mask);
  806.             }
  807.         }
  808.     }
  809.     else
  810.     {
  811.         while(Size-- > 0)
  812.         {
  813.             c = (*String++) & Mask;
  814.  
  815.             Spaces = (Fit - Current) * 3 + Current - 3;
  816.  
  817.             if(c && c != ' ')
  818.                 LimitedSPrintf(sizeof(DummyBuffer),DummyBuffer,"%02lx \33[%ldC%lc\33[%ldD",c,Spaces,c,Spaces + 1);
  819.             else
  820.                 LimitedSPrintf(sizeof(DummyBuffer),DummyBuffer,"%02lx \33[%ldC.\33[%ldD",c,Spaces,Spaces + 1);
  821.  
  822.             ConProcessDataGeneric(DummyBuffer,strlen(DummyBuffer),Mask);
  823.  
  824.             if(Current++ == Fit - 1)
  825.             {
  826.                 Current = 0;
  827.  
  828.                 ConProcessDataGeneric("\r\n",2,Mask);
  829.             }
  830.         }
  831.     }
  832. }
  833.  
  834.     /* ConProcessDataHex7(STRPTR String,LONG Size):
  835.      *
  836.      *    Process data, hex mode flavour, seven bits.
  837.      */
  838.  
  839. STATIC VOID
  840. ConProcessDataHex7(STRPTR String,LONG Size)
  841. {
  842.     ConProcessDataHexGeneric(String,Size,0x7F);
  843. }
  844.  
  845.     /* ConProcessDataHex8(STRPTR String,LONG Size):
  846.      *
  847.      *    Process data, hex mode flavour, eight bits.
  848.      */
  849.  
  850. STATIC VOID
  851. ConProcessDataHex8(STRPTR String,LONG Size)
  852. {
  853.     ConProcessDataHexGeneric(String,Size,0xFF);
  854. }
  855.  
  856. /****************************************************************************/
  857.  
  858.     /* ConTransferHost(STRPTR Buffer,LONG Len):
  859.      *
  860.      *    Process data read from the serial line,
  861.      *    special XPR flavour.
  862.      */
  863.  
  864. STATIC VOID
  865. ConTransferHost(STRPTR Buffer,LONG Len)
  866. {
  867.     LONG MaxSize;
  868.  
  869.         /* How much room is left? */
  870.  
  871.     if(Buffer != ReadBuffer)
  872.         MaxSize = SerialBufferSize - ((LONG)Buffer - (LONG)ReadBuffer);
  873.     else
  874.         MaxSize = SerialBufferSize;
  875.  
  876.         /* Let the XPR library take its share. */
  877.  
  878.     Len = XProtocolHostMon(XprIO,Buffer,Len,MaxSize);
  879.  
  880.         /* Did a file transfer start? */
  881.  
  882.     if(TransferWindow)
  883.         TransferCleanup();
  884.  
  885.         /* If the file transfer was aborted, flush the receive buffer. */
  886.  
  887.     if(TransferAborted)
  888.     {
  889.         BlockWindows();
  890.  
  891.         CompletelyFlushSerialRead();
  892.  
  893.         ReleaseWindows();
  894.  
  895.         TransferAborted = FALSE;
  896.     }
  897.  
  898.         /* Reset these two. */
  899.  
  900.     TransferFailed = TransferError = FALSE;
  901.  
  902.     if(Len)
  903.         ConProcess(Buffer,Len);
  904. }
  905.  
  906.     /* ConRawOutput(STRPTR String):
  907.      *
  908.      *    Bypass the `normal' ConOutput() data processing.
  909.      */
  910.  
  911. STATIC VOID
  912. ConRawOutput(STRPTR String)
  913. {
  914.     CALLBACK ProcessData;
  915.  
  916.     if(Config->SerialConfig->StripBit8)
  917.         ProcessData = (CALLBACK)ConProcessData7;
  918.     else
  919.         ProcessData = (CALLBACK)ConProcessData8;
  920.  
  921.     ObtainSemaphore(&TerminalSemaphore);
  922.  
  923.     if(Marking)
  924.         WindowMarkerStop();
  925.  
  926.     ClearCursor();
  927.  
  928.     (*ProcessData)(String,strlen(String));
  929.  
  930.     DrawCursor();
  931.  
  932.     ReleaseSemaphore(&TerminalSemaphore);
  933. }
  934.  
  935. STATIC VOID
  936. ConTransferHost_Translate_CR_LF(STRPTR String,LONG Size)
  937. {
  938.     LONG MaxSize;
  939.  
  940.     if(String != ReadBuffer)
  941.         MaxSize = SerialBufferSize - ((LONG)String - (LONG)ReadBuffer);
  942.     else
  943.         MaxSize = SerialBufferSize;
  944.  
  945.     Size = XProtocolHostMon(XprIO,String,Size,MaxSize);
  946.  
  947.     if(TransferWindow)
  948.         TransferCleanup();
  949.  
  950.     if(Size > 0)
  951.     {
  952.         if(Size = (*Translate_CR_LF)(String,Size))
  953.             ConProcess(String,Size);
  954.     }
  955. }
  956.  
  957. STATIC VOID
  958. ConProcess_Translate_CR_LF(STRPTR String,LONG Size)
  959. {
  960.     if(Size = (*Translate_CR_LF)(String,Size))
  961.         ConProcess(String,Size);
  962. }
  963.  
  964.     /* ConProcess(STRPTR String,LONG Size):
  965.      *
  966.      *    This is the central entry point to the terminal window
  967.      *    output routines. The incoming data is filtered through
  968.      *    the flow scanner (FlowFilter), passed through the capture
  969.      *    routines (CaptureData), the script recorder (RememberOutputText)
  970.      *    and the trap scanner (TrapFilter).
  971.      */
  972.  
  973. VOID
  974. ConProcess(STRPTR String,LONG Size)
  975. {
  976.     if(Size > 0)
  977.     {
  978.             /* Feed the flow filter. */
  979.  
  980.         if(UseFlow)
  981.             Size = FlowFilter(String,Size,Config->SerialConfig->StripBit8 ? 0x7F : 0xFF);
  982.  
  983.             /* In quiet mode no characters are echoed to the
  984.              * console window, they are just passed through
  985.              * the data flow filter. Usually, this mode is
  986.              * enabled by the dial panel.
  987.              */
  988.  
  989.         if(!ConsoleQuiet && Size > 0)
  990.         {
  991.                 /* Capture the data. */
  992.  
  993.             if(CaptureData && !XEmulatorBase)
  994.             {
  995.                 if(Config->CaptureConfig->ConvertChars && Config->TerminalConfig->FontMode != FONT_STANDARD)
  996.                 {
  997.                     UBYTE     LocalBuffer[BUFFER_LINE_MAX];
  998.                     UBYTE    *Src = String,*Dst,c;
  999.                     ULONG     Count,Len = Size;
  1000.  
  1001.                     while(Len > 0)
  1002.                     {
  1003.                         Count = MIN(BUFFER_LINE_MAX,Len);
  1004.                         Len -= Count;
  1005.                         Dst = LocalBuffer;
  1006.  
  1007.                         do
  1008.                         {
  1009.                             if(c = ISOConversion[*Src++])
  1010.                                 *Dst++ = c;
  1011.                             else
  1012.                                 *Dst++ = (UBYTE)'·';
  1013.                         }
  1014.                         while(--Count > 0);
  1015.  
  1016.                         if((Count = (ULONG)Dst - (ULONG)LocalBuffer) > 0)
  1017.                             (*CaptureData)(LocalBuffer,Count);
  1018.                     }
  1019.                 }
  1020.                 else
  1021.                     (*CaptureData)(String,Size);
  1022.             }
  1023.  
  1024.                 /* Remember the data. */
  1025.  
  1026.             if(RememberOutput)
  1027.                 RememberOutputText(String,Size);
  1028.  
  1029.                 /* Check the traps if necessary. */
  1030.  
  1031.             if(WatchTraps)
  1032.                 TrapFilter(String,Size);
  1033.  
  1034.             if(Marking)
  1035.                 WindowMarkerStop();
  1036.  
  1037.             if(TerminalQueue)
  1038.             {
  1039.                 struct DataMsg *Msg;
  1040.  
  1041.                 if(Msg = (struct DataMsg *)CreateMsgItem(sizeof(struct DataMsg) + Size))
  1042.                 {
  1043.                     Msg->Data = (APTR)(Msg + 1);
  1044.                     Msg->Size = Size;
  1045.  
  1046.                     CopyMem(String,Msg->Data,Msg->Size);
  1047.  
  1048.                     PutMsgItem(TerminalQueue,(struct MsgItem *)Msg);
  1049.  
  1050.                     return;
  1051.                 }
  1052.             }
  1053.  
  1054.             ClearCursor();
  1055.  
  1056.             (*ConProcessData)(String,Size);
  1057.  
  1058.             DrawCursor();
  1059.         }
  1060.     }
  1061. }
  1062.  
  1063.     /* ConPrintf(STRPTR String,...):
  1064.      *
  1065.      *    Output a string to the console.
  1066.      */
  1067.  
  1068. VOID
  1069. ConPrintf(STRPTR String,...)
  1070. {
  1071.     UBYTE LocalBuffer[256];
  1072.     va_list    VarArgs;
  1073.  
  1074.     if(Marking)
  1075.         WindowMarkerStop();
  1076.  
  1077.     va_start(VarArgs,String);
  1078.     LimitedVSPrintf(sizeof(LocalBuffer),LocalBuffer,String,VarArgs);
  1079.     va_end(VarArgs);
  1080.  
  1081.     ConProcess(LocalBuffer,strlen(LocalBuffer));
  1082. }
  1083.  
  1084. /****************************************************************************/
  1085.  
  1086.     /* ConProcessUpdate():
  1087.      *
  1088.      *    Choose the right console data processing routine.
  1089.      */
  1090.  
  1091. VOID
  1092. ConProcessUpdate()
  1093. {
  1094.     Forbid();
  1095.  
  1096.     if(XEmulatorBase && Config->TerminalConfig->EmulationMode == EMULATION_EXTERNAL)
  1097.     {
  1098.         if(ReceiveTable)
  1099.             ConProcessData = ConProcessDataTransExternal;
  1100.         else
  1101.             ConProcessData = ConProcessDataExternal;
  1102.     }
  1103.     else
  1104.     {
  1105.         if(Config->SerialConfig->StripBit8)
  1106.         {
  1107.             if(Config->TerminalConfig->EmulationMode == EMULATION_HEX)
  1108.                 ConProcessData = ConProcessDataHex7;
  1109.             else
  1110.                 ConProcessData = ConProcessData7;
  1111.         }
  1112.         else
  1113.         {
  1114.             if(Config->TerminalConfig->EmulationMode == EMULATION_HEX)
  1115.                 ConProcessData = ConProcessDataHex8;
  1116.             else
  1117.                 ConProcessData = ConProcessData8;
  1118.         }
  1119.     }
  1120.  
  1121.     Permit();
  1122. }
  1123.  
  1124.     /* ConOutputUpdate():
  1125.      *
  1126.      *    Choose the right raw text output routine for the job.
  1127.      */
  1128.  
  1129. VOID
  1130. ConOutputUpdate()
  1131. {
  1132.     Forbid();
  1133.  
  1134.     if(Config->CaptureConfig->BufferMode == BUFFERMODE_FLOW)
  1135.         SaveRaster = SaveRasterDummy;
  1136.     else
  1137.         SaveRaster = SaveRasterReal;
  1138.  
  1139.     if(BufferFrozen || Config->CaptureConfig->BufferMode != BUFFERMODE_FLOW)
  1140.     {
  1141.         if(FileCapture)
  1142.         {
  1143.             if(PrinterCapture)
  1144.             {
  1145.                 if(Config->CaptureConfig->CaptureFilterMode && !RawCapture)
  1146.                     CaptureData = CaptureFilteredTo_File_Printer;
  1147.                 else
  1148.                     CaptureData = CaptureRawTo_File_Printer;
  1149.             }
  1150.             else
  1151.             {
  1152.                 if(Config->CaptureConfig->CaptureFilterMode && !RawCapture)
  1153.                     CaptureData = CaptureFilteredTo_File;
  1154.                 else
  1155.                     CaptureData = CaptureRawTo_File;
  1156.             }
  1157.         }
  1158.         else
  1159.         {
  1160.             if(PrinterCapture)
  1161.             {
  1162.                 if(Config->CaptureConfig->CaptureFilterMode && !RawCapture)
  1163.                     CaptureData = CaptureFilteredTo_Printer;
  1164.                 else
  1165.                     CaptureData = CaptureRawTo_Printer;
  1166.             }
  1167.             else
  1168.                 CaptureData = NULL;
  1169.         }
  1170.     }
  1171.     else
  1172.     {
  1173.         if(FileCapture)
  1174.         {
  1175.             if(PrinterCapture)
  1176.             {
  1177.                 if(Config->CaptureConfig->CaptureFilterMode && !RawCapture)
  1178.                     CaptureData = CaptureFilteredTo_Buffer_File_Printer;
  1179.                 else
  1180.                     CaptureData = CaptureRawTo_Buffer_File_Printer;
  1181.             }
  1182.             else
  1183.             {
  1184.                 if(Config->CaptureConfig->CaptureFilterMode && !RawCapture)
  1185.                     CaptureData = CaptureFilteredTo_Buffer_File;
  1186.                 else
  1187.                     CaptureData = CaptureRawTo_Buffer_File;
  1188.             }
  1189.         }
  1190.         else
  1191.         {
  1192.             if(PrinterCapture)
  1193.             {
  1194.                 if(Config->CaptureConfig->CaptureFilterMode && !RawCapture)
  1195.                     CaptureData = CaptureFilteredTo_Buffer_Printer;
  1196.                 else
  1197.                     CaptureData = CaptureRawTo_Buffer_Printer;
  1198.             }
  1199.             else
  1200.             {
  1201.                 if(Config->CaptureConfig->CaptureFilterMode && !RawCapture)
  1202.                     CaptureData = CaptureFilteredTo_Buffer;
  1203.                 else
  1204.                     CaptureData = CaptureRawTo_Buffer;
  1205.             }
  1206.         }
  1207.     }
  1208.  
  1209.     if(ControllerActive)
  1210.         ConOutput = ConOutputPrinter;
  1211.     else
  1212.     {
  1213.         if(CurrentFont == GFX)
  1214.             ConOutput = ConOutputGFX;
  1215.         else
  1216.             ConOutput = ConOutputNormal;
  1217.     }
  1218.  
  1219.     if(ReceiveTable)
  1220.         ConDump = ConOutputTranslate;
  1221.     else
  1222.         ConDump = ConOutput;
  1223.  
  1224.     Permit();
  1225. }
  1226.  
  1227.     /* ConFontScaleUpdate():
  1228.      *
  1229.      *    Choose the right font scale for the job.
  1230.      */
  1231.  
  1232. VOID
  1233. ConFontScaleUpdate()
  1234. {
  1235.     CurrentFontScale    = RasterAttr[CursorY];
  1236.     FontScalingRequired    = FALSE;
  1237.     CharCellNominator    = 1;
  1238.  
  1239.     if(CurrentCharWidth == SCALE_HALF)
  1240.         CharCellDenominator = 2;
  1241.     else
  1242.         CharCellDenominator = 1;
  1243.  
  1244.     if(CurrentFontScale == SCALE_ATTR_NORMAL)
  1245.     {
  1246.         if(CurrentCharWidth == SCALE_HALF)
  1247.         {
  1248.                 /* Half of normal width */
  1249.  
  1250.             LastPrintableColumn    = (LastColumn + 1) * 2 - 1;
  1251.             LastPrintablePixel     = (LastPixel + 1) * 2 - 1;
  1252.             FontScalingRequired    = TRUE;
  1253.         }
  1254.         else
  1255.         {
  1256.                 /* Normal width */
  1257.  
  1258.             LastPrintableColumn    = LastColumn;
  1259.             LastPrintablePixel    = LastPixel;
  1260.         }
  1261.     }
  1262.     else
  1263.     {
  1264.         if(CurrentCharWidth == SCALE_HALF)
  1265.         {
  1266.                 /* Half of double width */
  1267.  
  1268.             LastPrintableColumn    = LastColumn;
  1269.             LastPrintablePixel    = LastPixel;
  1270.         }
  1271.         else
  1272.         {
  1273.                 /* Double width */
  1274.  
  1275.             LastPrintableColumn    = ((LastColumn + 1) / 2) - 1;
  1276.             LastPrintablePixel    = ((LastPixel + 1) / 2) - 1;
  1277.             FontScalingRequired    = TRUE;
  1278.         }
  1279.     }
  1280. }
  1281.  
  1282.     /* ConTransferUpdate():
  1283.      *
  1284.      *    Choose the right processing routine for the job.
  1285.      */
  1286.  
  1287. VOID
  1288. ConTransferUpdate()
  1289. {
  1290.     if(Translate_CR_LF)
  1291.     {
  1292.         if(XProtocolBase && (TransferBits & XPRS_HOSTMON))
  1293.             ConTransfer = (CONTRANSFER)ConTransferHost_Translate_CR_LF;
  1294.         else
  1295.             ConTransfer = (CONTRANSFER)ConProcess_Translate_CR_LF;
  1296.     }
  1297.     else
  1298.     {
  1299.         if(XProtocolBase && (TransferBits & XPRS_HOSTMON))
  1300.             ConTransfer = (CONTRANSFER)ConTransferHost;
  1301.         else
  1302.             ConTransfer = (CONTRANSFER)ConProcess;
  1303.     }
  1304. }
  1305.  
  1306. /****************************************************************************/
  1307.  
  1308.     /* ConClear():
  1309.      *
  1310.      *    Clears the console screen, no matter what emulation is
  1311.      *    currently running.
  1312.      */
  1313.  
  1314. VOID
  1315. ConClear()
  1316. {
  1317.     if(XEmulatorBase && Config->TerminalConfig->EmulationMode == EMULATION_EXTERNAL)
  1318.         XEmulatorClearConsole(XEM_IO);
  1319.     else
  1320.     {
  1321.         if(Marking)
  1322.             WindowMarkerStop();
  1323.  
  1324.         ConRawOutput("\033[2J\033[H");
  1325.     }
  1326. }
  1327.  
  1328.     /* ConResetFont():
  1329.      *
  1330.      *    Resets the console font, no matter what emulation is
  1331.      *    currently running.
  1332.      */
  1333.  
  1334. VOID
  1335. ConResetFont()
  1336. {
  1337.     if(XEmulatorBase && Config->TerminalConfig->EmulationMode == EMULATION_EXTERNAL)
  1338.         XEmulatorResetCharset(XEM_IO);
  1339.     else
  1340.     {
  1341.         if(Marking)
  1342.             WindowMarkerStop();
  1343.  
  1344.         CurrentFont = TextFont;
  1345.  
  1346.         SetFont(RPort,CurrentFont);
  1347.  
  1348.         ConOutputUpdate();
  1349.     }
  1350. }
  1351.  
  1352.     /* ConResetStyles():
  1353.      *
  1354.      *    Resets the console text rendering style, no matter what emulation is
  1355.      *    currently running.
  1356.      */
  1357.  
  1358. VOID
  1359. ConResetStyles()
  1360. {
  1361.     if(XEmulatorBase && Config->TerminalConfig->EmulationMode == EMULATION_EXTERNAL)
  1362.         XEmulatorResetTextStyles(XEM_IO);
  1363.     else
  1364.     {
  1365.         if(Marking)
  1366.             WindowMarkerStop();
  1367.  
  1368.         ConRawOutput("\033[0m");
  1369.  
  1370.         ObtainSemaphore(&TerminalSemaphore);
  1371.  
  1372.         ClearCursor();
  1373.  
  1374.         CurrentCharWidth = SCALE_NORMAL;
  1375.  
  1376.         if(!Config->EmulationConfig->LockColour)
  1377.         {
  1378.             ForegroundPen = GetPenIndex(SafeTextPen);
  1379.             BackgroundPen = 0;
  1380.         }
  1381.  
  1382.         UpdatePens();
  1383.  
  1384.         ConFontScaleUpdate();
  1385.  
  1386.         DrawCursor();
  1387.  
  1388.         ReleaseSemaphore(&TerminalSemaphore);
  1389.     }
  1390. }
  1391.  
  1392.     /* ConResetTerminal():
  1393.      *
  1394.      *    Resets the console, no matter what emulation is
  1395.      *    currently running.
  1396.      */
  1397.  
  1398. VOID
  1399. ConResetTerminal()
  1400. {
  1401.     if(XEmulatorBase && Config->TerminalConfig->EmulationMode == EMULATION_EXTERNAL)
  1402.         XEmulatorResetConsole(XEM_IO);
  1403.     else
  1404.     {
  1405.         if(Marking)
  1406.             WindowMarkerStop();
  1407.  
  1408.         ConRawOutput("\033c");
  1409.     }
  1410. }
  1411.  
  1412.     /* SetConsoleQuiet(BOOL NewSettings):
  1413.      *
  1414.      *    Tell the console to be quiet.
  1415.      */
  1416.  
  1417. BOOL
  1418. SetConsoleQuiet(BOOL NewSettings)
  1419. {
  1420.     BOOL OldSettings;
  1421.  
  1422.     OldSettings        = ConsoleQuiet;
  1423.     ConsoleQuiet    = NewSettings;
  1424.  
  1425.     return(OldSettings);
  1426. }
  1427.