自学教程：C++ update_input函数代码示例

/* input_backspace: does a backspace in the input buffer */void input_backspace(char key, char *blah){    cursor_to_input();    if (THIS_POS > MIN_POS) {	char *ptr = NULL;	int pos;	malloc_strcpy(&ptr, &(THIS_CHAR));	strcpy(&(PREV_CHAR), ptr);	new_free(&ptr);	THIS_POS--;	term_cursor_left();	if (THIS_CHAR) {	    if (term_delete())		update_input(UPDATE_FROM_CURSOR);	    {		pos = str_start + term_cols - 1;		pos += count_ansi(&(current_screen->input_buffer[str_start]), zone);		if (pos < strlen(INPUT_BUFFER)) {		    term_move_cursor(term_cols - 1, input_line);		    term_putchar(INPUT_BUFFER[pos]);		}		update_input(UPDATE_JUST_CURSOR);	    }	} else {	    term_putchar(' ');	    term_cursor_left();	    update_input(NO_UPDATE);	}    }    in_completion = STATE_NORMAL;    *new_nick = 0;}

/* input_delete_character: deletes a character from the input line */void input_delete_character(char unused, char *not_used){    cursor_to_input();    if (THIS_CHAR) {	char *ptr = NULL;	int pos;	malloc_strcpy(&ptr, &(NEXT_CHAR));	strcpy(&(THIS_CHAR), ptr);	new_free(&ptr);	if (term_delete())	    update_input(UPDATE_FROM_CURSOR);	else {	    pos = str_start + term_cols - 1;	    pos += count_ansi(&(current_screen->input_buffer[str_start]), zone);	    if (pos < strlen(INPUT_BUFFER)) {		term_move_cursor(term_cols - 1, input_line);		term_putchar(INPUT_BUFFER[pos]);		term_move_cursor(cursor, input_line);	    }	    update_input(NO_UPDATE);	}    }    in_completion = STATE_NORMAL;}

