questo è il codice del programma esecutivo.
le funzioni e le strutture sono definite in due file a parte.
l'errore "access violation" me lo da in corrispondenza della printf segnata con l'asterisco (fase di lettura e inizializzazione).


codice:
#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include <string.h>
#include <time.h>
#include <direct.h>

#include "generator.h"

int main(int argc, char *argv[])
{
	//inizializzazione puntatori
	GENDIMDATA_PTR gendimdata_ptr = malloc(sizeof(GENDIMDATA));
	LISTCOORD_PTR listcoord_ptr = malloc(sizeof(LISTCOORD));
	NICONST_PTR consts_ptr = malloc(sizeof(NICONST));
	NISIZE_PTR size_ptr = malloc(sizeof(NISIZE));
	NIDATA_PTR data_ptr = malloc(sizeof(NIDATA));
	
	//I FASE: inizializzazioni e lettura

	streama = malloc(sizeof(FILE));
	if (argc == 2)
	{
	  strcpy(parameters_file, argv[1]);
	}
 	
	//lettura di genparameter.data
    gendimdata_ptr = read_genparameter(streama);

	//creazione della struttura netinfo_const
	consts_ptr = netinfoconst_create(gendimdata_ptr);
	
    //assegnazione da input di NNODES;
	printf("\nInsert the number of the nodes (NNODES):");
	scanf("%d", &NNODES);
	printf("\n");

	//assegnazione da input del nome della directory di output
	printf("\nInsert the name of the Output directory: ");
	scanf("%s", &output);
*	printf("\n");
	output_dirname = &output;

    //II FASE: generazioni
	
	//inizializzazione della srand
	srand((unsigned)time(NULL));

    //generazione di size.data (NNODES, COUPLE_NUM, POWERLEVELS_NUM, CAPACITYLEVELS_NUM)
    size_ptr = netinfosize_generation(NNODES, gendimdata_ptr);

	//funzione che alloca e genera netdata
    data_ptr = generate_netdata(consts_ptr, size_ptr, gendimdata_ptr, listcoord_ptr); 

    //allocazione per la struttura netinfo.data (dopo aver generato size.data)
	//data_ptr = allocate_netdata(size_ptr);

    //generazione di nodes.data (ncoord_mtx, powercost_array, normconst_mtx, sigma_array)
    //data_ptr = nodes_generation(NNODES, data_ptr, consts_ptr, gendimdata_ptr);  
  
    //generazione routing.data
    //data_ptr = routing_array_generation(NNODES, data_ptr, size_ptr, gendimdata_ptr);

    //generazione di cappowlevels.data
   	//data_ptr = powerlevel_array_generation(data_ptr, size_ptr, gendimdata_ptr);
	//data_ptr = capacitylevel_array_generation(data_ptr, size_ptr, gendimdata_ptr);
       
	//creazione directory di output
	_mkdir(output_dirname);

	free(gendimdata_ptr);
	free(listcoord_ptr);
	    
  
    //III FASE: scrittura

	sprintf(constants_filename, CONSTANTS_FORMATSTR, output_dirname);

    //scrittura del file constants.data
	write_constants_data(constants_filename, consts_ptr);

	sprintf(sizes_filename, SIZES_FORMATSTR, output_dirname);

    //scrittura del file size.data
	write_sizes_data(sizes_filename, size_ptr);

	sprintf(nodes_filename, NODES_FORMATSTR, output_dirname);

    //scrittura del file nodes.data
	write_nodes_data(nodes_filename, NNODES, data_ptr);

	sprintf(routing_filename, ROUTING_FORMATSTR, output_dirname);

    //scrittura del file routing.data
    write_routing_data(routing_filename, data_ptr, size_ptr);

	sprintf(cappowlevels_filename, CAPPOWLEVELS_FORMATSTR, output_dirname);

    //scrittura del file cappowlevels.data
	write_cappowlevels_data (cappowlevels_filename, data_ptr, size_ptr);

	free(consts_ptr);
	free(size_ptr);
	free(data_ptr);

	return 0;
}