Pascal/Turbo Pascal - Tamaño, Arrays y registros URGENTE

Hola tengo una practica que hacer y no se ni como empezar porque PASCAL me "destruye" las pocas ideas que tengo con el mismo error (22: Structure too large), la practica consiste en lo siguiente:

Una Academia de Informática ha convocado diez cursos de formación : ASP.NET, JSP,
Access, Oracle, Word, Pascal, C, Visual Basic, Delphi y AJAX. De cada curso establece
diariamente tres turnos de clases de 1 hora, 10,00, 12,00 y 20,00 h. En cada grupo de clase hay
capacidad para 5 alumnos. De cada alumno se desea conocer su nombre, apellidos y edad. El precio
de inscripción será de 60 euros por matricula en cada curso.

Desarrollar un programa con el menú siguiente :
1.- Añadir un alumno a un curso.
2.- Listar los alumnos de un grupo de clase de un curso.
3.- Listar los alumnos de un curso completo.
4.- Contabilidad.
0.- Salir

El menú se repetirá hasta que se pulse la opción 0. Al seleccionar la opción 1, se introducen todos
los datos de un alumno, solicitando al usuario nombre del alumno, curso y grupo de clase en el que
desea matricularse; si hay hueco en el grupo de clase se matricula al alumno y pregunta si desea
matricularse en otro curso diferente; si la contestación es afirmativa desarrolla los mismos pasos
anteriores, mientras que si es negativa presenta por pantalla el importe de la matriculación. La
opción 2, solicita al usuario el curso y el grupo de clase y graba en el fichero de salida estándar los
nombres de los alumnos matriculados en dicho curso. La opción 3, solicita al usuario el curso a
listar, grabando en el fichero de salida estándar los nombres de todos los alumnos matriculados en
dicho curso. La opción 4, muestra por pantalla el importe total cobrado por cada uno de los grupos
de clase, por cada uno de los cursos y el total facturado por la Academia.

-Lo que yo empece fue esto:

Program Academia
type
Treg_alumno=record
nombre:string;
apellido:string;
edad:integer;
end;
Treg_curso=record
GrupoA: array[1..5] of alumno;
GrupoB: array[1..5] of alumno;
GrupoC: array[1..5] of alumno;
end;
TCursos_vector: Array [1..10] of Treg_cursos;

(************************************************************)

Pero como me da eel error que comente hice esto y TAMBIEN ME DA ERROR !! que hago!! snif...

program academia_de_estudios;
uses crt;
type
Treg_alumno=record
nombre:string;
apellido:string;
edad:integer;
end;
Ttabla=array[1..15,1..10] of Treg_alumno; (*GrupoA de fila 1 hasta 5; GrupoB de la 2 a la 10,...*)

Veamos. El registro Treg_alumno mide 514 bytes (256+256+2), tienes declarados 3 arrays de 5 posiciones cada uno, entonces son 514*5*5, son 12850 bytes y luego otro array de 10 posiciones cada uno con los tres arrays anteriores, son 128500 bytes, o sea 120 Kb, los cuales superan casi el doble de los 64 Kb permitidos en el stack en Turbo Pascal. Ahí está tu problema :).

La solución que trataste de usar también supera los 64 Kb. Me temo que vas a tener que achicar los arrays o la definición del registro. No tiene sentido usar todo un string para almacenar un nombre y un apellido, con que los declares de, digamos, 20 caracteres es suficiente.

Si tampoco te da, me temo que tendrás que implementar archivos o... buscar otro compilador como Free Pascal, que no tiene límite en el stack.

Habia pensado definir 10 tipo registros (cursos) cada uno con los registros ya puestos, es mas incordioso pero parece que funciona nose si esto tendra algun inconveniente grave para realizar completa la practica, imagino que no...

En Freepascal es cierto que funciona pero no me dejan utilizarlo...de todas maneras acabo de probar eso de achicar los strings que se me habian pasado y FUNCIONA!!
Menos mal. Mil gracias! :)

Me alegro haberte sido de ayuda.

Me asalta la curiosidad ¿por qué no te dejan usar Free Pascal?.

Pues si te digo la verdad no es que haya una hostilidad al software libre xD, en realidad nose si me dajasen porque no he hablado con el profesor dado que tengo todas las practicas para septiembre (esta es la penultima) y no asisti mucho a su clase... ,me da miedo entregarsela en freepascal porque alomejor me manda a tomar por... (Me han dicho q es estricto, y si no tiene el programa donde abrirlo se mosqueara fijo xD)

Por cierto siento ser pesao pero tengo otra duda tonta, segun lo que me dice el enunciado...

"La opción 3, solicita al usuario el curso a listar, grabando en el fichero de salida estándar los nombres de todos los alumnos matriculados en dicho curso. "

