Usa el stack.
Por ejemplo con la cadena 'mi caso,a.' tiene que ocurrir esto:
'm': la introduzco al stack. stack: 'm'
'i': la introduzco al stack. stack: 'mi'
' ': la introduzco al stack. stack: 'mi '
'c': la introduzco al stack. stack: 'mi c'
'a': la introduzco al stack. stack: 'mi ca'
's': la introduzco al stack. stack: 'mi cas'
'o': la introduzco al stack. stack: 'mi caso'
',': borro el ultimo elemento del stack. stack: 'mi cas'
'a': la introduzco al stack.  stack: 'mi casa'
'.': dejo de procesar la cadena. stack: 'mi casa'

Por tanto debes hacer uso del stack que te han proporcionado para realizar el trabajo.
Además deberás inventar algo para poder imprimir la cadena que hay guardada en la stack en orden y sin vaciarla.

Espero que así explicado veas que no hay que usar ese array auxiliar. Si sabes usar un stack (el ejercicio está pensado para eso) no te será difícil.

Según entiendo se debe mostrar la cadena procesada hasta ese momento. Pero cuando encuentras el '.' cierras el programa directamente.
Para el '!' escribes un '\0' (que te machaca el carácter que has escrito anteriormente), muestras tmpCad (recuerda que solo tiene '\0') y regresas de la función sin mirar los demás caracteres.

---

Además tienes toda una pila que no usas para nada. ¿Estás seguro que debes usar el array tmpCad para el ejercicio?

Eso es .Net, como trabaje sin ese framework deberá encontrar otra cosa.

Te recomiendo este hilo: https://foro.elhacker.net/programacion_cc/escapar_de_un_ciclo_con_getasynckeystate-t511897.0.html

Si cuando vas a escribir un nuevo post o una respuesta miras la barra de herramientas que hay justo encima del cuando de entrada, hay una lista desplegable que dice Código GeSHi. En ella hay muchos lenguajes. Debes elegir con el que vas a escribir el trozo de código.

Automáticamente aparecerá un par de etiquetas en el cuadro de escritura entre corchetes con code=lenguaje y /code. Entre las dos etiquetas escribes tu código.

Usa etiquetas GeSHi para poner tu código, lo encontrarás como desplegable en la barra de botones del post.

Respondiendo a tu mensaje cambia ese 0x8000 por un 1.
El 0x8000 lo que hace es mirar si la tecla se está pulsando durante la llamada a la función, el 1 informa si desde la anterior llamada a la función se ha pulsado la tecla, es decir, informa si la tecla en algún momento ha sido pulsada. Creo que ese es el comportamiento que estás buscando.

Aquí está la información al completo de cómo funciona: https://docs.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-getasynckeystate

Para entender cómo funciona eso debes comprender sobre el ámbito de las variables. Una variable existe desde el bloque que se crea (lo que hay dentro de unas llaves { }) y ocupa tanto a ese bloque como a todos los internos. Por lo tanto un bloque interno puede manipular una variable de un bloque más externo y esta se verá afectada pues sigue trabajando en su bloque.

Después está la ocultación: una puede declarar una variable en un bloque interno con el mismo nombre que una variable de un bloque externo. A partir de entonces y hasta el final de ese bloque interno cunado se nombre dicha variable hará referencia a la del bloque interno, la más externa está oculta del código.

Un programa ejemplo:

#include <stdio.h>
 
int main() {
    int dato = 6;
 
    printf("Dato del bloque externo: %d\n", dato);
 
    {
        int dato = 7; // El dato de este bloque oculta al del bloque externo
        printf("Dato dentro del primer bloque: %d\n", dato);
    }
 
    printf("Dato del bloque externo: %d\n", dato);
 
    {
        dato += 4; // Este dato es el del bloque externo
        printf("Dato del segundo bloque: %d\n", dato);
    }
 
    printf("Dato del bloque externo: %d\n", dato);
}

Bueno, seguramente está empezando y coincidirás conmigo que esa es la forma de hacer de la mayoría de los tutoriales de internet.

Te he modificado el programa para que funcione y te he escrito en los comentarios el por qué de cada cambio.

#include <stdio.h>
#include <stdlib.h>
 
//
// Acuérdate de realizar uan función que libere todos los nodos que hayas creado.
//
 
// rNodo no existe, al menos en este código que nos has pasado
typedef struct rLista {
	int dato;
	struct rLista * sig;
} * tLista;
 
// tLista ya es un puntero. Esta función sólo genera un dato en en heap y lo devuelve,
// por tanto no hay que regresar un puntero a puntero.
tLista crear_nodo (int nuevo_dato) {
	tLista nuevo_elemento = malloc (sizeof(struct rLista));
	nuevo_elemento->dato = nuevo_dato;
	nuevo_elemento->sig = NULL;
	return nuevo_elemento;
}
 
// nuevo_elemento debe ser un puntero a la dirección del heap con el contenido
// relleno de la estructura y por tanto no un puntero a puntero,
tLista agregar_final (tLista * ppio, tLista nuevo_elemento) {
    // ppio es un puntero a puntero y eso es para que puedas modificar el puntero que
    // está en otra función. ppio debe ser dereferenciado
	if (!*ppio) *ppio = nuevo_elemento;
	// El parámetro que se debe pasar a agregar_final es el puntero al campo sig del dato apuntado por ppio
	// por eso debe pasarse la referencia & a sig del puntero -> al que hace referencia * ppio
	else (*ppio)->sig = agregar_final(&((*ppio)->sig), nuevo_elemento);
 
	return *ppio;
}
 
//tLista ya es un puntero y solo hay que recorrerlo, no hay que pasarle un puntero a puntero
int contar_elementos (tLista ppio) {
	if (!ppio) return 0;
	// Usar una variable contandor haría que se reiniciara cada vez, por tanto lo que hay que hacer
	// es añadir 1 a la siguiente llamada a la faunción. Así es como funciona la recursión:
	// Cuando ppio sea NULL devolverá 0 y no hará más llamadas, la función anterior devolverá 1 + 0,
	// la anterior devolverá 1 + 1 + 0... y así se recorrerá la lista de llamadas hasta la función inicial
	// que devolverá la suma de todas las llamadas al llamante
	else return 1+contar_elementos(ppio->sig);
}
 
int main (void) {
	tLista ppio = NULL;
 
	agregar_final(&ppio,crear_nodo(5));
	agregar_final(&ppio,crear_nodo(6));
 
        // Muestra el uso de contar_elementos
	printf("Elementos en la lista: %d", contar_elementos(ppio));
}

n es el número al que se buscan los primos.

y 2 es el primer primo. Así

Por lo que cualquier número por encima de

salvo n, no dará un número entero y por tanto no es divisible.