void main(){	auto int key, reading, channel,device0;	auto rn_search newdev;	brdInit();                 //initialize controller   rn_init(RN_PORTS, 1);      //initialize controller RN ports   //search for device match	newdev.flags = MATCHFLAG;	newdev.productid = MATCHPID;   if ((device0 = rn_find(&newdev)) == -1)   {   	printf("/n no device found/n");      exit(0);   }	//Display user instructions and channel headings	DispStr(8, 1, GREEN, "/t/t<<< Digital inputs 0 - 23 >>>");	DispStr(8, 3, BLACK, "IN00/tIN01/tIN02/tIN03/tIN04/tIN05/tIN06/tIN07");	DispStr(8, 4, BLACK, "----/t----/t----/t----/t----/t----/t----/t----");	DispStr(8, 7, BLACK, "IN08/tIN09/tIN10/tIN11/tIN12/tIN13/tIN14/tIN15");	DispStr(8, 8, BLACK, "----/t----/t----/t----/t----/t----/t----/t----");	DispStr(8,11, BLACK, "IN16/tIN17/tIN18/tIN19/tIN20/tIN21/tIN22/tIN23");	DispStr(8,12, BLACK, "----/t----/t----/t----/t----/t----/t----/t----");	DispStr(8, 16, RED, "Connect the Demo Bd. switches to the inputs that you what to toggle.");	DispStr(8, 17, RED, "(See instructions in sample program for complete details)");	DispStr(8, 19, RED, "<-PRESS 'Q' TO QUIT->");	//loop until user presses the "Q" key	for(;;)	{		// update input channels 0 - 7   (display at col = 8 row = 5)		update_input(device0, 1, 8, 5);		// update input channels 8 - 15  (display at col = 8 row = 9)		update_input(device0, 2, 8, 9);		// update input channels 16 - 23  (display at col = 8 row = 13)		update_input(device0, 3, 8, 13);		if(kbhit())		{			key = getchar();			if (key == 'Q' || key == 'q')		// check if it's the q or Q key			{				while(kbhit()) getchar();      		exit(0);     		}		}   }}

// check if any keys or buttons1 are pressedboolany_key_pressed (void){  int i;  bool ret = FALSE;  update_input();  for (i=0; i<KEY_PACK(SDLK_LAST); i++)    if ( just_pressed(input_state[i]) )      { 	clear_fresh(input_state[i]);	ret = TRUE; 	break;      }  if ( just_pressed(input_state[KEY_PACK(JOY_BUTTON1)]) )    {      clear_fresh (input_state[KEY_PACK(JOY_BUTTON1)]);      ret = TRUE;    }  if ( just_pressed(input_state[KEY_PACK(MOUSE_BUTTON1)]) )    {      ret = TRUE;      clear_fresh (input_state[KEY_PACK(MOUSE_BUTTON1)]);    }  return (ret);}  // any_key_pressed()

boolKeyIsPressed (SDLKey key){  update_input();  return( (input_state[KEY_PACK(key)] & PRESSED) == PRESSED );}

voidhistory_cmd (void){    Listbox *listbox;    GList *current;    if (cmdline->need_push) {	if (push_history (cmdline, cmdline->buffer) == 2)	    cmdline->need_push = 0;    }    if (!cmdline->history) {	message (1, MSG_ERROR, _(" The command history is empty "));	return;    }    current = g_list_first (cmdline->history);    listbox = create_listbox_window (60, 10, _(" Command history "),				     "[Command Menu]");    while (current) {	LISTBOX_APPEND_TEXT (listbox, 0, (char *) current->data, current);	current = g_list_next(current);    }    run_dlg (listbox->dlg);    if (listbox->dlg->ret_value == B_CANCEL)	current = NULL;    else	current = listbox->list->current->data;    destroy_dlg (listbox->dlg);    g_free (listbox);    if (!current)	return;    cmdline->history = current;    assign_text (cmdline, (char *) current->data);    update_input (cmdline, 1);}

void retro_run(void){   uint32_t x, y;   const uint8_t *buffer;   uint32_t *surface, pitch;   update_input();   prosystem_ExecuteFrame(keyboard_data); // wants input   videoWidth  = Rect_GetLength(&maria_visibleArea);   videoHeight = Rect_GetHeight(&maria_visibleArea);   buffer      = maria_surface + ((maria_visibleArea.top - maria_displayArea.top) * Rect_GetLength(&maria_visibleArea));   surface     = (uint32_t*)videoBuffer;   pitch       = 320;   for(y = 0; y < videoHeight; y++)   {      for(x = 0; x < videoWidth; x += 4)      {         surface[x + 0] = display_palette32[buffer[x + 0]];         surface[x + 1] = display_palette32[buffer[x + 1]];         surface[x + 2] = display_palette32[buffer[x + 2]];         surface[x + 3] = display_palette32[buffer[x + 3]];      }      surface += pitch;      buffer  += videoWidth;   }   video_cb(videoBuffer, videoWidth, videoHeight, videoWidth << 2);   sound_Store();}

int run_emu(const char *path){	SceCtrlData pad;	unsigned int joypad1, joypad2;		setup_audio();	emu->set_sample_rate(44100);	emu->set_equalizer(Nes_Emu::nes_eq);	emu->set_palette_range(0);	vita2d_texture *tex = vita2d_create_empty_texture(Nes_Emu::image_width, Nes_Emu::image_height);	void *tex_data = vita2d_texture_get_datap(tex);	static uint32_t video_buffer[Nes_Emu::image_width * Nes_Emu::image_height];	emu->set_pixels(video_buffer, Nes_Emu::image_width);	Auto_File_Reader freader(path);	emu->load_ines(freader);	int scale = 2;	int pos_x = SCREEN_W/2 - (Nes_Emu::image_width/2)*scale;	int pos_y = SCREEN_H/2 - (Nes_Emu::image_height/2)*scale;	while (1) {		sceCtrlPeekBufferPositive(0, &pad, 1);		if ((pad.buttons & CHANGE_GAME_MASK) == CHANGE_GAME_MASK) break;		joypad1 = joypad2 = update_input(&pad);		emu->emulate_frame(joypad1, joypad2);		const Nes_Emu::frame_t &frame = emu->frame();		const uint8_t *in_pixels = frame.pixels;		uint32_t *out_pixels = (uint32_t *)tex_data;		for (unsigned h = 0; h < Nes_Emu::image_height;			h++, in_pixels += frame.pitch, out_pixels += Nes_Emu::image_width) {			for (unsigned w = 0; w < Nes_Emu::image_width; w++) {				unsigned col = frame.palette[in_pixels[w]];				const Nes_Emu::rgb_t& rgb = emu->nes_colors[col];				unsigned r = rgb.red;				unsigned g = rgb.green;				unsigned b = rgb.blue;				out_pixels[w] = 0xFF000000 | (r << 0) | (g << 8) | (b << 16);			}		}		vita2d_start_drawing();		vita2d_clear_screen();		vita2d_draw_texture_scale(tex, pos_x, pos_y, scale, scale);		show_fps();		vita2d_end_drawing();		vita2d_swap_buffers();	}	return 0;}

/* * input_beginning_of_line: moves the input cursor to the first character in * the input buffer  */void new_input_beginning_of_line(char unused, char *not_used){    cursor_to_input();    THIS_POS = MIN_POS;    update_input(UPDATE_JUST_CURSOR);    extended_handled = 1;}

/* * refresh_screen: Whenever the REFRESH_SCREEN function is activated, this * swoops into effect  */void refresh_screen (unsigned char dumb, char *dumber){extern int need_redraw;#if !defined(WINNT) && !defined(__EMX__)	term_clear_screen();	unflash();#else	xterm_settitle();	term_clear_screen();#endif#if 0	for (tmp = screen_list; tmp; tmp = tmp->next)		tmp->co = TI_cols, tmp->li = TI_lines;#endif	if (term_resize())		recalculate_windows(current_window->screen);	else		redraw_all_windows();	if (need_redraw)		need_redraw = 0;	update_all_windows();	update_input(UPDATE_ALL);}

void nick_completion(char dumb, char *dumber){    char *q, *line;    int i = -1;    char *nick = NULL, *tmp;    q = line = m_strdup(&current_screen->input_buffer[MIN_POS]);    if (in_completion == STATE_NORMAL) {	i = word_count(line);	nick = extract_words(line, i - 1, i);    }    if (nick)	line[strlen(line) - strlen(nick)] = 0;    else	*line = 0;    if ((tmp = getchannick(input_lastmsg, nick && *nick ? nick : NULL))) {	malloc_strcat(&q, tmp);	set_input(q);	update_input(UPDATE_ALL);	malloc_strcpy(&input_lastmsg, tmp);	in_completion = STATE_COMPLETE;    }    new_free(&q);    new_free(&nick);}

void retro_run(void){   int x;   unsigned width = 640;   unsigned height = 400;   bool updated = false;   if (environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE_UPDATE, &updated) && updated)      update_variables();   if(pauseg==0)   {      update_input();      if(SND==1)      {         int16_t *p=(int16_t*)SNDBUF;         for(x = 0; x < snd_sampler; x++)            audio_cb(*p++,*p++);      }   }   if(ConfigureParams.Screen.bAllowOverscan || SHOWKEY==1 || STATUTON==1 || pauseg==1 )   {      width  = retrow;      height = retroh;   }   video_cb(bmp, width, height, retrow<< 1);   co_switch(emuThread);}

void retro_run(void){   int x;   bool updated = false;   if (environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE_UPDATE, &updated) && updated)      update_variables();   if(pauseg==0){      update_input();      if(SND==1){         signed short int *p=(signed short int *)SNDBUF;         for(x=0;x<snd_sampler;x++)audio_cb(*p++,*p++);			      }	   }      if(ConfigureParams.Screen.bAllowOverscan || SHOWKEY==1 || STATUTON==1 || pauseg==1 )video_cb(bmp,retrow,retroh, retrow<< 1);   // EMU ST FULLSCREEN NO BORDER   else video_cb(bmp,640/*retrow*/,400/*retrow-80*/,retrow << 1);   co_switch(emuThread);}

void retro_run(void){   bool updated = false;   if (environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE_UPDATE, &updated) && updated)      check_variables();   update_input();   JaguarExecuteNew();	static int lastw=STARTWIDTH;	if(lastw!=TOMGetVideoModeWidth()){		retro_get_system_av_info(&g_av_info);		printf("width change:%d-" ,lastw);		lastw=TOMGetVideoModeWidth();		printf(">%d/n" ,lastw);	    game_width = TOMGetVideoModeWidth();	    game_height = TOMGetVideoModeHeight();		tomWidth = game_width; tomHeight = game_height;		printf("new res:%dx%d %f/n",game_width,game_height,(float)game_width/game_height);		bool ret;		ret = environ_cb(RETRO_ENVIRONMENT_SET_GEOMETRY, &g_av_info.geometry);	}   SDLSoundCallback(NULL,sampleBuffer, vjs.hardwareTypeNTSC==1?BUFNTSC:BUFPAL);   video_cb(videoBuffer, game_width, game_height, MAXWIDTH << 2);   audio_batch_cb((int16_t *)sampleBuffer, vjs.hardwareTypeNTSC==1?BUFNTSC/2:BUFPAL/2);}

static int insert_text (WInput *in, char *text, ssize_t len){    len = min (len, (ssize_t) strlen (text)) + start - end;    if (strlen (in->buffer) + len >= (size_t) in->current_max_len){    /* Expand the buffer */    	char *narea = g_realloc (in->buffer, in->current_max_len + len + in->field_len);	if (narea){	    in->buffer = narea;	    in->current_max_len += len + in->field_len;	}    }    if (strlen (in->buffer)+1 < (size_t) in->current_max_len){    	if (len > 0){	    int i = strlen (&in->buffer [end]);	    for (; i >= 0; i--)	        in->buffer [end + len + i] = in->buffer [end + i];	} else if (len < 0){	    char *p = in->buffer + end + len, *q = in->buffer + end;	    while (*q)	    	*(p++) = *(q++);	    *p = 0;	}	memcpy (in->buffer + start, text, len - start + end);	in->point += len;	update_input (in, 1);	end += len;    }    return len != 0;}

void	redraw_all_screens (void){	Screen *s, *old_os;	old_os = output_screen;	for (s = screen_list; s; s = s->next)	{		if (!s->alive)			continue;		output_screen = s;		unflash();		term_clear_screen();		if (s == main_screen && term_resize())			recalculate_windows(current_window->screen);	}	/* Logically mark all windows as needing a redraw */	redraw_all_windows();	/* Physically redraw all windows and status bars */	update_all_windows();	/* Physically redraw all input lines */	update_input(NULL, UPDATE_ALL);	output_screen = old_os;	need_redraw = 0;}

void retro_run(){    input_poll_cb();        update_input();        static int16_t sound_buf[0x10000];    static MDFN_Rect rects[384];        EmulateSpecStruct spec = {0};     spec.surface = surf;    spec.SoundRate = 48000;    spec.SoundBuf = sound_buf;    spec.LineWidths = rects;    spec.SoundBufMaxSize = sizeof(sound_buf) / 2;    spec.SoundVolume = 1.0;    spec.soundmultiplier = 1.0;        MDFNI_Emulate(&spec);        //unsigned width = rects[0].w;    //unsigned height = spec.DisplayRect.h;    unsigned width = 384;    unsigned height = 224;        convert_surface();    video_cb(conv_buf, width, height, width << 1);        audio_batch_cb(spec.SoundBuf, spec.SoundBufSize);}

void refresh_window_screen(Window *window){   xterm_settitle();   recalculate_windows(current_window->screen);   update_all_windows();   update_input(UPDATE_ALL);}

/* * This removes every character from the 'anchor' position to the current * position from the input line, and puts it into the cut buffer.  It does * the requisite redraw as well. */static void	cut_input (int anchor){	char *	buffer;	size_t	size;	if (anchor < THIS_POS)	{		size = THIS_POS - anchor;		buffer = alloca(size + 1);		strlcpy(buffer, &INPUT_BUFFER[anchor], size + 1);		malloc_strcpy(&cut_buffer, buffer);		buffer = LOCAL_COPY(&THIS_CHAR);		INPUT_BUFFER[anchor] = 0;		ADD_TO_INPUT(buffer);		THIS_POS = anchor;	}	else	{		size = anchor - THIS_POS;		buffer = alloca(size + 1);		strlcpy(buffer, &THIS_CHAR, size + 1);		malloc_strcpy(&cut_buffer, buffer);		buffer = LOCAL_COPY(&INPUT_BUFFER[anchor]);		THIS_CHAR = 0;		ADD_TO_INPUT(buffer);	}	update_input(UPDATE_ALL);}

void retro_run(){   MDFNGI *curgame = game;   input_poll_cb();   update_input();   static int16_t sound_buf[0x10000];   static MDFN_Rect rects[FB_MAX_HEIGHT];   rects[0].w = ~0;   EmulateSpecStruct spec = {0};   spec.surface = surf;   spec.SoundRate = 44100;   spec.SoundBuf = sound_buf;   spec.LineWidths = rects;   spec.SoundBufMaxSize = sizeof(sound_buf) / 2;   spec.SoundVolume = 1.0;   spec.soundmultiplier = 1.0;   spec.SoundBufSize = 0;   spec.VideoFormatChanged = false;   spec.SoundFormatChanged = false;   if (memcmp(&last_pixel_format, &spec.surface->format, sizeof(MDFN_PixelFormat)))   {      spec.VideoFormatChanged = TRUE;      last_pixel_format = spec.surface->format;   }   if (spec.SoundRate != last_sound_rate)   {      spec.SoundFormatChanged = true;      last_sound_rate = spec.SoundRate;   }   curgame->Emulate(&spec);   int16 *const SoundBuf = spec.SoundBuf + spec.SoundBufSizeALMS * curgame->soundchan;   int32 SoundBufSize = spec.SoundBufSize - spec.SoundBufSizeALMS;   const int32 SoundBufMaxSize = spec.SoundBufMaxSize - spec.SoundBufSizeALMS;   spec.SoundBufSize = spec.SoundBufSizeALMS + SoundBufSize;   unsigned width  = spec.DisplayRect.w;   unsigned height = spec.DisplayRect.h;   const uint16_t *pix = surf->pixels16;   video_cb(pix, width, height, FB_WIDTH << 1);   video_frames++;   audio_frames += spec.SoundBufSize;   audio_batch_cb(spec.SoundBuf, spec.SoundBufSize);   bool updated = false;   if (environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE_UPDATE, &updated) && updated)      check_variables();}

/* * input_transpose_characters: swaps the positions of the two characters * before the cursor position  */void input_transpose_characters(char unused, char *not_used){    cursor_to_input();    if (current_screen->buffer_pos > MIN_POS) {	u_char c1[3] = { 0 };	int pos, end_of_line = 0;	if (THIS_CHAR)	    pos = THIS_POS;	else if (strlen(get_input()) > MIN_POS + 2) {	    pos = THIS_CHAR - 1;	    end_of_line = 1;	} else	    return;	c1[0] = INPUT_BUFFER[pos];	c1[1] = INPUT_BUFFER[pos] = INPUT_BUFFER[pos - 1];	INPUT_BUFFER[pos - 1] = c1[0];	term_cursor_left();	if (end_of_line)	    term_cursor_left();	term_putchar(c1[0]);	term_putchar(c1[1]);	if (!end_of_line)	    term_cursor_left();	update_input(NO_UPDATE);    }}

void 	change_input_prompt (int direction){	/* XXXXXX THIS is totaly wrong. XXXXXX */	if (!last_input_screen->promptlist)	{		strlcpy(INPUT_BUFFER, last_input_screen->saved_input_buffer, sizeof INPUT_BUFFER);		THIS_POS = last_input_screen->saved_buffer_pos;		MIN_POS = last_input_screen->saved_min_buffer_pos;		*last_input_screen->saved_input_buffer = 0;		last_input_screen->saved_buffer_pos = 0;		last_input_screen->saved_min_buffer_pos = 0;	}	else if (direction == -1)		;	else if (!last_input_screen->promptlist->next)	{		strlcpy(last_input_screen->saved_input_buffer, INPUT_BUFFER, sizeof INPUT_BUFFER);		last_input_screen->saved_buffer_pos = THIS_POS;		last_input_screen->saved_min_buffer_pos = MIN_POS;		*INPUT_BUFFER = 0;		THIS_POS = MIN_POS = 0;	}	update_input(UPDATE_ALL);}

static void p_part(char *from, char **ArgList){    char *channel;    if (!from || !*from)	return;    channel = ArgList[0];    PasteArgs(ArgList, 1);    message_from(channel, LOG_CRAP);    in_on_who = 1;    if ((check_ignore(from, FromUserHost, channel, IGNORE_PARTS | IGNORE_CRAP, NULL) != IGNORED) &&	do_hook(LEAVE_LIST, "%s %s %s %s", from, channel, FromUserHost, ArgList[1] ? ArgList[1] : empty_str))	put_it("%s",	       convert_output_format(get_format(FORMAT_LEAVE_FSET), "%s %s %s %s %s", update_clock(GET_TIME), from, FromUserHost,				     channel, ArgList[1] ? ArgList[1] : empty_str));    if (!my_stricmp(from, get_server_nickname(from_server))) {	remove_channel(channel, from_server);	remove_from_mode_list(channel, from_server);	remove_from_join_list(channel, from_server);	set_input_prompt(curr_scr_win, get_string_var(INPUT_PROMPT_VAR), 0);    } else {	remove_from_channel(channel, from, from_server, 0, NULL);    }    update_all_status(curr_scr_win, NULL, 0);    update_input(UPDATE_ALL);    message_from(NULL, LOG_CRAP);    in_on_who = 0;}

static void reinit_screen(Window *win, char *unused, int value){	set_input_prompt(current_window, NULL, 0);	set_input_prompt(current_window, get_string_var(INPUT_PROMPT_VAR), 0);	update_all_windows();	update_all_status(current_window, NULL, 0);	update_input(UPDATE_ALL);}

/* input_clear_to_eol: erases from the cursor to the end of the input buffer */void input_clear_to_eol(char unused, char *not_used){    cursor_to_input();    malloc_strcpy(&cut_buffer, &(THIS_CHAR));    THIS_CHAR = 0;    term_clear_to_eol();    update_input(NO_UPDATE);}

 tracker<F>& tracker<F>::run(const I& in) {   //copy(in, input_);   //fill_border_clamp(input_);   update_input(in);   run();   return *this; }

static voidinput_do_set_cursor_pos(unsigned pos){	ScreenInputData *inputdata = screen_get_inputdata(get_current_screen());	inputdata->buffer.pos = pos;	update_input(UPDATE_JUST_CURSOR);}

boolModIsPressed (SDLMod mod){  bool ret;  update_input();  ret = ( (current_modifiers & mod) != 0) ;  return (ret);}

/*----------------------------------------------------------------- * Desc: should do roughly what getchar() does, but in raw * 	 (SLD) keyboard mode. * * Return: the (SDLKey) of the next key-pressed event cast to (int) * *-----------------------------------------------------------------*/intgetchar_raw (void){  SDL_Event event;  int Returnkey = 0;  //  keyboard_update ();   /* treat all pending keyboard-events */  while ( !Returnkey )    {      SDL_WaitEvent (&event);    /* wait for next event */      switch (event.type)	{	case SDL_KEYDOWN:	  /*	   * here we use the fact that, I cite from SDL_keyboard.h:	   * "The keyboard syms have been cleverly chosen to map to ASCII"	   * ... I hope that this design feature is portable, and durable ;)	   */	  Returnkey = (int) event.key.keysym.sym;	  if ( event.key.keysym.mod & KMOD_SHIFT )	    Returnkey = toupper( (int)event.key.keysym.sym );	  break;	case SDL_JOYBUTTONDOWN:	  if (event.jbutton.button == 0)	    Returnkey = JOY_BUTTON1;	  else if (event.jbutton.button == 1)	    Returnkey = JOY_BUTTON2;	  else if (event.jbutton.button == 2)	    Returnkey = JOY_BUTTON3;	  break;	case SDL_MOUSEBUTTONDOWN:	  if (event.button.button == SDL_BUTTON_LEFT)	    Returnkey = MOUSE_BUTTON1;	  else if (event.button.button == SDL_BUTTON_RIGHT)	    Returnkey = MOUSE_BUTTON2;	  else if (event.button.button == SDL_BUTTON_MIDDLE)	    Returnkey = MOUSE_BUTTON3;	  else if (event.button.button == SDL_BUTTON_WHEELUP)	    Returnkey = MOUSE_WHEELUP;	  else if (event.button.button == SDL_BUTTON_WHEELDOWN)	    Returnkey = MOUSE_WHEELDOWN;	  break;	default:	  SDL_PushEvent (&event);  /* put this event back into the queue */	  update_input ();  /* and treat it the usual way */	  continue;	}    } /* while(1) */  return ( Returnkey );} /* getchar_raw() */

/* * input_yank_cut_buffer: takes the contents of the cut buffer and inserts it * into the input line  */void input_yank_cut_buffer(char unused, char *not_used){    char *ptr = NULL;    if (cut_buffer) {	malloc_strcpy(&ptr, &(THIS_CHAR));	/* Ooops... */	THIS_CHAR = 0;	ADD_TO_INPUT(cut_buffer);	ADD_TO_INPUT(ptr);	new_free(&ptr);	update_input(UPDATE_FROM_CURSOR);	THIS_POS += strlen(cut_buffer);	if (THIS_POS > INPUT_BUFFER_SIZE)	    THIS_POS = INPUT_BUFFER_SIZE;	update_input(UPDATE_JUST_CURSOR);    }}