acgetline.c revision 1.1.1.4
1 /****************************************************************************** 2 * 3 * Module Name: acgetline - local line editing 4 * 5 *****************************************************************************/ 6 7 /* 8 * Copyright (C) 2000 - 2016, 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 "acpi.h" 45 #include "accommon.h" 46 #include "amlcode.h" 47 #include "acparser.h" 48 #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 66 static void 67 AcpiAcClearLine ( 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 86 extern 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 116 static void 117 AcpiAcClearLine ( 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 160 ACPI_STATUS 161 AcpiOsGetLine ( 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 266 if (CursorPosition > 0) 267 { 268 CursorPosition--; 269 } 270 continue; 271 272 case _ASCII_NEWLINE: /* Normal exit case at end of command line */ 273 case _ASCII_NUL: 274 275 /* Return the number of bytes in the command line string */ 276 277 if (BytesRead) 278 { 279 *BytesRead = EndOfLine; 280 } 281 282 /* Echo, terminate string buffer, and exit */ 283 284 putchar (InputChar); 285 Buffer[EndOfLine] = 0; 286 return (AE_OK); 287 288 case _ASCII_TAB: 289 290 /* Ignore */ 291 292 continue; 293 294 case EOF: 295 296 return (AE_ERROR); 297 298 case _ASCII_ESCAPE: 299 300 /* Check for escape sequences of the form "ESC[x" */ 301 302 InputChar = getchar (); 303 if (InputChar != _ASCII_LEFT_BRACKET) 304 { 305 continue; /* Ignore this ESC, does not have the '[' */ 306 } 307 308 /* Get the code following the ESC [ */ 309 310 InputChar = getchar (); /* Backup one character */ 311 switch (InputChar) 312 { 313 case _ASCII_LEFT_ARROW: 314 315 if (CursorPosition > 0) 316 { 317 putchar (_ASCII_BACKSPACE); 318 CursorPosition--; 319 } 320 continue; 321 322 case _ASCII_RIGHT_ARROW: 323 /* 324 * Move one character forward. Do this without sending 325 * ESC sequence to the terminal for max portability. 326 */ 327 if (CursorPosition < EndOfLine) 328 { 329 /* Backup to start of line and print the entire line */ 330 331 ACPI_BACKUP_CURSOR (i, CursorPosition); 332 fprintf (stdout, "%s", Buffer); 333 334 /* Backup to where the cursor should be */ 335 336 CursorPosition++; 337 ACPI_BACKUP_CURSOR (i, EndOfLine - CursorPosition); 338 } 339 continue; 340 341 case _ASCII_UP_ARROW: 342 343 /* If no commands available or at start of history list, ignore */ 344 345 if (!CurrentCommandIndex) 346 { 347 continue; 348 } 349 350 /* Manage our up/down progress */ 351 352 if (CurrentCommandIndex > PreviousCommandIndex) 353 { 354 CurrentCommandIndex = PreviousCommandIndex; 355 } 356 357 /* Get the historical command from the debugger */ 358 359 NextCommand = AcpiDbGetHistoryByIndex (CurrentCommandIndex); 360 if (!NextCommand) 361 { 362 return (AE_ERROR); 363 } 364 365 /* Make this the active command and echo it */ 366 367 AcpiAcClearLine (EndOfLine, CursorPosition); 368 strcpy (Buffer, NextCommand); 369 fprintf (stdout, "%s", Buffer); 370 EndOfLine = CursorPosition = strlen (Buffer); 371 372 PreviousCommandIndex = CurrentCommandIndex; 373 CurrentCommandIndex--; 374 continue; 375 376 case _ASCII_DOWN_ARROW: 377 378 if (!MaxCommandIndex) /* Any commands available? */ 379 { 380 continue; 381 } 382 383 /* Manage our up/down progress */ 384 385 if (CurrentCommandIndex < PreviousCommandIndex) 386 { 387 CurrentCommandIndex = PreviousCommandIndex; 388 } 389 390 /* If we are the end of the history list, output a clear new line */ 391 392 if ((CurrentCommandIndex + 1) > MaxCommandIndex) 393 { 394 AcpiAcClearLine (EndOfLine, CursorPosition); 395 EndOfLine = CursorPosition = 0; 396 PreviousCommandIndex = CurrentCommandIndex; 397 continue; 398 } 399 400 PreviousCommandIndex = CurrentCommandIndex; 401 CurrentCommandIndex++; 402 403 /* Get the historical command from the debugger */ 404 405 NextCommand = AcpiDbGetHistoryByIndex (CurrentCommandIndex); 406 if (!NextCommand) 407 { 408 return (AE_ERROR); 409 } 410 411 /* Make this the active command and echo it */ 412 413 AcpiAcClearLine (EndOfLine, CursorPosition); 414 strcpy (Buffer, NextCommand); 415 fprintf (stdout, "%s", Buffer); 416 EndOfLine = CursorPosition = strlen (Buffer); 417 continue; 418 419 case 0x31: 420 case 0x32: 421 case 0x33: 422 case 0x34: 423 case 0x35: 424 case 0x36: 425 /* 426 * Ignore the various keys like insert/delete/home/end, etc. 427 * But we must eat the final character of the ESC sequence. 428 */ 429 InputChar = getchar (); 430 continue; 431 432 default: 433 434 /* Ignore random escape sequences that we don't care about */ 435 436 continue; 437 } 438 continue; 439 } 440 } 441 } 442
Indexes created Sun Sep 28 07:09:56 GMT 2025