...cuando dice "grabando en el fichero de salida estándar" ,me dice un amigo que es mostrar por pantalla directamente... sin guardarlos en ficheros y eso, osea, sin usar el tipo fichero de dato... entonces me lio porque ademas para cuando tuvimos que hacer esa practica no habiamos dado todavia ficheros... y encima no tengo a quien preguntarle porque estan todos en la playa... :(

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/wait.h>
#include <signal.h>
#define MYPORT 3490 /* Puerto de escucha */
#define BACKLOG 10 /* Cantidad de conexiones máximas permit.*/
#define MAX 1024 /*tamaño máximo del buff de lectura de archivo*/

int enviototal(int s, char buffer[],int *len);

int main(void)
{
int sockfd, new_fd;
/* Escuchar sobre sock_fd, nuevas conexiones sobre new_fd*/
struct sockaddr_in dir_local; /*información sobre mi dirección*/
struct sockaddr_in dir_entrante;
/* información sobre la dirección del cliente*/
int yes=1,bytesrec,sin_size;
FILE* archivo;
char nomarch[40],carpeta[40],dir[100],httpmsj[100],
http200[ ]="HTTP 200:FILE FOUND",
http404[ ]="HTTP404:FILE NOT FOUND";
char *parse,*p;
int len,bytesleidos;
char buffer[512];


/*se crea el socket*/

if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1)
{
perror("socket");
exit (1);
}


if (setsockopt(sockfd,SOL_SOCKET,SO_REUSEADDR,&yes,
sizeof(int)) == -1)
{
perror("setsockopt");
exit (1);
}


dir_local.sin_family = AF_INET;
// Ordenación de bytes de la máquina
dir_local.sin_port = htons(MYPORT);
// short, Ordenación de bytes de la red
dir_local.sin_addr.s_addr = htonl(INADDR_ANY);
// Rellenar con mi dirección IP
memset(&(dir_local.sin_zero), '', 8);
// Poner a cero el resto de la estructura


if (bind(sockfd, (struct sockaddr *)&dir_local,
sizeof (struct sockaddr))== -1)
{
perror("bind");
exit(1);
}



if (listen(sockfd, BACKLOG) == -1)
{
perror("listen");
exit(1);
}


while(1){

sin_size =sizeof(struct sockaddr_in);

if ((new_fd = accept(sockfd,
(struct sockaddr *) &dir_entrante,&sin_size)) == -1)
{
perror("accept");
continue;
}


}

/*recibe nombre del archivo y se extrae del mensaje GET
el nombre para intentar la apertura*/


if ((recv(new_fd, httpmsj, sizeof(httpmsj), 0)) == -1)
/*recibe mensaje get*/

{
perror("recv");
exit(1);
}



if(((p=strstr(httpmsj,"HTTP/1.0"))!=NULL)||
((p=strstr(httpmsj,"HTTP/1.1"))!=NULL))

{

parse=strtok(httpmsj," ");

parse=strtok(NULL," ");


strcpy(nomarch,parse);


}





/*se arma la ruta de acceso*/


strcpy(carpeta,"/etc/");

sprintf(dir,("%s%s"),carpeta,nomarch);


/*apertura de archivo*/


archivo=fopen(dir,"rt");

/*se procede a mandar los mensajes http correspondientes e iniciar la transferencia*/



if(archivo)
{


len=strlen(http200);
if(enviototal(new_fd,http200,&len)==-1)
/*se asegura de que llegue la totalidad del mensaje HTTP 200*/
{ perror("enviototal");
printf("Se enviaron %d bytes a causa del error ",len);
}



while((bytesleidos=fread(buffer,sizeof(buffer),1,archivo))!=0)

{ len=strlen(buffer);
if(enviototal(new_fd,buffer,
&len)==-1)
/* asegura que llegue la totalidad del buffer*/
{ perror("enviototal");

printf("Se enviaron %d bytes a causa del error ",len);
}


}/*fin while*/






} /*fin then*/


else

{

len=strlen(http404);
if(enviototal(new_fd,http404,&len)==-1)
/*asegura que llegue la totalidad del mensaje HTTP 404*/
{ perror("enviototal");

printf("Se enviaron %d bytes a causa del error ",len);
}



} /*fin else*/




close(new_fd);/*se cierra la conexión*/


close(sockfd);/*no es necesario*/



return 0;

}/*fin main*/

int enviototal(int s, char buffer[],int *len)
{
int total=0; /*cuantos bytes se enviaron*/
int restantes=*len; /*cuantos bytes quedan en el buffer*/
int n;
while (total<*len) {
n=send(s,buffer+total,restantes,0);
if(n==-1) {break;}
total+=n;
restantes-=n;
} /*fin while*/

*len=total; /*devuelve la cantidad enviada*/
return (n=-1?-1:0); /*devuelve -1 si falla, 0 en cualquier otro caso*/
}