hla-stdlib-talk Mailing List for HLA Standard Library (Page 2)

SourceForge Headquarters 225 Broadway Suite 1600 San Diego, CA 92101 +1 (858) 422-6466

Nathan Baker wrote:

...
>      > w.ReadFile( hStdIn, &InputBuffer, 1, InputIndex, 0 );
> 
>     Who "InputIndex"? I'm thinking we want an address here (? remember I
>     don't do Windows). Perhaps that's what you've got...
> 
> I cribbed InputBuffer and InputIndex from the original getc() -- again, 
> I am guessing they are defined in "../include/stdinunit.hhf" -- probably 
> need to call stdin.read() { the original calls readln() but that won't 
> work here }.

Could that be a problem? Or an opportunity?

...
>     "Leaking handles" is a pretty bad problem. Other than that, it looks
>     good to me!
> 
> I don't think so.  To my understanding, the 'standard I/O' handles are 
> created (by the OS) for each process when it starts, and are closed 
> automatically when it terminates.  The 'GetStdHandle' doesn't actually 
> create a new handle... it just asks the OS for the handle that was 
> already created when the process started.  I think closing it 
> prematurely might be a bad thing.  I'll check the book to make sure.

Yeah... or see what GetStdHandle(-10) returns on repeated calls.

>     What I've got for Linux does a similar thing... we "get" a whole
>     bleedin' structure for "current mode" - but only clear two bits, and
>     "set" to that. It is not strictly "right". If the pesky user suspends
>     the program with control-z, and restarts it with "fg", we're back
>     reading one key... but waiting for "Enter" again! :( A similar problem
>     may occur if the window size is changed (in an Xterm). We could fix
>     that
>     by blocking control-c/control-z entirely - handling it ourselves,
>     perhaps. Or we can "catch" these signals and do the appropriate
>     cleanup/restoration of our "tweak". (I'm not sure how to do that one).
> 
> Could you post the code?  Or is it already at Linux-nasm-users?

Might be... in the form of "Beth's Game". Here's a "simplified" version 
- as-is, needs-work! And a C program (since you like C compilers these 
days) which does something a little more - kills more "processing" and 
checks for control-c. The way he does "check-for-key" doesn't impress 
me. Rather than make the handle non-blocking, we can use sys__newselect 
for that. There are several interesting points: size of termios is not 
what I'm using (!), different tweak for Ubuntu (!), and the different 
bits in termios that he tweaks and I leave alone...

Best,
Frank

begin Nasmcode;

global _start

; misc. equates
%define NL 10
%define STDIN 0
%define STDOUT 1

; sys_calls
%define SYS_EXIT 1
%define SYS_READ 3
%define SYS_WRITE 4
%define SYS_IOCTL 54

section .text
_start:
     nop
.top:
     call getc

     cmp al, 'q'
     jz exit

     call putc
     call showalhex
     mov al, 10
     call putc
     jmp short .top

exit:
     mov ebx, eax
     mov eax, 1
     int 80h
;-------------------

;------------------
showalhex:
     push eax
     mov ah, al
     shr al, 4
     cmp al, 0Ah
     sbb al, 69h
     das
     call putc
     mov al, ah
     and al, 0Fh
     cmp al, 0Ah
     sbb al, 69h
     das
     call putc
     pop eax
     ret
;-----------------------

;---------------------------
putc:
     push edx
     push ecx
     push ebx
     push eax

     mov eax, 4
     mov ebx, 1
     mov ecx, esp
     mov edx, 1
     int 80h

     pop eax
     pop ebx
     pop ecx
     pop edx
     ret
;-----------------------------

;-----------------------------
; ioctl subfunctions
%define TCGETS		0x5401 ; tty-"magic"
%define TCSETS		0x5402

; flags for 'em
%define ICANON	2	;.Do erase and kill processing.
%define ECHO	8	;.Enable echo.

     struc termios
	alignb 4
	.c_iflag:	resd 1	; input mode flags
	.c_oflag:	resd 1	; output mode flags
	.c_cflag:	resd 1	; control mode flags
	.c_lflag:	resd 1	; local mode flags
	.c_line:	resb 1	; line discipline
	.c_cc:		resb 19	; control characters
     endstruc
;---------------------------------

getc:
     push ebp
     mov ebp, esp

     sub esp, termios_size     ; make a place for current kbd mode

     push edx
     push ecx
     push ebx

     mov eax, SYS_IOCTL        ; get current mode
     mov ebx, STDIN
     mov ecx, TCGETS
     lea edx, [ebp - termios_size]
     int 80h

                               ; monkey with it
     and dword [ebp - termios_size + termios.c_lflag], ~(ICANON | ECHO)

     mov eax, SYS_IOCTL
     mov ebx, STDIN
     mov ecx, TCSETS
     lea edx, [ebp - termios_size]
     int 80h

     xor eax, eax
     push eax         ; this is the buffer to read into

     mov eax, SYS_READ
     mov ebx, STDIN
     mov ecx, esp     ; character goes on the stack
     mov edx, 1       ; just one
     int 80h          ; do it

                      ; restore normal kbd mode
     or dword [ebp - termios_size + termios.c_lflag], ICANON | ECHO

     mov eax, SYS_IOCTL
     mov ebx, STDIN
     mov ecx, TCSETS
     lea edx, [ebp - termios_size]
     int 80h

     pop eax          ; get character into al

     pop ebx          ; restore caller's regs
     pop ecx
     pop edx

     mov esp, ebp     ; leave
     pop ebp
     ret
;-------------------------

end Nasmcode;

begin Ccode;

/* 
***************************************************************************
  *
  *          Copyright 1992-2005 by Pete Wilson All Rights Reserved
  *           50 Staples Street : Lowell Massachusetts 01851 : USA
  *        <a href="http://www.pwilson.net/">http://www.pwilson.net/</a> 
   pete at pwilson dot net   +1 978-454-4547
  *
  * This item is free software: you can redistribute it and/or modify it as
  * long as you preserve this copyright notice. Pete Wilson prepared 
this item
  * hoping it might be useful, but it has NO WARRANTY WHATEVER, not even 
any
  * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 
PURPOSE.
  *

*************************************************************************** 
*/

/* 
***************************************************************************
  *
  *                          KBHIT.C
  *
  * Based on the work of W. Richard Stevens in "Advanced Programming in
  *   the Unix Environment," Addison-Wesley; and of Floyd Davidson.
  *
  * Contains these functions:
  *
  *  To set the TTY mode:
  *     tty_set_raw() Unix setup to read a character at a time.
  *     tty_set_cooked() Unix setup to reverse tty_set_raw()
  *
  *  To read keyboard input:
  *     kb_getc()      keyboard get character, NON-BLOCKING. If a char
  *                      has been typed, return it. Else return 0.
  *     kb_getc_w()    kb get char with wait: BLOCKING. Wait for a char
  *                      to be typed and return it.
  *
  *  How to use:
  *     tty_set_raw()  set the TTY mode to read one char at a time.
  *     kb_getc()      read chars one by one.
  *     tty_set_cooked() VERY IMPORTANT: restore cooked mode when done.
  *
  * Revision History:
  *
  *     DATE                  DESCRIPTION
  * -----------    --------------------------------------------
  * 12-jan-2002     new
  * 20-aug-2002     cleanup
  * 24-nov-2003     Fixed kb_getc() so that it really is non blocking(JH)
  * 10-sep-2006     Let kb_getc() work right under certain Unix/Linux 
flavors
  *

*************************************************************************** 
*/

#ifdef __cplusplus
   extern "C" {
#endif

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <termios.h>
#include <unistd.h>
#include <errno.h>

#ifndef STDIN_FILENO
   #define STDIN_FILENO 0
#endif

extern int errno;

static struct termios termattr, save_termattr;
static int ttysavefd = -1;
static enum
{
   RESET, RAW, CBREAK
} ttystate = RESET;

/* 
***************************************************************************
  *
  * set_tty_raw(), put the user's TTY in one-character-at-a-time mode.
  * returns 0 on success, -1 on failure.
  *

*************************************************************************** 
*/
int
set_tty_raw(void)
{
   int i;

   i = tcgetattr (STDIN_FILENO, &termattr);
   if (i < 0)
   {
     printf("tcgetattr() returned %d for fildes=%d\n",i,STDIN_FILENO);
     perror ("");
     return -1;
   }
   save_termattr = termattr;

   termattr.c_lflag &= ~(ECHO | ICANON | IEXTEN | ISIG);
   termattr.c_iflag &= ~(BRKINT | ICRNL | INPCK | ISTRIP | IXON);
   termattr.c_cflag &= ~(CSIZE | PARENB);
   termattr.c_cflag |= CS8;
   termattr.c_oflag &= ~(OPOST);

   termattr.c_cc[VMIN] = 1;  /* or 0 for some Unices; <a href="#note1"> 
see note 1</a> */
   termattr.c_cc[VTIME] = 0;

   i = tcsetattr (STDIN_FILENO, TCSANOW, &termattr);
   if (i < 0)
   {
     printf("tcsetattr() returned %d for fildes=%d\n",i,STDIN_FILENO);
     perror("");
     return -1;
   }

   ttystate = RAW;
   ttysavefd = STDIN_FILENO;

   return 0;
}

/* 
***************************************************************************
  *
  * set_tty_cbreak(), put the user's TTY in cbreak mode.
  * returns 0 on success, -1 on failure.
  *

*************************************************************************** 
*/
int
set_tty_cbreak()
{
   int i;

   i = tcgetattr (STDIN_FILENO, &termattr);
   if (i < 0)
   {
     printf("tcgetattr() returned %d for fildes=%d\n",i,STDIN_FILENO);
     perror ("");
     return -1;
   }

   save_termattr = termattr;

   termattr.c_lflag &= ~(ECHO | ICANON);
   termattr.c_cc[VMIN] = 1;
   termattr.c_cc[VTIME] = 0;

   i = tcsetattr (STDIN_FILENO, TCSANOW, &termattr);
   if (i < 0)
   {
     printf("tcsetattr() returned %d for fildes=%d\n",i,STDIN_FILENO);
     perror ("");
     return -1;
   }
   ttystate = CBREAK;
   ttysavefd = STDIN_FILENO;

   return 0;
}

/* 
***************************************************************************
  *
  * set_tty_cooked(), restore normal TTY mode. Very important to call
  *   the function before exiting else the TTY won't be too usable.
  * returns 0 on success, -1 on failure.
  *

*************************************************************************** 
*/
int
set_tty_cooked()
{
   int i;
   if (ttystate != CBREAK && ttystate != RAW)
   {
     return 0;
   }
   i = tcsetattr (STDIN_FILENO, TCSAFLUSH, &save_termattr);
   if (i < 0)
   {
     return -1;
   }
   ttystate = RESET;
   return 0;
}

/* 
***************************************************************************
  *
  * kb_getc(), if there's a typed character waiting to be read,
  *   return it; else return 0.
  * 10-sep-2006: kb_getc() fails (it hangs on the read() and never returns
  * until a char is typed) under some Unix/Linux versions: ubuntu, suse, and
  * maybe others. To make it work, please uncomment two source lines below.
  *

*************************************************************************** 
*/
unsigned char
kb_getc(void)
{
   int i;
   unsigned char ch;
   ssize_t size;
/*  termattr.c_cc[VMIN] = 0; */ /* uncomment if needed */
   i = tcsetattr (STDIN_FILENO, TCSANOW, &termattr);
   size = read (STDIN_FILENO, &ch, 1);
/*  termattr.c_cc[VMIN] = 1; */ /* uncomment if needed */
   i = tcsetattr (STDIN_FILENO, TCSANOW, &termattr);
   if (size == 0)
   {
     return 0;
   }
   else
   {
     return ch;
   }
}

/* 
***************************************************************************
  *
  * kb_getc_w(), wait for a character to be typed and return it.
  *

*************************************************************************** 
*/
unsigned char
kb_getc_w(void)
{
   unsigned char ch;
   size_t size;

   while (1)
   {

     usleep(20000);        /* 1/50th second: thanks, Floyd! */

     size = read (STDIN_FILENO, &ch, 1);
     if (size > 0)
     {
       break;
     }
   }
   return ch;
}

#define TEST
#ifdef TEST

void echo(unsigned char ch);

static enum
{
   CH_ONLY, CH_HEX
} how_echo = CH_ONLY;

int
main(int argc, char * argv[])
{
   unsigned char ch;

   printf("Test Unix single-character input.\n");

   printf("termios size %d\n", sizeof(struct termios));

   set_tty_raw();         /* set up character-at-a-time */

   while (1)              /* wait here for a typed char */
   {
     usleep(20000);       /* 1/50th second: thanks, Floyd! */
     ch = kb_getc();      /* char typed by user? */
     if (0x03 == ch)      /* might be control-C */
     {
       set_tty_cooked();  /* control-C, restore normal TTY mode */
       return 1;          /* and get out */
     }
     echo(ch);            /* not control-C, echo it */
   }
}

void
echo(unsigned char ch)
{
   switch (how_echo)
   {
   case CH_HEX:
     printf("%c,0x%x  ",ch,ch);
     break;
   default:
   case CH_ONLY:
     printf("%c", ch);
     break;
   }

   fflush(stdout);      /* push it out */
}

#endif /* test */

#ifdef __cplusplus
}
#endif

end Ccode;
:)

2006	Jan	Feb	Mar	Apr (1)	May (2)	Jun (2)	Jul (5)	Aug (8)	Sep	Oct	Nov (3)	Dec
2007	Jan	Feb	Mar	Apr	May	Jun	Jul (5)	Aug	Sep (6)	Oct	Nov	Dec
2008	Jan (3)	Feb (7)	Mar	Apr	May	Jun	Jul (1)	Aug (13)	Sep (6)	Oct	Nov	Dec
2009	Jan	Feb (1)	Mar	Apr	May	Jun	Jul	Aug	Sep	Oct	Nov	Dec
2011	Jan	Feb	Mar	Apr	May	Jun	Jul	Aug (1)	Sep	Oct	Nov	Dec
2013	Jan	Feb	Mar (1)	Apr	May	Jun	Jul	Aug	Sep	Oct	Nov	Dec

hla-stdlib-talk Mailing List for HLA Standard Library (Page 2)

hla-stdlib-talk — Talk about HLA StdLib issues