acgetline.c revision 281075 
1/******************************************************************************
2 *
3 * Module Name: acgetline - local line editing
4 *
5 *****************************************************************************/
6
7/*
8 * Copyright (C) 2000 - 2015, Intel Corp.
9 * All rights reserved.
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
14 * 1. Redistributions of source code must retain the above copyright
15 *    notice, this list of conditions, and the following disclaimer,
16 *    without modification.
17 * 2. Redistributions in binary form must reproduce at minimum a disclaimer
18 *    substantially similar to the "NO WARRANTY" disclaimer below
19 *    ("Disclaimer") and any redistribution must be conditioned upon
20 *    including a substantially similar Disclaimer requirement for further
21 *    binary redistribution.
22 * 3. Neither the names of the above-listed copyright holders nor the names
23 *    of any contributors may be used to endorse or promote products derived
24 *    from this software without specific prior written permission.
25 *
26 * Alternatively, this software may be distributed under the terms of the
27 * GNU General Public License ("GPL") version 2 as published by the Free
28 * Software Foundation.
29 *
30 * NO WARRANTY
31 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
32 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
33 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
34 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
35 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
36 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
37 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
38 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
39 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
40 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
41 * POSSIBILITY OF SUCH DAMAGES.
42 */
43
44#include <contrib/dev/acpica/include/acpi.h>
45#include <contrib/dev/acpica/include/accommon.h>
46#include <contrib/dev/acpica/include/amlcode.h>
47#include <contrib/dev/acpica/include/acparser.h>
48#include <contrib/dev/acpica/include/acdebug.h>
49
50#include <stdio.h>
51
52/*
53 * This is an os-independent implementation of line-editing services needed
54 * by the AcpiExec utility. It uses getchar() and putchar() and the existing
55 * history support provided by the AML debugger. It assumes that the terminal
56 * is in the correct line-editing mode such as raw and noecho. The OSL
57 * interface AcpiOsInitialize should do this. AcpiOsTerminate should put the
58 * terminal back into the original mode.
59 */
60#define _COMPONENT          ACPI_OS_SERVICES
61        ACPI_MODULE_NAME    ("acgetline")
62
63
64/* Local prototypes */
65
66static void
67AcpiAcClearLine (
68    UINT32                  EndOfLine,
69    UINT32                  CursorPosition);
70
71/* Various ASCII constants */
72
73#define _ASCII_NUL                  0
74#define _ASCII_BACKSPACE            0x08
75#define _ASCII_TAB                  0x09
76#define _ASCII_ESCAPE               0x1B
77#define _ASCII_SPACE                0x20
78#define _ASCII_LEFT_BRACKET         0x5B
79#define _ASCII_DEL                  0x7F
80#define _ASCII_UP_ARROW             'A'
81#define _ASCII_DOWN_ARROW           'B'
82#define _ASCII_RIGHT_ARROW          'C'
83#define _ASCII_LEFT_ARROW           'D'
84#define _ASCII_NEWLINE              '\n'
85
86extern UINT32               AcpiGbl_NextCmdNum;
87
88/* Erase a single character on the input command line */
89
90#define ACPI_CLEAR_CHAR() \
91    putchar (_ASCII_BACKSPACE); \
92    putchar (_ASCII_SPACE); \
93    putchar (_ASCII_BACKSPACE);
94
95/* Backup cursor by Count positions */
96
97#define ACPI_BACKUP_CURSOR(i, Count) \
98    for (i = 0; i < (Count); i++) \
99        {putchar (_ASCII_BACKSPACE);}
100
101
102/******************************************************************************
103 *
104 * FUNCTION:    AcpiAcClearLine
105 *
106 * PARAMETERS:  EndOfLine           - Current end-of-line index
107 *              CursorPosition      - Current cursor position within line
108 *
109 * RETURN:      None
110 *
111 * DESCRIPTION: Clear the entire command line the hard way, but probably the
112 *              most portable.
113 *
114 *****************************************************************************/
115
116static void
117AcpiAcClearLine (
118    UINT32                  EndOfLine,
119    UINT32                  CursorPosition)
120{
121    UINT32                  i;
122
123
124    if (CursorPosition < EndOfLine)
125    {
126        /* Clear line from current position to end of line */
127
128        for (i = 0; i < (EndOfLine - CursorPosition); i++)
129        {
130            putchar (' ');
131        }
132    }
133
134    /* Clear the entire line */
135
136    for (; EndOfLine > 0; EndOfLine--)
137    {
138        ACPI_CLEAR_CHAR ();
139    }
140}
141
142
143/******************************************************************************
144 *
145 * FUNCTION:    AcpiOsGetLine
146 *
147 * PARAMETERS:  Buffer              - Where to return the command line
148 *              BufferLength        - Maximum length of Buffer
149 *              BytesRead           - Where the actual byte count is returned
150 *
151 * RETURN:      Status and actual bytes read
152 *
153 * DESCRIPTION: Get the next input line from the terminal. NOTE: terminal
154 *              is expected to be in a mode that supports line-editing (raw,
155 *              noecho). This function is intended to be very portable. Also,
156 *              it uses the history support implemented in the AML debugger.
157 *
158 *****************************************************************************/
159
160ACPI_STATUS
161AcpiOsGetLine (
162    char                    *Buffer,
163    UINT32                  BufferLength,
164    UINT32                  *BytesRead)
165{
166    char                    *NextCommand;
167    UINT32                  MaxCommandIndex = AcpiGbl_NextCmdNum - 1;
168    UINT32                  CurrentCommandIndex = MaxCommandIndex;
169    UINT32                  PreviousCommandIndex = MaxCommandIndex;
170    int                     InputChar;
171    UINT32                  CursorPosition = 0;
172    UINT32                  EndOfLine = 0;
173    UINT32                  i;
174
175
176    /* Always clear the line buffer before we read a new line */
177
178    memset (Buffer, 0, BufferLength);
179
180    /*
181     * This loop gets one character at a time (except for esc sequences)
182     * until a newline or error is detected.
183     *
184     * Note: Don't attempt to write terminal control ESC sequences, even
185     * though it makes certain things more difficult.
186     */
187    while (1)
188    {
189        if (EndOfLine >= (BufferLength - 1))
190        {
191            return (AE_BUFFER_OVERFLOW);
192        }
193
194        InputChar = getchar ();
195        switch (InputChar)
196        {
197        default: /* This is the normal character case */
198
199            /* Echo the character (at EOL) and copy it to the line buffer */
200
201            if (EndOfLine == CursorPosition)
202            {
203                putchar (InputChar);
204                Buffer[EndOfLine] = (char) InputChar;
205
206                EndOfLine++;
207                CursorPosition++;
208                Buffer[EndOfLine] = 0;
209                continue;
210            }
211
212            /* Insert character into the middle of the buffer */
213
214            memmove (&Buffer[CursorPosition + 1], &Buffer[CursorPosition],
215                (EndOfLine - CursorPosition + 1));
216
217            Buffer [CursorPosition] = (char) InputChar;
218            Buffer [EndOfLine + 1] = 0;
219
220            /* Display the new part of line starting at the new character */
221
222            fprintf (stdout, "%s", &Buffer[CursorPosition]);
223
224            /* Restore cursor */
225
226            ACPI_BACKUP_CURSOR (i, EndOfLine - CursorPosition);
227            CursorPosition++;
228            EndOfLine++;
229            continue;
230
231        case _ASCII_DEL: /* Backspace key */
232
233            if (!EndOfLine) /* Any characters on the command line? */
234            {
235                continue;
236            }
237
238            if (EndOfLine == CursorPosition) /* Erase the final character */
239            {
240                ACPI_CLEAR_CHAR ();
241                EndOfLine--;
242                CursorPosition--;
243                continue;
244            }
245
246            if (!CursorPosition) /* Do not backup beyond start of line */
247            {
248                continue;
249            }
250
251            /* Remove the character from the line */
252
253            memmove (&Buffer[CursorPosition - 1], &Buffer[CursorPosition],
254                (EndOfLine - CursorPosition + 1));
255
256            /* Display the new part of line starting at the new character */
257
258            putchar (_ASCII_BACKSPACE);
259            fprintf (stdout, "%s ", &Buffer[CursorPosition - 1]);
260
261            /* Restore cursor */
262
263            ACPI_BACKUP_CURSOR (i, EndOfLine - CursorPosition + 1);
264            EndOfLine--;
265            if (CursorPosition > 0)
266            {
267                CursorPosition--;
268            }
269            continue;
270
271        case _ASCII_NEWLINE: /* Normal exit case at end of command line */
272        case _ASCII_NUL:
273
274            /* Return the number of bytes in the command line string */
275
276            if (BytesRead)
277            {
278                *BytesRead = EndOfLine;
279            }
280
281            /* Echo, terminate string buffer, and exit */
282
283            putchar (InputChar);
284            Buffer[EndOfLine] = 0;
285            return (AE_OK);
286
287        case _ASCII_TAB:
288
289            /* Ignore */
290
291            continue;
292
293        case EOF:
294
295            return (AE_ERROR);
296
297        case _ASCII_ESCAPE:
298
299            /* Check for escape sequences of the form "ESC[x" */
300
301            InputChar = getchar ();
302            if (InputChar != _ASCII_LEFT_BRACKET)
303            {
304                continue; /* Ignore this ESC, does not have the '[' */
305            }
306
307            /* Get the code following the ESC [ */
308
309            InputChar = getchar (); /* Backup one character */
310            switch (InputChar)
311            {
312            case _ASCII_LEFT_ARROW:
313
314                if (CursorPosition > 0)
315                {
316                    putchar (_ASCII_BACKSPACE);
317                    CursorPosition--;
318                }
319                continue;
320
321            case _ASCII_RIGHT_ARROW:
322                /*
323                 * Move one character forward. Do this without sending
324                 * ESC sequence to the terminal for max portability.
325                 */
326                if (CursorPosition < EndOfLine)
327                {
328                    /* Backup to start of line and print the entire line */
329
330                    ACPI_BACKUP_CURSOR (i, CursorPosition);
331                    fprintf (stdout, "%s", Buffer);
332
333                    /* Backup to where the cursor should be */
334
335                    CursorPosition++;
336                    ACPI_BACKUP_CURSOR (i, EndOfLine - CursorPosition);
337                }
338                continue;
339
340            case _ASCII_UP_ARROW:
341
342                /* If no commands available or at start of history list, ignore */
343
344                if (!CurrentCommandIndex)
345                {
346                    continue;
347                }
348
349                /* Manage our up/down progress */
350
351                if (CurrentCommandIndex > PreviousCommandIndex)
352                {
353                    CurrentCommandIndex = PreviousCommandIndex;
354                }
355
356                /* Get the historical command from the debugger */
357
358                NextCommand = AcpiDbGetHistoryByIndex (CurrentCommandIndex);
359                if (!NextCommand)
360                {
361                    return (AE_ERROR);
362                }
363
364                /* Make this the active command and echo it */
365
366                AcpiAcClearLine (EndOfLine, CursorPosition);
367                strcpy (Buffer, NextCommand);
368                fprintf (stdout, "%s", Buffer);
369                EndOfLine = CursorPosition = strlen (Buffer);
370
371                PreviousCommandIndex = CurrentCommandIndex;
372                CurrentCommandIndex--;
373                continue;
374
375            case _ASCII_DOWN_ARROW:
376
377                if (!MaxCommandIndex) /* Any commands available? */
378                {
379                    continue;
380                }
381
382                /* Manage our up/down progress */
383
384                if (CurrentCommandIndex < PreviousCommandIndex)
385                {
386                    CurrentCommandIndex = PreviousCommandIndex;
387                }
388
389                /* If we are the end of the history list, output a clear new line */
390
391                if ((CurrentCommandIndex + 1) > MaxCommandIndex)
392                {
393                    AcpiAcClearLine (EndOfLine, CursorPosition);
394                    EndOfLine = CursorPosition = 0;
395                    PreviousCommandIndex = CurrentCommandIndex;
396                    continue;
397                }
398
399                PreviousCommandIndex = CurrentCommandIndex;
400                CurrentCommandIndex++;
401
402                 /* Get the historical command from the debugger */
403
404                NextCommand = AcpiDbGetHistoryByIndex (CurrentCommandIndex);
405                if (!NextCommand)
406                {
407                    return (AE_ERROR);
408                }
409
410                /* Make this the active command and echo it */
411
412                AcpiAcClearLine (EndOfLine, CursorPosition);
413                strcpy (Buffer, NextCommand);
414                fprintf (stdout, "%s", Buffer);
415                EndOfLine = CursorPosition = strlen (Buffer);
416                continue;
417
418            case 0x31:
419            case 0x32:
420            case 0x33:
421            case 0x34:
422            case 0x35:
423            case 0x36:
424                /*
425                 * Ignore the various keys like insert/delete/home/end, etc.
426                 * But we must eat the final character of the ESC sequence.
427                 */
428                InputChar = getchar ();
429                continue;
430
431            default:
432
433                /* Ignore random escape sequences that we don't care about */
434
435                continue;
436            }
437            continue;
438        }
439    }
440}
441