אתה מדבר על:

includes_extractor(c1_fp, c1_file_name ,c1_file_string_len); /*extract all headers*/	
return 0; /*dummy*/

אלו ?

שורה אחת למעלה. רמז: מה free עושה?

חוץ מזה, אתה לא צריך כל פעם לפנות לפורום לבקש עזרה. תנסה להבין בעצמך מה הבעיות. הקוד לא עובד? תשתמש בדיבאגר או בהדפסות עזר כדי להבין מה קורה בדיוק.

התכוונת שצריך לשנות את זה ל: (העתקתי רק את החלק התחתון קצת)

} /*while*/
	fclose(c_fp);
	fclose(c1_fp);

	includes_extractor(c1_fp, c1_file_name ,c1_file_string_len); 
	free(c1_file_name);/*extract all headers*/	
return 0; /*dummy*/



} /*main()*/

אי אפשר הרי לשחרר זיכרון שאתה עוד רץ איתו... נכון ?

עכשיו לפחות הוא יוצר את *.c2 אבל נותן לי segmentation fault משום מה... וב- *.c2 לא ממלא דבר...

כן, זה מה שהתכוונתי.

בכל מקרה:

אתה לא צריך כל פעם לפנות לפורום לבקש עזרה. תנסה להבין בעצמך מה הבעיות. הקוד לא עובד? תשתמש בדיבאגר או בהדפסות עזר כדי להבין מה קורה בדיוק.

אוקיי, אני אנסה למצוא את הבעיה.. רק תוכל לתת לי רמז שיכוון אותי לפני שאני ניגש למשימה?, כי ישבתי על הפונקציה 3 שעות כדי שלא יהיו בה טעויות...

תודה !

יש טעויות שלא תוכל למצוא כל עוד לא תריץ את הקוד בעצמך, שלב אחר שלב.

ניסיתי להירגע מהתרגיל ולחשוב עליו ברגוע.

הגעתי למצב שהקומפיילר אומר לי: ‘header_file_len’ is used uninitialized in this function

העניין הוא שאין לי מושג למה אני אמור לאתחל את header_file_len כי הרי אני מקבל אותו רק לאחר הלולאה שבה אני מכניס למעשה את שם הקובץ, כלומר

header_name ואכן כתבתי אחרי הלולאה:

 header_file_len=strlen(header_name)+1;

ככה שבאמת אין לי מושג מה הוא רוצה....

עשיתי מה שאמרת לי וזה לעבור שלב שלב ולהדפיס, על פניו היצירה של שם קובץ ה-header וכל ההדפסות תקינות, זאת רק בעית הגדרת זיכרון מעצבנת...

יש לך אפשרות לתקן אותי רק בהקצאה הדינמית? זה למעשה הדבר היחיד שתוקע אותי עם התרגיל הזה, כי אני ממש יושב הרבה מדי על התרגיל הזה שלא היה אמור להסתבך לי כ"כ... :'(

תודה.

void includes_extractor(FILE *c1_fp, char *c1_file_name ,int c1_file_str_len )
{
	int i;
	FILE *c2_fp , *header_fp;
	char ch, *c2_file_name, *header_name;
	char inc_name[]="include"; 
	char inc_chk[INCLUDE_LEN+1]; /*INCLUDE_LEN is defined | +1 for null*/
	int header_file_len;

	header_name=(char *) malloc (header_file_len*sizeof(char)); 

	/* making the c2 file name */

	c2_file_name=(char *) malloc ((c1_file_str_len)*sizeof(char)); 
	strcpy(c2_file_name , c1_file_name); 
	c2_file_name[c1_file_str_len-1] = '\0'; 
	c2_file_name[c1_file_str_len-2] = '2';

/*Open source & destination files + ERR check */

	if( !(c1_fp = fopen (c1_file_name,"r") ) )
	{
	 fprintf(stderr,"\ncannot open *.c1 file !\n");
	 exit(0);
	}

	if( !(c2_fp = fopen (c2_file_name,"w+") ) )
	{
	 fprintf(stderr,"\ncannot open *.c2 file !\n");
	 exit(0);
	}

/*next code lines are copy char by char from c1 to c2,
 but if meet header file, copy its content */

	ch=fgetc(c1_fp);
	while (!feof(c1_fp))
	{
		i=0;	/*zero i */	
		if (ch == '#') /*potential #include case*/
		{
	     fgets(inc_chk, INCLUDE_LEN+1, c1_fp); /*8 places for "include" + null*/
		 if(strcmp(inc_chk,inc_name)==0) /*case #include*/
		 {
		 ch=fgetc(c1_fp);
		 while(ch==' ') /* stop when head with a '<' or '"' */
		 {
		  ch=fgetc(c1_fp);
		 } /*while(2)*/

		 ch=fgetc(c1_fp); /*start read header file name*/

		 while((ch!='"') || (ch!='>')) /*until we get the end of header name*/
		 {
		  header_name[i] = ch;
		  i++;
		  ch=fgetc(c1_fp);
		 }/*while(3)*/
		 header_name[i]='\0'; /*close the header_name array*/
		 header_file_len=strlen(header_name)+1;

		 if( !(header_fp = fopen (header_name,"r") ) ) /*open *.h for read + ERR chk*/
		 {
	      fprintf(stderr,"cannot open header file !\n");
	 	  exit(0);
	     }
		 while (!feof(header_fp)) /*copy header file content to *.c2 file*/
		 {
		  ch=fgetc(header_fp);
		  fputc(ch,c2_fp);
		 }/*while(4)*/
		 fclose(header_fp);
		 }
        }/*frst if*/
		else
		{
		 fputc(ch,c2_fp);
		}
	 ch=fgetc(c1_fp); 
	}/*while(1)*/
fclose(c1_fp);
fclose(c2_fp);
free (header_name);
free (c2_file_name);
}

תן לי להבין, אתה מגדיר משתנה בשם header_name_len ולא מאתחל אותו, יוצר מערך שגודלו header_name_len, ואז בסוף הפונקציה אתה שם ערך ב-header_name_len? איך בדיוק ציפית שזה יעבוד...?

סך הכל יש שתי דרכים לקרוא מחרוזת באורך שאינו ידוע מראש. או להניח שאורך המחרוזת בטוח קטן ממספר מסויים ואז לעבוד עם מערך סטטי, או להגדיל את המערך באופן דינמי באמצעות realloc מתי שצריך.

עריכה: השתמשתי במערך סטטי, כי יצאתי מנק' הנחה (שהרשו לנו) שאורך שורה הינו 80 תווים. שיניתי עוד כמה דברים מינוריים וזה סבבה.

פעם הבאה, אני בונה את התוכניות שלי באופן מודולרי עם פונק' קטנות הרבה יותר, והרבה יותר פונק' מחולקות ל'קבצים, זה מה שבטוח ;D