int main() {

	int value = 0;

	while (1) {
		printf("working...\n");
		sleep(1);

		scanf("%f", &value);

		if (value == 1) break;	

	} 

	return 0;
	
}		// end main

stty eof "^D"

/*
 * Demonstration of two functions that act more-or-less like
 * the traditional dos getch() and kbhit() functions.
 *
 * Have been tested with gcc 3.4.x and 4.x on various
 * Linux systems.
 *
 * Also tested on Windows XP/cygwin with gcc 3.4.x
 *
 * They work for me, but Your Mileage May Vary.
 *
 * davekw7x
 *
 */

#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <time.h>
#include <sys/time.h>
#include <unistd.h>
#include <termios.h>

#ifndef STDIN_FILENO
#define STDIN_FILENO 0
#endif


struct termios tty_set_raw();
void tty_restore(struct termios oldstuff);
int linux_getch(void);
int linux_kbhit(void);


int main()
{
    unsigned ticknumber = 0;
    int kb_char;
    time_t now;
    struct termios save_attr;
    int i;

    printf(
     "\n\n  This is a test of two functions that (more-or-less) emulate the\n"
     "  classic DOS \"getch()\"  and \"kbhit()\" functions.\n\n"
     "  The keyboard routine is set so that ctlr-d is EOF.\n\n"
     "  Just to prove that it isn't really hanging while waiting for user \n"
     "  input, the program prints out a marker every second."
     "\n\n");

    now = time(0);

    i = 0;
    save_attr = tty_set_raw();

    while (1) {
        usleep(1);            /* keep from hogging cpu time  */
        if (time(0) != now) { /* show something every second */
            now = time(0);
            printf("Tick %u\n", ++ticknumber);
        }
        else if (linux_kbhit()) {
            kb_char = linux_getch();
            if (kb_char == EOF) {
                printf("EOF\n");
                break;
            }
            if (kb_char == 0x03) {
                printf("Ctrl-C breaks out of the loop\n");
                break;
            }
            if (isprint(kb_char)) {
                printf("'%c'", kb_char);
            }
            else {
                printf("   ");
            }
            printf(" (%02x hex)\n", kb_char);
        }
    }
    tty_restore(save_attr);
    return 0;
}

int linux_kbhit()
{
    struct timeval tv = {0,0}; /* set one microsecond timeout */
    fd_set rdfds;
    int retval;

    FD_ZERO(&rdfds);
    FD_SET(STDIN_FILENO, &rdfds);

    if (select(STDIN_FILENO + 1, &rdfds, NULL, NULL, &tv) == -1) {
        perror("select");
        exit(1);
    }
    if (FD_ISSET(STDIN_FILENO, &rdfds)) {
        retval = 1;
    }
    else {
        retval = 0;
    }
    return retval;
}

struct termios tty_set_raw()
{
    struct termios oldstuff;
    struct termios newstuff;

    tcgetattr(STDIN_FILENO, &oldstuff);/* save old attributes          */
    newstuff = oldstuff;
    /* 
     * Resetting these flags will set the terminal to raw mode.
     * Note that ctrl-c won't cause program exit, so there
     * is no emergency panic escape. (If your calling program
     * doesn't handle things properly, you will have to kill
     * the process externally.)
     */
    newstuff.c_lflag &= ~(ICANON | ECHO | IGNBRK);

    tcsetattr(STDIN_FILENO, TCSANOW, &newstuff);/* set new attributes  */
    return oldstuff;
}

void tty_restore(struct termios oldstuff)
{
    tcsetattr(STDIN_FILENO, TCSANOW, &oldstuff);/* restore old attributes */
}

#define END_FILE_CHARACTER 0x04 /* ctrl-d is unix-style eof input key */

/* 
 * Waits until a key has been pressed, then reads.
 * Since this is "raw" mode, EOF is a special case
 *
 * This can be used in the same program where the tty has been
 * set to "no-wait".
 *
 */
int linux_getch(void)
{
    char inch;
    int num_chars;

    do {
        num_chars = read(0, &inch, 1);
    } while (num_chars < 1);

    if (inch == END_FILE_CHARACTER) {
        inch = EOF;
    }

    return inch;
}