Annotation of capa/capa51/pProj/capaCommon.c, revision 1.20
1.12 albertel 1: /* Library of useful functions
2: Copyright (C) 1992-2000 Michigan State University
3:
4: The CAPA system is free software; you can redistribute it and/or
1.14 albertel 5: modify it under the terms of the GNU General Public License as
1.12 albertel 6: published by the Free Software Foundation; either version 2 of the
7: License, or (at your option) any later version.
8:
9: The CAPA system is distributed in the hope that it will be useful,
10: but WITHOUT ANY WARRANTY; without even the implied warranty of
11: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
1.14 albertel 12: General Public License for more details.
1.12 albertel 13:
1.14 albertel 14: You should have received a copy of the GNU General Public
1.12 albertel 15: License along with the CAPA system; see the file COPYING. If not,
16: write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
1.13 albertel 17: Boston, MA 02111-1307, USA.
18:
19: As a special exception, you have permission to link this program
20: with the TtH/TtM library and distribute executables, as long as you
21: follow the requirements of the GNU GPL in regard to all of the
22: software in the executable aside from TtH/TtM.
23: */
1.12 albertel 24:
1.1 albertel 25: /* =||>|===================== capaCommon.c =====================|<||= */
26: /* created 1994 by Isaac Tsai */
27: /* TODO: restructure capa_check_ans*() calls into one */
28: /* =||>|===================== capaCommon.c =====================|<||= */
29: #include <ctype.h>
30: #if defined(__sun) || defined(linux) || defined(__alpha) || defined(hpux) || defined(AIX) || defined(IRIX)
31: #include <unistd.h> /* lockf() */
32: #endif
33: #include <sys/types.h>
34: #include <sys/stat.h>
35: #include <fcntl.h>
36: #include "capaParser.h"
37: #include "capaToken.h"
38: #include "capaCommon.h"
39: #include "ranlib.h"
40:
41:
42: /*----------------------------------------------------------*/
43: /* flock() in SUN is in BSD compatibility lib */
44: /* #include <sys/file.h> */
45: /*----------------------------------------------------------*/
46:
47: int yyparse();
48: extern FILE *yyin;
49: extern void yyrestart();
50:
1.16 albertel 51: extern FILE *dfp;
52:
1.1 albertel 53: /*----------------------------------------------------------*/
54: /* RETURN: -1 file error */
55: /* 0 success */
56: /* INPUT: if section == 0, for all students in class */
57: /* set : 1, 2, 3, ... */
58: /* prob: 1, 2, 3, ... */
59: /*----------------------------------------------------------*/
60: int
61: capa_excuse(int set,int prob,int section)
62: {
63: int nq;
64: T_header header;
65: T_entry entry;
66: T_student *student_p, *s1_p;
67: char tmp_number[MAX_STUDENT_NUMBER+1];
68: long offset;
69: int num_students;
70:
71: /* Calculate parameters */
72: if (capa_get_header(&header,set)) return (-1);
73: sscanf(header.num_questions,"%d", &nq);
74:
75: if( ( prob > nq ) || (section < 0 ) || (section > MAX_SECTION_COUNT) ) return (-1);
76: num_students= 0;
77: if ( (num_students = capa_get_section(&student_p, section))== -1 ) return (-1);
78: for ( s1_p = student_p ; s1_p ; s1_p = (s1_p->s_next)) {
79: sprintf(tmp_number,"%s",s1_p->s_sn);
80: offset = capa_get_entry(&entry,tmp_number,set);
81: if(offset < 0 ) offset = -offset;
82: switch(entry.answers[prob-1]) {
1.2 albertel 83: case '0':
1.1 albertel 84: case '-': entry.answers[prob-1] = 'E'; break;
85: case 'N': entry.answers[prob-1] = 'E'; break;
86: case 'n': entry.answers[prob-1] = 'e'; break;
1.2 albertel 87: case '1': case '2': case '3': case '4': case '5':
88: case '6': case '7': case '8': case '9':
89: if (entry.answers[prob-1] < header.weight[prob-1]) {
90: entry.answers[prob-1] = 'E';
91: }
92: break;
1.1 albertel 93: default : break;
94: }
95: capa_set_entry(&entry,tmp_number,set,offset);
96: capa_mfree(entry.answers); entry.answers = NULL;
97: capa_mfree(entry.tries); entry.tries = NULL;
98: }
1.2 albertel 99: capa_mfree(header.weight);
100: capa_mfree(header.partial_credit);
1.1 albertel 101: free_students(student_p);
102: return (0);
103: }
104:
105: /*----------------------------------------------------------*/
106: /* Lock file shared */
107: /* lock the file specified by file stream pointer sp */
108: /*----------------------------------------------------------*/
109: int
110: flockstream_sh(sp) FILE *sp;
111: {
112: int fd;
113:
114: fd = fileno(sp);
115:
116: #if defined(__sun) || defined(hpux) || defined(AIX)
117: return ( lockf(fd,F_LOCK, 0L) );
118: #else
119: return (flock(fd,LOCK_SH));
120: #endif
121: }
122: /*----------------------------------------------------------*/
123: int
124: flockstream(sp) FILE *sp;
125: {
126: int fd;
127:
128: fd = fileno(sp);
129:
130: #if defined(__sun) || defined(hpux) || defined(AIX)
131: return ( lockf(fd,F_LOCK, 0L) );
132: #else
133: return (flock(fd,LOCK_EX));
134: #endif
135: }
136: /*----------------------------------------------------------*/
137: int
138: funlockstream(sp) FILE *sp;
139: {
140: int fd;
141:
142: fd = fileno(sp);
143:
144: #if defined(__sun) || defined(hpux) || defined(AIX)
145: return ( lockf(fd,F_ULOCK, 0L) );
146: #else
147: return ( flock(fd,LOCK_UN) );
148: #endif
149: }
150:
151: int
152: inquery_a_lock(sp,cmd,type,offset,whence,len)
153: FILE *sp;int cmd;off_t offset;int whence;off_t len;
154: {
155: struct flock lock;
156: int fd;
157: lock.l_type = type; lock.l_start = offset;
158: lock.l_whence = whence; lock.l_len = len;
159: fd=fileno(sp);
160: return (fcntl(fd,cmd,&lock));
161: }
162: #define Blocked_Write_Lock(sp) \
163: inquery_a_lock(sp,F_SETLK,F_WRLCK,0,0,0)
164:
165: #define Blocked_Write_Lock(sp) \
166: inquery_a_lock(sp,F_SETLK,F_WRLCK,0,0,0)
167:
168: #define Un_Lock(sp) \
169: inquery_a_lock(sp,F_SETLK,F_UNLCK,0,0,0)
170:
171:
172: /*----------------------------------------------------------*/
173: /* INPUT: set problem set number */
174: /* RETURN: -1 no records/setX.db file or file error */
175: /* 0 success */
176: /* OUTPUT: header pointer to T_header structure */
177: /*----------------------------------------------------------*/
178: int
179: capa_set_header(header, set) T_header *header;int set;
180: {
181: FILE *fp;
182: char *big_buf=NULL, filename[FILE_NAME_LENGTH], cr=0, oneline[TMP_LINE_LENGTH];
183: int nq, len, errcode, fd, item_cnt, exists=1;
184: T_header oldheader;
185: long orig_size, new_size, big_buf_size;
186:
187: sprintf(filename,"records/set%d.db",set);
188: if ((fp=fopen(filename,"r+"))==NULL) {
189: exists=0;
190: if ((fp=fopen(filename,"w"))==NULL) { /* create if non-existant */
191: /*printf("Error: can't open %s\n",filename);*/ return (-1);
192: }
193: }
194: sscanf(header->num_questions,"%d",&nq);
195: /* sprintf(oneline,"%d,%s,%s,%s\n",nq,header->open_date,header->due_date,header->answer_date); */
196: sprintf(oneline,"%d\n",nq);
197: len = strlen(oneline);
198: flockstream(fp); errcode = 0;
199:
200: if (exists) {
201: /*get file size*/
202: fseek(fp,0L,SEEK_END);
203: orig_size = ftell(fp);
204: big_buf_size = orig_size; /*the amt we need to read is less then the file's size*/
205: big_buf = capa_malloc(big_buf_size,1);
206: fseek(fp,0L,SEEK_SET);
207:
208: /*read in old header*/
209: fscanf(fp,"%d",&nq);
210: while ( cr != '\n' && cr != EOF ) { cr=fgetc(fp); }
211: oldheader.weight=capa_malloc(nq+1,1);
212: oldheader.partial_credit=capa_malloc(nq+1,1);
213: if (!fread(oldheader.weight, sizeof(char), nq, fp)) errcode = -2;
214: if (EOF==(cr=fgetc(fp))) errcode = -3;
215: if (!fread(oldheader.partial_credit, sizeof(char), nq, fp)) errcode = -4;
216: if (EOF==(cr=fgetc(fp))) errcode = -5;
217: capa_mfree(oldheader.weight);
218: capa_mfree(oldheader.partial_credit);
219:
220: /*read rest of file*/
221: item_cnt=fread(big_buf,1,big_buf_size, fp);
222: }
223:
224: /*write new header*/
225: fseek(fp,0L,SEEK_SET);
226: if (!fwrite(oneline, len, 1, fp)) {errcode = -6;}
227: if ( header->weight != NULL ) {
228: if (!fwrite((char *)(header->weight), strlen(header->weight), 1, fp)) errcode=-7;
229: }
230:
231: if (EOF==(!fputc('\n', fp))) errcode = -8;
232: if (header->partial_credit != NULL) {
233: if (!fwrite((char *)(header->partial_credit), strlen(header->partial_credit),
234: 1, fp)) { errcode = -9; }
235: }
236: if (EOF==(!fputc('\n', fp))) errcode = -10;
237:
238: if (exists) {
239: /*write out rest of file*/
240: if (item_cnt >= 0 ) {
241: big_buf[item_cnt]=0;
242: if (!fwrite(big_buf,item_cnt,1,fp) ) errcode= -11;
243: new_size = ftell(fp);
244: if (new_size < orig_size ) {
245: fd = fileno(fp);
246: ftruncate(fd,new_size);
247: }
248: }
249: }
250:
251: fflush(fp);
252: funlockstream(fp); fclose(fp);
253: if (big_buf!=NULL) capa_mfree(big_buf);
254: return (errcode);
255: }
256:
257: /*----------------------------------------------------------*/
258: /* INPUT: set problem set number */
259: /* RETURN: -1 file error */
260: /* 0 success */
261: /* OUTPUT: header pointer to T_header structure */
262: /* Note: allocates space for the partial_credit and weight */
263: /* fields of the passed in header, caller needs to */
264: /* eventually free them with capa_mfree */
265: /*----------------------------------------------------------*/
266: int
267: capa_get_header(header, set) T_header *header;int set;
268: {
269: FILE *fp;
270: char filename[FILE_NAME_LENGTH];
271: char cr;
272: int nq=0, errcode;
273:
274: sprintf(filename,"records/set%d.db",set);
275: if ((fp=fopen(filename,"r"))==NULL) {
276: /*printf("Error capa_get_header(): can't open %s\n",filename);*/
277: return (-1);
278: }
279:
280: flockstream(fp); errcode = 0;
281: fscanf(fp,"%d",&nq);
282: cr='\0';
283: while ( cr != '\n' && cr != EOF ) { cr=fgetc(fp); }
284: header->weight=capa_malloc(nq+1,1);
285: header->partial_credit=capa_malloc(nq+1,1);
286: if (nq > 0 ) {
287: if (!fread(header->weight, sizeof(char), nq, fp)) errcode = -1;
288: }
289: if (EOF==(cr=fgetc(fp))) errcode = -1;
290: if (nq > 0 ) {
291: if (!fread(header->partial_credit, sizeof(char), nq, fp)) errcode = -1;
292: }
293:
294: funlockstream(fp); fclose(fp);
295: header->weight[nq]='\0'; header->partial_credit[nq]='\0';
296: sprintf(header->num_questions,"%d",nq);
297: return (errcode);
298: }
299: /*----------------------------------------------------------*/
300: /* ----------- previous version, obsolete as of May 1997
301: int
302: capa_set_entry(entry, student_number, set, offset)
303: T_entry *entry;
304: char *student_number;
305: int set;
306: long offset;
307: {
308: FILE *fp;
309: int errcode=0;
310: int len;
311: char filename[FILE_NAME_LENGTH];
312: char a_line[TMP_LINE_LENGTH];
313:
314: sprintf(filename,"records/set%d.db",set);
315: if ((fp=fopen(filename,"r+"))==NULL) {
316: return (-1);
317: }
318: sprintf(a_line,"%s %s,%s\n",entry->student_number,entry->answers,entry->tries);
319: len = strlen(a_line);
320: flockstream(fp);
321: fseek(fp,offset,0);
322: if (!fwrite(a_line,len,1,fp) ) {
323: printf("Error writing data to file\n");
324: errcode= (-1);
325: }
326: fflush(fp);
327: funlockstream(fp);
328: fclose(fp);
329: return (errcode);
330: }
331: ---------- */
332:
333: int
334: capa_set_entry(entry, student_number, set, offset)
335: T_entry *entry;
336: char *student_number;
337: int set;
338: long offset;
339: {
340: FILE *fp;
341: int fd;
342: int errcode=0;
343: int done, len, new_len, item_cnt;
344: long next_r, orig_size, new_size, big_buf_size;
345: char filename[FILE_NAME_LENGTH];
346: char *a_line, tmpline[TMP_LINE_LENGTH],
347: tmp_sn[MAX_STUDENT_NUMBER+1], fmtbuf[SMALL_LINE_BUFFER];
348: char *big_buf;
349:
350: sprintf(filename,"records/set%d.db",set);
351: if ((fp=fopen(filename,"r+"))==NULL) {
352: /* printf("Error capa_set_entry(): can't open %s\n",filename); */ return (-1);
353: }
354: /* entry->answers*3 == entry->tries, + fudge factor*/
355: a_line=capa_malloc(strlen(entry->tries)*5+MAX_STUDENT_NUMBER,1);
356: sprintf(a_line,"%s %s,%s\n",entry->student_number,entry->answers,entry->tries);
357: new_len = strlen(a_line);
358: sprintf(fmtbuf, "%%%dc",MAX_STUDENT_NUMBER);
359: flockstream(fp); /* <==== lock the setX.db file */
360: fseek(fp,0L,SEEK_END);
361: orig_size = ftell(fp);
362: big_buf_size = orig_size + new_len;
363: big_buf = capa_malloc(big_buf_size,1);
364: fseek(fp,0L,SEEK_SET); /* rewind to beginning of file */
365: fgets(tmpline,TMP_LINE_LENGTH-1,fp); /* skip weight line, including \n */
366: fgets(tmpline,TMP_LINE_LENGTH-1,fp); /* hand grading */
367: done = 0;
368: while(!done) {
369: done = !fgets(tmpline,TMP_LINE_LENGTH-1,fp); len = strlen(tmpline);
370: if( !done ) {
371: sscanf(tmpline,fmtbuf,tmp_sn);
372: if( !strncasecmp(tmp_sn,student_number,MAX_STUDENT_NUMBER) ) { /* Found */
373: next_r = ftell(fp); offset = next_r - len; done = 1;
374: item_cnt=fread(big_buf,1,big_buf_size, fp); /* read remaining lines into buffer */
375: if(item_cnt >= 0 ) { /* no error reading remaining lines */
376: big_buf[item_cnt]=0; /* terminate the buffer, for sure */
377: fseek(fp,offset,SEEK_SET); /* reposition file pointer to the record */
378: if (!fwrite(a_line,new_len,1,fp) ) { /* write out the records */
379: /* printf("Error writing data to file\n"); */
380: errcode= (-1);
381: }
382: if (item_cnt != 0) {
383: if (!fwrite(big_buf,item_cnt,1,fp) ){/*write out the remainings*/
384: /* printf("Error writing data to file\n"); */
385: errcode= (-1);
386: }
387: }
388: new_size = ftell(fp);
389: if(new_size < orig_size ) {
390: fd = fileno(fp);
391: ftruncate(fd,new_size);
392: }
393: }
394: }
395: } else { /* end of file */
396: fseek(fp,0L,SEEK_END);
397: offset = ftell(fp); /* last byte, if last byte is cr, back up one */
398: fseek(fp,-1L,SEEK_END);
399: while(fgetc(fp) == '\n' ) { offset--; fseek(fp,offset,SEEK_SET); }
400: offset = offset +2; /* last char and cr */
401: done=1;
402: fseek(fp,offset,SEEK_SET);
403: if (!fwrite(a_line,new_len,1,fp) ) { /* write out the records */
404: /* printf("Error writing data to file\n"); */
405: errcode= (-1);
406: }
407: }
408: }
409: fflush(fp);
410: funlockstream(fp); /* <======= unlock the file */
411: fclose(fp);
412: capa_mfree(big_buf); /* free up the buffer */
413: return (errcode);
414: }
415:
416: /* for all elements in entry->answers that aren't ? it changes the
417: file to have the new values (except if student has a Y and for all
418: entries in entry->tries that don't have the value -1 it changes the
419: file to have the new value */
420:
421: int
422: capa_change_entry(entry, student_number, set)
423: T_entry *entry;
424: char *student_number;
425: int set;
426: {
427: FILE *fp;
428: int fd;
429: int errcode=0,offset=0;
430: int done, len, new_len, item_cnt,i,j;
431: long next_r, orig_size, new_size, big_buf_size;
432: char filename[FILE_NAME_LENGTH];
433: char *a_line, tmpline[TMP_LINE_LENGTH],
434: tmp_sn[MAX_STUDENT_NUMBER+1], fmtbuf[SMALL_LINE_BUFFER];
435: char *big_buf;
436:
437: sprintf(filename,"records/set%d.db",set);
438: if ((fp=fopen(filename,"r+"))==NULL) {
439: /* printf("Error capa_set_entry(): can't open %s\n",filename); */ return (-1);
440: }
441: /* entry->answers*3 == entry->tries, + fudge factor*/
442: a_line=capa_malloc(strlen(entry->tries)*5+MAX_STUDENT_NUMBER,1);
443: sprintf(a_line,"%s %s,%s\n",entry->student_number,entry->answers,entry->tries);
444: new_len = strlen(a_line);
445: sprintf(fmtbuf, "%%%dc",MAX_STUDENT_NUMBER);
446: flockstream(fp); /* <==== lock the setX.db file */
447: fseek(fp,0L,SEEK_END);
448: orig_size = ftell(fp);
449: big_buf_size = orig_size + new_len;
450: big_buf = capa_malloc(big_buf_size,1);
451: fseek(fp,0L,SEEK_SET); /* rewind to beginning of file */
452: fgets(tmpline,TMP_LINE_LENGTH-1,fp); /* skip weight line, including \n */
453: fgets(tmpline,TMP_LINE_LENGTH-1,fp); /* hand grading */
454: done = 0;
455: while(!done) {
456: done = !fgets(tmpline,TMP_LINE_LENGTH-1,fp); len = strlen(tmpline);
457: if( !done ) {
458: sscanf(tmpline,fmtbuf,tmp_sn);
459: if( !strncasecmp(tmp_sn,student_number,MAX_STUDENT_NUMBER) ) { /* Found */
460: next_r = ftell(fp); offset = next_r - len; done = 1;
461: item_cnt=fread(big_buf,1,big_buf_size,fp); /*read remaining lines into buffer*/
462: if(item_cnt >= 0 ) { /* no error reading remaining lines */
463: big_buf[item_cnt]=0; /* terminate the buffer, for sure */
464: fseek(fp,offset,SEEK_SET); /* reposition file pointer to the record */
465: for(i=0;i<entry->e_probs;i++) {
466: /*if entry has been updated, and student doesn't have a Y yet*/
467: if ((entry->answers[i]!='?') &&
468: (tmpline[MAX_STUDENT_NUMBER+1+i]!='Y'))
469: tmpline[MAX_STUDENT_NUMBER+1+i]=entry->answers[i];
470: j = atoi(&(entry->tries[i*3]));
471: if ( j > -1 ) {
472: tmpline[MAX_STUDENT_NUMBER+1+entry->e_probs+1+i*3]=entry->tries[i*3];
473: tmpline[MAX_STUDENT_NUMBER+1+entry->e_probs+1+i*3+1]=entry->tries[i*3+1];
474: }
475: }
476: if (!fwrite(tmpline,new_len,1,fp) ) { errcode= (-1); }
477: if (item_cnt != 0) {
478: if (!fwrite(big_buf,item_cnt,1,fp) ){/*write out the remainings*/
479: /* printf("Error writing data to file\n"); */
480: errcode= (-1);
481: }
482: }
483: new_size = ftell(fp);
484: if(new_size < orig_size ) {
485: fd = fileno(fp);
486: ftruncate(fd,new_size);
487: }
488: }
489: }
490: } else { /* end of file */
491: fseek(fp,0L,SEEK_END);
492: offset = ftell(fp); /* last byte, if last byte is cr, back up one */
493: fseek(fp,-1L,SEEK_END);
494: while(fgetc(fp) == '\n' ) { offset--; fseek(fp,offset,SEEK_SET); }
495: offset = offset +2; /* last char and cr */
496: done=1;
497: fseek(fp,offset,SEEK_SET);
498: if (!fwrite(a_line,new_len,1,fp) ) { /* write out the records */
499: /* printf("Error writing data to file\n"); */
500: errcode= (-1);
501: }
502: }
503: }
504: fflush(fp);
505: funlockstream(fp); /* <======= unlock the file */
506: fclose(fp);
507: capa_mfree(big_buf); /* free up the buffer */
508: return (errcode);
509: }
510:
511: /* -------------------------------------------------- */
512: /* append a entry record to the very end of the file */
513: long
514: capa_append_entry(entry, student_number, set)
515: T_entry *entry;
516: char *student_number;
517: int set;
518: {
519: FILE *fp;
520: int len;
521: char filename[FILE_NAME_LENGTH];
522: char a_line[TMP_LINE_LENGTH];
523: long offset;
524:
525: sprintf(filename,"records/set%d.db",set);
526: if ((fp=fopen(filename,"r+"))==NULL) {
527: /* printf("Error capa_set_entry(): can't open %s\n",filename); */
528: return (-1);
529: }
530: sprintf(a_line,"%s %s,%s\n",entry->student_number,entry->answers,entry->tries);
531: len = strlen(a_line);
532:
533: flockstream(fp); /* <==== lock the setX.db file */
534: fseek(fp,0L,SEEK_END);
535: offset = ftell(fp);
536: fseek(fp,-1L,SEEK_END);
537: while(fgetc(fp) == '\n' ) { offset--; fseek(fp,offset,SEEK_SET); }
538: offset = offset +2;
539: fseek(fp,offset,SEEK_SET);
540: if (!fwrite(a_line,len,1,fp) ) {
541: /* printf("Error writing data to file\n"); */
542: return (-1);
543: }
544: fflush(fp);
545: funlockstream(fp);
546: fclose(fp);
547: return (offset);
548: }
549:
550: /*----------------------------------------------------------*/
551:
552: long /* RETURNS: byte offset to start of record, 0 if error,
553: -offset if not found & newly created */
554: capa_get_entry(entry, student_number, set)
555: T_entry *entry;
556: char *student_number;
557: int set;
558: {
559: char filename[FILE_NAME_LENGTH];
560: FILE *fp;
561: int len, nq;
562: char *ans_p, *tries_p, oneline[TMP_LINE_LENGTH],fmtbuf[SMALL_LINE_BUFFER];
563: long offset = 0, next_r;
564: int ii, done, found = 0;
565: char a_sn[MAX_STUDENT_NUMBER+1];
566:
567: sprintf(filename,"records/set%d.db",set);
568: if ((fp=fopen(filename,"r"))==NULL) {
569: /*printf("Error capa_get_entry(): can't open %s\n",filename);*/
570: return (0);
571: }
572: sprintf(entry->student_number,"%s",student_number);
573: sprintf(fmtbuf, "%%%dc",MAX_STUDENT_NUMBER);
574: flockstream(fp);
575: fgets(oneline,TMP_LINE_LENGTH-1,fp); len = strlen(oneline); sscanf(oneline,"%d",&nq);
576: fgets(oneline,TMP_LINE_LENGTH-1,fp); /* skip weight line, including \n */
577: fgets(oneline,TMP_LINE_LENGTH-1,fp); /* hand grading */
578: done = 0;
579: while(!done) {
580: done = !fgets(oneline,TMP_LINE_LENGTH-1,fp); len = strlen(oneline);
581: if( !done ) {
582: sscanf(oneline,fmtbuf,a_sn);
583: if( !strncasecmp(a_sn,student_number,MAX_STUDENT_NUMBER) ) { /* Found */
584: next_r = ftell(fp); offset = next_r - len; done = 1; found = 1;
585: }
586: } else { /* end of file */
587: fseek(fp,0L,SEEK_END);
588: offset = ftell(fp); /* last byte, if last bye is cr, back up one */
589: fseek(fp,-1L,SEEK_END);
590: while(fgetc(fp) == '\n' ) { offset--; fseek(fp,offset,SEEK_SET); }
591: offset = offset +2; /* last char and cr */
592: found = 0; done=1;
593: }
594: }
595: funlockstream(fp); fclose(fp);
596: if(!found) {
1.6 albertel 597: ans_p = capa_malloc(nq+2,1);
598: tries_p = capa_malloc(3*nq+3,1); /* space and \0 */
1.1 albertel 599: for(ii=0;ii<nq;ii++) { /* Initialize answer string and tries string */
600: ans_p[ii] = '-'; tries_p[3*ii] = ' '; tries_p[3*ii + 1] = '0';
601: if(ii < nq-1) tries_p[3*ii + 2] = ',';
602: }
603: entry->answers = ans_p;
604: entry->tries = tries_p;
605: entry->e_probs = nq;
606: offset = capa_append_entry(entry,student_number,set);
607: } else { /* grows records shorter than nq to nq in length*/
608: char *comma;
609: int length;
610: comma=index(oneline,',');
611: length=((int)(comma-oneline))-(MAX_STUDENT_NUMBER+1);
612: if (length < nq) {
1.6 albertel 613: ans_p = capa_malloc(nq+2,1);
614: tries_p = capa_malloc(3*nq+3,1); /* space and \0 */
1.1 albertel 615: } else {
1.6 albertel 616: ans_p = capa_malloc(length+2,1);
617: tries_p = capa_malloc(3*length+3,1); /* space and \0 */
1.1 albertel 618: }
619: sprintf(fmtbuf, "%%%dc",length);
620: sscanf(oneline + MAX_STUDENT_NUMBER+1,fmtbuf,ans_p);
1.6 albertel 621: ans_p[length]='\0';
1.1 albertel 622: sprintf(fmtbuf, "%%%dc",(3*length-1));
623: sscanf(oneline + MAX_STUDENT_NUMBER+1+length+1,fmtbuf,tries_p);
1.10 albertel 624: tries_p[3*length-1]='\0';
1.1 albertel 625: entry->answers = ans_p;
626: entry->tries = tries_p;
627: entry->e_probs = nq;
628: if (length < nq) {
629: for(ii=length;ii<nq;ii++) {
630: ans_p[ii] = '-'; tries_p[3*ii] = ' '; tries_p[3*ii + 1] = '0';
631: if(ii < nq-1) tries_p[3*ii + 2] = ',';
632: }
633: ans_p[nq]='\0';tries_p[3*(nq)+2]='\0';tries_p[3*length-1]=',';
634: }
635: }
636: return (offset);
637: }
638: /*----------------------------------------------------------*/
639: /* Constants defining the column number for each fields */
640: /* in classl file */
641: /*----------------------------------------------------------*/
642: #define SECTION_BEGIN_COLUMN 10
643: #define SN_BEGIN_COLUMN 14
644: #define NAME_BEGIN_COLUMN 24
645: #define EMAIL_BEGIN_COLUMN 60
646: #define CAPAID_BEGIN_COLUMN 100
647: /*----------------------------------------------------------*/
648: /* Retrieve a linked list of students with specified */
649: /* section in classl file */
650: /* If the input section number is 0, students in the whole */
651: /* classl will be retrieved. */
652: /* The resulting linked list is ordered according to the */
653: /* order in classl */
654: /* Remember to use free_students() to free up the linked */
655: /* list once done with it. */
656: /*----------------------------------------------------------*/
657: /* INPUT: section section number */
658: /* 0 means to load the whole class */
659: /* OUTPUT: student_pp */
660: /* pointer to pointer of structure T_student */
661: /* RETURN: number of students in specified section */
662: /*----------------------------------------------------------*/
663: int
664: capa_get_section(student_pp, section)
665: T_student **student_pp;
666: int section;
667: {
668: FILE *fp;
669: char line[SMALL_LINE_BUFFER],fmtbuf[SMALL_LINE_BUFFER], *cp;
670: int i, line_len;
671: int tmp_sec, student_cnt, tmp_capaid;
672: T_student *s1_p, *s2_p, *s3_p;
673:
674: if ((fp=fopen("classl","r"))==NULL) {
675: /*printf("Error: Can't open classlist file\n");*/
676: return (-1);
677: }
678: student_cnt = 0; s1_p = s2_p = s3_p = (T_student *)NULL;
679: while (fgets(line,SMALL_LINE_BUFFER-1,fp)) {
680: line_len = strlen(line);
681: if(line_len > 25 ) { /* contains valid information, instead of only cr */
682: sscanf(line+SECTION_BEGIN_COLUMN,"%d", &tmp_sec);
683: if (!section || tmp_sec == section) {
684: s3_p = (T_student *)capa_malloc(sizeof(T_student),1);
685: s3_p->s_sec = tmp_sec;
686: sprintf(fmtbuf, "%%%dc",MAX_STUDENT_NUMBER);
687: sscanf(line+SN_BEGIN_COLUMN,fmtbuf,s3_p->s_sn);
688: cp = (char *)&line[NAME_BEGIN_COLUMN];
689: for(i=0;i<MAX_NAME_CHAR;i++) s3_p->s_nm[i]=' ';
690: i=0;
691: while( (i < MAX_NAME_CHAR) &&
692: ( isalnum(cp[i]) || cp[i] == ',' || cp[i] == '.' || cp[i] == '\'' ||
693: cp[i] == ' ' || cp[i] == '\t'|| cp[i] == '-' ) ) {
694: s3_p->s_nm[i]=cp[i]; i++;
695: }
696: s3_p->s_nm[MAX_NAME_CHAR]='\0';
697: s3_p->s_email[0]=0;
698: if( line_len > EMAIL_BEGIN_COLUMN ) { /* contains email */
699: cp = (char *)&line[EMAIL_BEGIN_COLUMN];
700: for(i=0;i<MAX_EMAIL_CHAR;i++) s3_p->s_email[i]=' ';
701: i=0;
702: while( (i < MAX_EMAIL_CHAR) &&
703: ( isalnum(cp[i]) || cp[i] == '@' || cp[i] == '.' ) ) {
704: s3_p->s_email[i]=cp[i]; i++;
705: }
706: s3_p->s_email[i]='\0'; /* terminate the email string with the string length */
707: if( line_len > CAPAID_BEGIN_COLUMN ) { /* contains capa id */
708: sscanf(line+CAPAID_BEGIN_COLUMN,"%d", &tmp_capaid);
709: if(tmp_capaid > 0 ) {
710: s3_p->s_capaid = tmp_capaid;
711: }
712: }
713: }
714: if( student_cnt == 0 ) {
715: s1_p = s3_p;
716: s3_p->s_prev = s3_p; s3_p->s_next = (T_student *)NULL;
717: s2_p = s3_p;
718: } else {
719: s3_p->s_prev = s2_p; s3_p->s_next = (T_student *)NULL;
720: s2_p->s_next = s3_p;
721: s2_p = s3_p;
722: }
723: student_cnt++;
724: }
725: }
726: }
727: fclose(fp);
728: *student_pp = s1_p;
729: return (student_cnt);
730: }
731: /*----------------------------------------------------------*/
732: /*----------------------------------------------------------*/
733: /* Retrieve a linked list of students with specified */
734: /* section in classl file */
735: /* If the input section number is 0, students in the whole */
736: /* classl will be retrieved. */
737: /* The resulting linked list is ordered according to */
738: /* student name */
739: /* Remember to use free_students() to free up the linked */
740: /* list once done with it. */
741: /*----------------------------------------------------------*/
742: /* INPUT: section section number */
743: /* 0 means to load the whole class */
744: /* OUTPUT: student_pp */
745: /* pointer to pointer of structure T_student */
746: /* RETURN: number of students in specified section */
747: /*----------------------------------------------------------*/
748:
749: int
750: capa_sorted_section(student_pp, section)
751: T_student **student_pp;
752: int section;
753: {
754: int student_cnt;
755: T_student *student_p, *c_sp;
756:
757: student_cnt = capa_get_section(&student_p,section);
758: if( student_cnt > 1 ) {
759: for(c_sp=student_p;c_sp;c_sp=c_sp->s_next){
760: strcpy(c_sp->s_key,c_sp->s_nm);
761: }
762: msort_main(&student_p);
763: }
764: *student_pp = student_p;
765: return (student_cnt);
766: }
767:
768: /*----------------------------------------------------------*/
769: /* INPUT: address of a pointer to T_student structure */
770: /* OUTPUT: address of a pointer to T_student structure */
771: /* */
772: /* RETURN: none */
773: /*----------------------------------------------------------*/
774: void
775: msort_main(head_pp) T_student **head_pp;
776: {
777: T_student *right_p, *out_sp;
778:
779: if( (*head_pp != NULL) && ((*head_pp)->s_next != NULL) ) {
780: msort_split( *head_pp, &right_p);
781: msort_main(head_pp); msort_main(&right_p);
782: msort_merge(*head_pp, right_p, &out_sp);
783: *head_pp = out_sp;
784: }
785: }
786: /*----------------------------------------------------------*/
787: /* INPUT: a_sp pointer to T_student structur */
788: /* OUTPUT: a_sp */
789: /* b_pp address of a pointer to T_student structure */
790: /* */
791: /* RETURN: none */
792: /*----------------------------------------------------------*/
793: void
794: msort_split(a_sp, b_pp) T_student *a_sp; T_student **b_pp;
795: {
796: T_student *c_sp;
797:
798: *b_pp = a_sp;
799: c_sp = a_sp->s_next;
800: c_sp = c_sp->s_next;
801: while( c_sp != NULL ) {
802: c_sp = c_sp->s_next;
803: *b_pp = (*b_pp)->s_next;
804: if( c_sp != NULL ) c_sp = c_sp->s_next;
805: }
806: c_sp = (*b_pp)->s_next;
807: (*b_pp)->s_next = NULL;
808: *b_pp = c_sp;
809: }
810: /*----------------------------------------------------------*/
811: /* INPUT: a_sp pointer to T_student structur */
812: /* b_sp pointer to T_student structur */
813: /* OUTPUT: c_pp address of a pointer to T_student structure */
814: /* */
815: /* RETURN: none */
816: /*----------------------------------------------------------*/
817: void
818: msort_merge(a_sp, b_sp, c_pp) T_student *a_sp, *b_sp, **c_pp;
819: {
820: T_student *d_sp;
821:
822: if( a_sp == NULL || b_sp == NULL ) {
823:
824: } else {
825: if( strcmp(a_sp->s_key, b_sp->s_key) <= 0 ) {
826: *c_pp = a_sp;
827: a_sp = a_sp->s_next;
828: } else {
829: *c_pp = b_sp;
830: b_sp = b_sp->s_next;
831: }
832: d_sp = *c_pp;
833: while( (a_sp != NULL) && (b_sp != NULL) ) {
834: if( strcmp(a_sp->s_key, b_sp->s_key) <= 0) {
835: d_sp->s_next = a_sp;
836: d_sp = a_sp;
837: a_sp = a_sp->s_next;
838: } else {
839: d_sp->s_next = b_sp;
840: d_sp = b_sp;
841: b_sp = b_sp->s_next;
842: }
843: }
844: if( a_sp == NULL ) {
845: d_sp->s_next = b_sp;
846: } else {
847: d_sp->s_next = a_sp;
848: }
849: }
850: }
851:
852: /*----------------------------------------------------------*/
853: /* INPUT: head_p pointer to T_student structure */
854: /* OUTPUT: head_p pointed to sorted linked list */
855: /* */
856: /* RETURN: none */
857: /*----------------------------------------------------------*/
858: void
859: insert_sort(head_p) T_student *head_p;
860: {
861: T_student *tail_p, *i_p, *p_p, *r_p;
862:
863: if( head_p != NULL ) {
864: tail_p = head_p;
865: while( tail_p->s_next != NULL ) {
866: i_p = tail_p->s_next;
867: if( strcmp( i_p->s_key, head_p->s_key) < 0 ) {
868: tail_p->s_next = i_p->s_next;
869: i_p->s_next = head_p;
870: head_p = i_p;
871: } else {
872: r_p = head_p;
873: p_p = r_p->s_next;
874: while( strcmp(i_p->s_key, p_p->s_key) > 0 ) {
875: r_p = p_p;
876: p_p = r_p->s_next;
877: }
878: if( i_p == p_p ) {
879: tail_p = i_p;
880: } else {
881: tail_p->s_next = i_p->s_next;
882: i_p->s_next = p_p;
883: r_p->s_next = i_p;
884: }
885: }
886: }
887: }
888: }
889: /*----------------------------------------------------------*/
890: /* The purpose of this routine is to free up all spaces */
891: /* in the linked list */
892: /*----------------------------------------------------------*/
893: /* INPUT: student_p pointer to T_student structure */
894: /* OUTPUT: none */
895: /* */
896: /* RETURN: none */
897: /*----------------------------------------------------------*/
898:
899: void
900: free_students(student_p) T_student *student_p;
901: {
902: T_student *s_p,*next_p;
903:
904: for (s_p=student_p; s_p; s_p=next_p) {
905: next_p = (s_p->s_next);
906: capa_mfree((char *)s_p);
907: }
908: }
909:
910: /*----------------------------------------------------------*/
911: /* The purpose of this routine is to free up all spaces */
912: /* in the linked list */
913: /*----------------------------------------------------------*/
914: /* INPUT: student_p pointer to T_student structur */
915: /* OUTPUT: none */
916: /* */
917: /* RETURN: -2 file error */
918: /* -1 never login */
919: /* >= 0 score for that set */
920: /*----------------------------------------------------------*/
921: int
922: capa_get_score(student_number,set,valid_scores,answers_pp)
923: char *student_number;int set;int *valid_scores;char **answers_pp;
924: {
925: T_entry a_record;
926: T_header a_header;
927: long offset;
928: int set_scores, set_valids=0, probs_cnt;
929: int ii=0, never_login=1;
930:
931: if( (offset = capa_get_entry(&a_record,student_number,set) ) == 0 ) {
932: return (-2);
933: }
934: probs_cnt = a_record.e_probs;
935: if( capa_get_header(&a_header,set) < 0 ) { return (-2); }
936: if( offset < 0 ) {
937: for(set_valids=0,ii=0;ii<probs_cnt;ii++) {
938: set_valids += (a_header.weight[ii] - '0');
939: }
940: set_scores = -1;
941: *answers_pp = a_record.answers;
942: capa_mfree(a_record.tries); a_record.tries = NULL;
943: } else {
944: for(set_scores=0,ii=0, never_login=1;ii<probs_cnt;ii++) {
945: switch(a_record.answers[ii]) {
946: case 'Y': case 'y': never_login = 0;
947: set_scores += (a_header.weight[ii] - '0');
948: set_valids += (a_header.weight[ii] - '0'); break;
949: case '-': case 'N': case 'n':
950: set_valids += (a_header.weight[ii] - '0'); break;
951: case 'E': case 'e': break;
952: default : if( a_record.answers[ii] >= '0' &&
953: a_record.answers[ii] <= '9' ) {
954: set_scores += (a_record.answers[ii] - '0');
955: set_valids += (a_header.weight[ii] - '0');
956: never_login = 0;
957: } break;
958: }
959: }
960: *answers_pp = a_record.answers;
961: capa_mfree(a_record.tries); a_record.tries = NULL;
962: }
963: capa_mfree(a_header.weight);
964: capa_mfree(a_header.partial_credit);
965: *valid_scores = set_valids;
966: if(never_login) set_scores = -1;
967: return (set_scores);
968: }
969: /*----------------------------------------------------------*/
970: /* Reads the classl file and returns the number of students */
971: /* for each section in cnt_arry[] */
972: /* In cnt_arry[0] is the maximum section number that */
973: /* has at least one student */
974: /*----------------------------------------------------------*/
975: /* INPUT: cnt_arry[] integer array */
976: /* OUTPUT: cnt_arry[] */
977: /* */
978: /* */
979: /* RETURN: -1 file error */
980: /*----------------------------------------------------------*/
981: int
982: capa_get_section_count(cnt_arry) int cnt_arry[];
983: {
984: FILE *fp;
985: char filename[FILE_NAME_LENGTH];
986: char line[TMP_LINE_LENGTH];
987: int sec_num, cnt, i, max;
988:
989: sprintf(filename,"classl");
990: if ((fp=fopen(filename,"r"))==NULL) {
991: /*printf("Error: can't open %s\n",filename);*/
992: return (-1);
993: }
994: for(i=0;i<MAX_SECTION_COUNT;i++) cnt_arry[i]=0;
995: max = 0;
996: while ( fgets(line,TMP_LINE_LENGTH-1,fp) && (strlen(line) != 0) ) {
997: sec_num=0;
998: sscanf(line+SECTION_BEGIN_COLUMN,"%d", &sec_num);
999: if( sec_num != 0 ) {
1000: max = MAX(sec_num,max);
1001: cnt_arry[sec_num]++;
1002: }
1003: }
1004: fclose(fp);
1005: cnt = 0;
1006: for(i=1; i <= max; i++) {
1007: if(cnt_arry[i]) cnt++;
1008: }
1009: cnt_arry[0] = max;
1010: return (cnt);
1011: }
1012: /*----------------------------------------------------------*/
1013: /* lookup student information from classl file by */
1014: /* student number */
1015: /*----------------------------------------------------------*/
1016: /* INPUT: student_number char array of student number */
1017: /* OUTPUT: student_p pointer to a T_student structure */
1018: /* that contains the student name, */
1019: /* student number, section number */
1020: /* of the student inquired */
1021: /* */
1022: /* RETURN: -1 file error */
1023: /* 0 no such student */
1024: /* >0 success (line number in classl of student)*/
1025: /*----------------------------------------------------------*/
1026: int
1027: capa_get_student(student_number, student_p)
1028: char *student_number;
1029: T_student *student_p;
1030: {
1031: FILE *fp;
1032: char line[SMALL_LINE_BUFFER],fmtbuf[SMALL_LINE_BUFFER],
1033: sNumber[MAX_STUDENT_NUMBER+1],
1034: aNumber[MAX_STUDENT_NUMBER+1];
1035: int i,found,line_len,tmp_capaid,linenum=0;
1036: char *cp;
1037:
1038: strncpy(sNumber, student_number,MAX_STUDENT_NUMBER+1);
1039: if ((fp=fopen("classl","r"))==NULL) {
1040: /*printf("Error: Can't open classlist file\n");*/
1041: return (-1);
1042: }
1043: found = 0;
1044: while (!found && fgets(line,SMALL_LINE_BUFFER-1,fp)) {
1045: linenum++;
1046: line_len = strlen(line);
1047: sprintf(fmtbuf, "%%%dc",MAX_STUDENT_NUMBER);
1048: sscanf(line+SN_BEGIN_COLUMN,fmtbuf,aNumber);
1049: if(!strncasecmp(sNumber,aNumber, MAX_STUDENT_NUMBER)) {
1050: found = 1;
1051: i=0;
1052: strncpy(student_p->s_sn, student_number,MAX_STUDENT_NUMBER+1);
1053: cp = (char *)&line[NAME_BEGIN_COLUMN];
1054: while( (i< MAX_NAME_CHAR) &&
1055: (isalnum(cp[i]) || cp[i] == ',' || cp[i] == '.' || cp[i] == '\'' ||
1056: cp[i] == ' ' || cp[i] == '\t'|| cp[i] == '-' || cp[i] == '_' || cp[i] == '~' ) ) {
1057: student_p->s_nm[i]=cp[i]; i++;
1058: }
1059: student_p->s_nm[i]='\0';
1060: sscanf(line+SECTION_BEGIN_COLUMN,"%d", &(student_p->s_sec));
1061: student_p->s_email[0]=0;
1062: if( line_len > EMAIL_BEGIN_COLUMN ) { /* contains email */
1063: cp = (char *)&line[EMAIL_BEGIN_COLUMN];
1064: for(i=0;i<MAX_EMAIL_CHAR;i++) student_p->s_email[i]=' ';
1065: i=0;
1066: while( (i < MAX_EMAIL_CHAR) &&
1067: ( isalnum(cp[i]) || cp[i] == '@' || cp[i] == '.' || cp[i] == '!' || cp[i] == '=' ||
1068: cp[i] == '_' || cp[i] == '-' || cp[i] == '+' || cp[i] == '^' || cp[i] == '|' ) ) {
1069: student_p->s_email[i]=cp[i]; i++;
1070: }
1071: student_p->s_email[i]='\0'; /* terminate the email string with the string length */
1072: if( line_len > CAPAID_BEGIN_COLUMN ) { /* contains capa id */
1073: sscanf(line+CAPAID_BEGIN_COLUMN,"%d", &tmp_capaid);
1074: if(tmp_capaid > 0 ) {
1075: student_p->s_capaid = tmp_capaid;
1076: }
1077: }
1078: }
1079: }
1080: }
1081: fclose(fp);
1082: if (found > 0) found=linenum;
1083: return (found);
1084: }
1085: /*----------------------------------------------------------*/
1086: /* lookup student information from classl file by */
1087: /* student name */
1088: /*----------------------------------------------------------*/
1089: /* INPUT: student_name char array of student name */
1090: /* OUTPUT: student_p pointer to a T_student structure */
1091: /* that contains the student name, */
1092: /* student number, section number */
1093: /* of the student inquired */
1094: /* */
1095: /* RETURN: -1 file error */
1096: /* 0 no such student */
1097: /* 1 success */
1098: /*----------------------------------------------------------*/
1099: int
1100: capa_student_byname(student_name, student_p)
1101: char *student_name;
1102: T_student *student_p;
1103: {
1104: FILE *fp;
1105: char line[SMALL_LINE_BUFFER],fmtbuf[SMALL_LINE_BUFFER],
1106: sName[MAX_NAME_CHAR+1],
1107: aName[MAX_NAME_CHAR+1];
1108: int i,found, len, line_len,tmp_capaid;
1109: char *cp;
1110:
1111: len = strlen(student_name);
1112: strncpy(sName, student_name,MAX_NAME_CHAR+1);
1113: if ((fp=fopen("classl","r"))==NULL) {
1114: /*printf("Error: Can't open classlist file\n");*/
1115: return (-1);
1116: }
1117: found = 0;
1118: while (fgets(line,SMALL_LINE_BUFFER-1,fp)) {
1119: i=0;
1120: cp = (char *)&line[NAME_BEGIN_COLUMN];
1121: while( (i < MAX_NAME_CHAR) &&
1122: (isalnum(cp[i]) || cp[i] == ',' || cp[i] == '.' || cp[i] == '\'' ||
1123: cp[i] == ' ' || cp[i] == '\t' || cp[i] == '-' || cp[i] == '_' || cp[i] == '~') ) {
1124: aName[i]=cp[i]; i++;
1125: }
1126: aName[i]='\0';
1127: if(!strncasecmp(sName,aName,len)) {
1128: found = 1;
1129: strcpy(student_p->s_nm,aName);
1130: sscanf(line+SECTION_BEGIN_COLUMN,"%d", &(student_p->s_sec));
1131: sprintf(fmtbuf, "%%%dc",MAX_STUDENT_NUMBER);
1132: sscanf(line+SN_BEGIN_COLUMN,fmtbuf,student_p->s_sn);
1133: student_p->s_email[0]=0;
1134: line_len=strlen(line);
1135: if( line_len > EMAIL_BEGIN_COLUMN ) { /* contains email */
1136: cp = (char *)&line[EMAIL_BEGIN_COLUMN];
1137: for(i=0;i<MAX_EMAIL_CHAR;i++) student_p->s_email[i]=' ';
1138: i=0;
1139: while( (i < MAX_EMAIL_CHAR) &&
1140: ( isalnum(cp[i]) || cp[i] == '@' || cp[i] == '.' || cp[i] == '!' || cp[i] == '=' ||
1141: cp[i] == '_' || cp[i] == '-' || cp[i] == '+' || cp[i] == '^' || cp[i] == '|' ) ) {
1142: student_p->s_email[i]=cp[i]; i++;
1143: }
1144: student_p->s_email[i]='\0'; /* terminate the email string with the string length */
1145: if( line_len > CAPAID_BEGIN_COLUMN ) { /* contains capa id */
1146: sscanf(line+CAPAID_BEGIN_COLUMN,"%d", &tmp_capaid);
1147: if(tmp_capaid > 0 ) {
1148: student_p->s_capaid = tmp_capaid;
1149: }
1150: }
1151: }
1152: }
1153: }
1154: fclose(fp);
1155: return (found);
1156: }
1157: /*----------------------------------------------------------*/
1158: /* Randomly selected a student from classl file specified */
1159: /* by section */
1160: /*----------------------------------------------------------*/
1161: /* INPUT: section section number */
1162: /* OUTPUT: student_p pointer to a T_student structure */
1163: /* that contains the student name, */
1164: /* student number, section number */
1165: /* of the student inquired */
1166: /* */
1167: /* RETURN: -1 file error */
1168: /* 0 no such student */
1169: /* 1 success */
1170: /*----------------------------------------------------------*/
1171: int
1172: capa_pick_student(section, student_p)
1173: int section;
1174: T_student *student_p;
1175: {
1176: T_student *s1_p, *s2_p;
1177: int student_cnt, idx, pick=-1;
1178:
1179: student_cnt = capa_get_section(&s1_p,section);
1180: if(student_cnt > 0 ) {
1181: srand(time(NULL));
1182: pick = rand() % student_cnt;
1183: for(s2_p = s1_p, idx=0; s2_p && idx < pick; idx++) {
1184: s2_p = s2_p->s_next;
1185: }
1186: strcpy(student_p->s_sn,s2_p->s_sn);
1187: strcpy(student_p->s_nm,s2_p->s_nm);
1188: strcpy(student_p->s_email,s2_p->s_email);
1189: student_p->s_capaid=s2_p->s_capaid;
1190: student_p->s_sec = s2_p->s_sec;
1191: free_students(s1_p);
1192: }
1193: return (pick);
1194: }
1195: /* -------------------------------------------------- */
1196: /* add a student to the class file */
1197: /* check duplicated student id */
1198: /* student name? */
1199: /* Returns: 0 success */
1200: /* 1 there is an duplicate entry */
1201: /* -------------------------------------------------- */
1202: int
1203: capa_add_student(student_p)
1204: T_student *student_p;
1205: {
1206: FILE *fp;
1207: char line[SMALL_LINE_BUFFER], fmtbuf1[SMALL_LINE_BUFFER],
1208: tmp_nm[MAX_STUDENT_NUMBER+1],
1209: tmp_nu[MAX_NAME_CHAR+1];
1210: int i,found, len;
1211: char *class, *cp;
1212: char cid[4],cn[4];
1213: #if defined(NeXT)
1214: char cwd[FILE_NAME_LENGTH];
1215: #endif
1216:
1217: #if defined(NeXT)
1218: class = getwd(cwd);
1219: if( class == NULL ) { class = cwd; }
1220: #else
1221: class = getcwd(NULL,255);
1222: #endif
1223:
1224: if( class == NULL ) { printf("capa_add_student(): Current working directory unknown!\n"); }
1225: len=strlen(class); cp=class; cp=cp+(len-8);
1226: for(i=0;i<3;i++) {
1227: cid[i] = cp[i+3];
1228: cn[i] = cp[i];
1229: }
1230: cid[3]=cn[3]=0;
1231: if ((fp=fopen("classl","r+"))==NULL) {
1232: /*printf("Error: Can't open classlist file\n");*/
1233: return (-1);
1234: }
1235: found = 0;
1236: sprintf(fmtbuf1, "%%%dc",MAX_STUDENT_NUMBER);
1237: while (fgets(line,SMALL_LINE_BUFFER-1,fp)) {
1238: sscanf(line+SN_BEGIN_COLUMN,fmtbuf1,tmp_nu);
1239: tmp_nu[MAX_STUDENT_NUMBER]='\0';
1240: if(!strncasecmp(student_p->s_sn,tmp_nu, MAX_STUDENT_NUMBER)) {
1241: found = 1; break;
1242: }
1243: i=0; cp = (char *)&line[NAME_BEGIN_COLUMN];
1244: while( (i < MAX_NAME_CHAR) &&
1245: (isalnum(cp[i]) || cp[i] == ',' || cp[i] == '.' || cp[i] == '\'' ||
1246: cp[i] == ' ' || cp[i] == '\t'|| cp[i] == '-' || cp[i] == '_' || cp[i] == '~') ) {
1247: tmp_nm[i]=cp[i]; i++;
1248: }
1249: tmp_nm[i]='\0';
1250: len=strlen(tmp_nm);
1251: if(!strncasecmp(student_p->s_nm,tmp_nm,len)) {
1252: found = 1; break;
1253: }
1254: }
1255: if(!found) {
1256: sprintf(line,"%s %s %03d %s %s\n",
1257: cn,cid,student_p->s_sec,student_p->s_sn,student_p->s_nm);
1258: len = strlen(line);
1259: fseek(fp,0L,SEEK_END);
1260: if (!fwrite(line,len,1,fp) ) {
1261: /*printf("Error writing data to file\n");*/
1262: found = -1;
1263: }
1264: fflush(fp);
1265: }
1266: fclose(fp);
1267: free(class);
1268: return (found);
1269: }
1270: /*----------------------------------------------------------*/
1271: /* INPUT: student_number char array of student number */
1272: /* set the X in logX.db */
1273: /* OUTPUT: none */
1274: /* */
1275: /* RETURN: -1 file error */
1276: /* 0 no login */
1277: /* >0 number of logins in that logX.db file */
1278: /*----------------------------------------------------------*/
1279: int
1280: capa_get_login_count(student_number,set)
1281: char *student_number;
1282: int set;
1283: {
1284: char filename[FILE_NAME_LENGTH],
1285: sNumber[MAX_STUDENT_NUMBER+1],
1286: aNumber[MAX_STUDENT_NUMBER+1];
1287: FILE *fp;
1288: char line[MAX_BUFFER_SIZE],fmtbuf[MAX_BUFFER_SIZE];
1289: int num;
1290:
1291: strncpy(sNumber, student_number,MAX_STUDENT_NUMBER+1);
1292: sprintf(filename,"records/log%d.db",set);
1293: if( !capa_access(filename, F_OK) ) {
1294: if ((fp=fopen(filename,"r"))==NULL) {
1295: /*printf("Error: can't open %s\n",filename);*/
1296: return (-1);
1297: }
1298: } else {
1299: return (-1);
1300: }
1301: num = 0;
1302: while (fgets(line,MAX_BUFFER_SIZE-1,fp)) {
1303: sprintf(fmtbuf, "%%%dc",MAX_STUDENT_NUMBER);
1304: sscanf(line,fmtbuf,aNumber);
1305: if(!strncasecmp(sNumber,aNumber, MAX_STUDENT_NUMBER)) num++;
1306: }
1307: fclose(fp);
1308: return (num);
1309: }
1310: /*----------------------------------------------------------*/
1311: /* INPUT: set the X in logX.db */
1312: /* OUTPUT: none */
1313: /* */
1314: /* RETURN: -1 file error */
1315: /* 0 no login */
1316: /* >0 number of logins in that logX.db file */
1317: /*----------------------------------------------------------*/
1318: #define ANSWER_BEGIN_COLUMN 35
1319: int
1320: capa_get_login_db(login_item,num_probs,set)
1321: T_entry login_item[];
1322: int *num_probs;
1323: int set;
1324: {
1325: FILE *fp;
1326: char filename[FILE_NAME_LENGTH];
1327: char line[MAX_BUFFER_SIZE],fmtbuf[SMALL_LINE_BUFFER];
1328: T_header header;
1329: int num_q, count, len;
1330:
1331: if(capa_get_header(&header,set)) return (0);
1332: sscanf(header.num_questions,"%d",&num_q);
1333: *num_probs = num_q;
1334: capa_mfree(header.weight);
1335: capa_mfree(header.partial_credit);
1336:
1337: sprintf(filename,"records/log%d.db",set);
1338: if((fp=fopen(filename,"r"))==NULL) {
1339: /*printf("Error: can't open %s\n",filename);*/
1340: return (-1);
1341: }
1342: count=0;
1343: while ( fgets(line,MAX_BUFFER_SIZE,fp) && (strlen(line) != 0 )) {
1344: len = strlen(line);
1345: if(len > ANSWER_BEGIN_COLUMN ) {
1346: sprintf(fmtbuf, "%%%dc",MAX_STUDENT_NUMBER);
1347: sscanf(line,fmtbuf, login_item[count].student_number);
1348: login_item[count].answers = capa_malloc(num_q,1);
1349: sprintf(fmtbuf, "%%%dc",num_q);
1350: sscanf(line+ANSWER_BEGIN_COLUMN,fmtbuf, login_item[count].answers);
1351: count++;
1352: }
1353: }
1354: fclose(fp);
1355: return (count);
1356: }
1357:
1358: /*----------------------------------------------------------*/
1359: /* INPUT: option the option the check */
1360: /* set the X in dateX.db */
1361: /* section which section to check for */
1362: /* */
1363: /* OUTPUT: none */
1364: /* */
1365: /* RETURN: -2 invalid option */
1366: /* -1 capa_get_section_dates error */
1367: /* 0 no */
1368: /* 1 yes */
1369: /*----------------------------------------------------------*/
1370: int capa_check_option(int option,int set,int section)
1371: {
1372: T_dates* dates;
1373: int result;
1374:
1375: result=capa_get_section_dates(section,set,&dates);
1376: if (result < 0) return -1;
1377: switch(option) {
1378: case OPTION_INHIBIT_RESPONSE: result=dates->inhibit_response;break;
1379: case OPTION_VIEW_PROBLEMS_AFTER_DUE: result=dates->view_problems_after_due;break;
1380: default: result=-2;
1381: }
1382: capa_mfree((char*)dates);
1383: return result;
1384: }
1385:
1386: /*----------------------------------------------------------*/
1.3 albertel 1387: /* INPUT: time the current time */
1388: /* datetime the datetime string to compare */
1.1 albertel 1389: /* OUTPUT: none */
1390: /* */
1.3 albertel 1391: /* RETURN: -1 time is earlier then datetime */
1392: /* 1 time is later than datetime */
1.1 albertel 1393: /*----------------------------------------------------------*/
1394: int
1395: compare_datetime(time,datetime)
1396: time_t time;
1397: char *datetime;
1398: {
1399: char dateStr[16], timeStr[16];
1400: time_t time2;
1401: char *t_ptr;
1402: int idx;
1403:
1404: /* sscanf(datetime,"%s %s",dateStr,timeStr); */
1405: t_ptr = index(datetime,' '); t_ptr++; /*** hpux complained */
1406: for(idx=0;idx<10;idx++) dateStr[idx] = datetime[idx];
1407: dateStr[10] = 0;
1408: for(idx=0;idx<5;idx++) timeStr[idx] = t_ptr[idx];
1409: timeStr[5] = 0;
1410: time2 = convertTime(dateStr,timeStr);
1411: if(time == time2 ) return (0);
1412: return ( (time > time2)? 1 : -1 );
1413: }
1414:
1415: /* --------------------------------- */
1416: /* check if records/dateX.db exists */
1417: /* read the section open date, answer date, due date info */
1418: /* What if: [7,3] date_info */
1419: /* [3,7] date_info */
1420: /* 4 date_info */
1.3 albertel 1421: /* RETURN: -1 if not pass time */
1422: /* 1 if pass time (or no time available */
1.1 albertel 1423: int capa_check_date(int which,char *student_number, int section,int set)
1424: {
1425: int result;
1426: char date_str[TMP_LINE_LENGTH];
1427: time_t curtime;
1428:
1429: time(&curtime);
1430:
1431: result = capa_get_date(which,student_number,section,set,date_str);
1432: if ( result == 1 ) { result = compare_datetime(curtime,date_str); }
1433: return result;
1434: }
1435:
1436: time_t capa_convert_duration(char *duration)
1437: {
1438: int hour, minute;
1439: sscanf(duration,"%d:%d",&hour,&minute);
1440: return ((hour*60)+minute)*60;
1441: }
1442:
1443: void capa_get_due_date(char *date_str,T_dates *current,char *student_number,int set)
1444: {
1445: time_t duration=capa_convert_duration(current->duration);
1446: time_t duetime=0;
1447: time_t logintime;
1448: struct tm *due_time_tm;
1449: if ((duration > 0) && (student_number!=NULL)) {
1450: if (capa_get_login_time(student_number,set,&logintime)==1) {
1451: duetime=logintime+duration;
1.19 albertel 1452: if (compare_datetime(duetime,current->due_date)==-1) {
1453: due_time_tm=localtime(&duetime);
1454: sprintf(date_str,"%04d/%02d/%02d %02d:%02d",((due_time_tm->tm_year)+1900),
1455: due_time_tm->tm_mon+1,due_time_tm->tm_mday,due_time_tm->tm_hour,
1456: due_time_tm->tm_min);
1457: } else {
1458: strncpy(date_str,current->due_date,DATE_BUFFER);
1459: }
1.1 albertel 1460: return;
1461: }
1462: }
1463: strncpy(date_str,current->due_date,DATE_BUFFER);
1464: }
1465:
1466: /* student_number can be NULL, if it isn't NULL it is used by get_due_date */
1467: /* to assign a due date based on the time the student first accessed the */
1468: /* set if duration is non-zero */
1469: int
1470: capa_get_date(int which,char *student_number,int section,int set,char *date_str)
1471: {
1472: T_dates *current;
1473: int result;
1474: result=capa_get_section_dates(section,set,¤t);
1475: if (result<0) return result;
1476: result=1;
1477: switch(which) {
1478: case CHECK_OPEN_DATE: strncpy(date_str,current->open_date,DATE_BUFFER); break;
1479: case CHECK_DUE_DATE: capa_get_due_date(date_str,current,student_number,set); break;
1480: case CHECK_ANS_DATE: strncpy(date_str,current->answer_date,DATE_BUFFER); break;
1481: default: strncpy(date_str,current->open_date,DATE_BUFFER); result=-4;break;
1482: }
1483: capa_mfree((char*)current);
1484: return result;
1485: }
1486:
1487: int
1488: capa_get_duration(char *student_number,int section,int set)
1489: {
1490: T_dates *current;
1491: int duration=0,result;
1492: result=capa_get_section_dates(section,set,¤t);
1493: if (result<0) return result;
1494: duration=capa_convert_duration(current->duration);
1495: capa_mfree((char*)current);
1496: return duration;
1497: }
1498:
1499: int
1500: capa_get_section_dates(int section,int set,T_dates** dates)
1501: {
1502: register int c;
1503: FILE *fp;
1504: int result = 0, done;
1505: int tmp_low, tmp_high, sec_mode;
1506: char filename[FILE_NAME_LENGTH], tmpline[TMP_LINE_LENGTH],
1507: default_line[TMP_LINE_LENGTH];
1508:
1509: sprintf(filename,"records/date%d.db",set);
1510: if( capa_access(filename, F_OK) != 0 ) { result = -2; } else {
1511: if ((fp=fopen(filename,"r")) == NULL) { result = -2; } else {
1512: done = 0; result = -3;
1513: /* first non-comment line is assumed to be the default line */
1514: c_gettype(fp); c_ignorewhite(fp); fgets(default_line,TMP_LINE_LENGTH-1,fp);
1515: do {
1516: c_ignorewhite(fp); c = getc(fp); ungetc(c,fp);
1517: if( c != EOF ) {
1518: sec_mode = c_getsec_range(fp,&tmp_low,&tmp_high);
1519: if( sec_mode > 0 ) { /* no error */
1520: c_ignorewhite(fp); fgets(tmpline,TMP_LINE_LENGTH-1,fp);
1521: if( sec_mode == 1 ) { /* form: sec date_info */
1522: if((result == -3) && (tmp_low == section)) {
1523: result=-4;
1524: *dates=add_date_info(tmp_low,tmp_low,tmpline);
1525: if ( *dates != NULL ) { done = 1; result = 1; }
1526: }
1527: } else { /* form : [low,high] date_info */
1528: if( (result == -3) && ((section>=tmp_low)&&(section<=tmp_high)) ) {
1529: result = -4;
1530: *dates=add_date_info(tmp_low,tmp_high,tmpline);
1531: if ( *dates != NULL ) { done = 1; result = 1; }
1532: }
1533: }
1534: } else { /* error in specify section date */
1535: while ( ((c = getc(fp)) != '\n') && ( c != EOF) ); /* skip to end of line */
1536: }
1537: } else { /* EOF encountered */
1538: done = 1;
1539: }
1540: } while (!done);
1541: /* need to deal with those sections not show up in the dateX.db file */
1542: if( result == -3 ) { /* section not in the dateX.db file, use default */
1543: result = -4;
1544: *dates=add_date_info(DATE_DEFAULTS,DATE_DEFAULTS,default_line);
1545: if ( *dates != NULL ) { result = 1; }
1546: }
1547: }
1548: fclose(fp);
1549: }
1550: return (result);
1551: }
1552:
1553: T_dates* add_date_info(int lowsec,int highsec, char *dateinfo)
1554: {
1555: T_dates *dates;
1556: int result;
1557: dates=(T_dates*)capa_malloc(sizeof(T_dates),1);
1558: result=sscanf(dateinfo,"%16c,%16c,%16c,%s %d,%d",dates->open_date,dates->due_date,
1559: dates->answer_date,dates->duration,&(dates->inhibit_response),
1560: &(dates->view_problems_after_due));
1561: if (result != 6) {
1562: capa_mfree((char*)dates);
1563: dates=NULL;
1564: } else {
1565: dates->section_start=lowsec;
1566: dates->section_end=highsec;
1567: dates->s_next=NULL;
1568: }
1569: return dates;
1570: }
1571: /*----------------------------------------------------------*/
1572: /* INPUT: set the X in dateX.db */
1573: /* dates a pointer to the dates pointer */
1574: /* ACTION: builds a linked list of T_dates containing */
1575: /* the login information */
1576: /* RETURN: <0 file error */
1577: /* >0 success (number of lines successfully */
1578: /* proccessed) */
1579: /*----------------------------------------------------------*/
1580: int capa_get_all_dates (int set,T_dates **dates)
1581: {
1582: T_dates *current;
1583: FILE *fp;
1584: int result = 0, done, tmp_low, tmp_high, sec_mode, c, num=0;
1585: char filename[FILE_NAME_LENGTH], tmpline[TMP_LINE_LENGTH];
1586:
1587: sprintf(filename,"records/date%d.db",set);
1588: if ( ((fp=fopen(filename,"r")) == NULL)) { result = -2; } else {
1589: done = 0; result = -3;
1590: /* first non-comment line is assumed to be the default line */
1591: c_gettype(fp); c_ignorewhite(fp); fgets(tmpline,TMP_LINE_LENGTH-1,fp);
1592: *dates=add_date_info(DATE_DEFAULTS,DATE_DEFAULTS,tmpline);
1593: num++;
1594: if ( NULL == (current=*dates) ) {
1595: result = -3;
1596: } else {
1597: while(1) {
1598: c_ignorewhite(fp); c = getc(fp); ungetc(c,fp);
1599: if( c == EOF ) { break; }
1600: sec_mode = c_getsec_range(fp,&tmp_low,&tmp_high);
1601: if( sec_mode > 0 ) { /* no error */
1602: c_ignorewhite(fp); fgets(tmpline,TMP_LINE_LENGTH-1,fp);
1603: if( sec_mode == 1 ) { /* form: sec date_info */
1604: current->s_next=add_date_info(tmp_low,tmp_low,tmpline);
1605: } else { /* form : [low,high] date_info */
1606: current->s_next=add_date_info(tmp_low,tmp_high,tmpline);
1607: }
1608: current=current->s_next;
1609: num++;
1610: } else { /* error in specify section date */
1611: while ( ((c = getc(fp)) != '\n') && ( c != EOF) ); /* skip to end of line */
1612: }
1613: }
1614: result=num;
1615: }
1616: fclose(fp);
1617: }
1618: return (result);
1619: }
1620:
1621: /*----------------------------------------------------------*/
1622: /* INPUT: dates a pointer to the dates pointer */
1623: /* ACTION: frees a linked list of T_dates */
1624: /*----------------------------------------------------------*/
1625: void free_dates(T_dates *dates)
1626: {
1627: T_dates *current = dates,*next;
1628: while ( current != NULL ) {
1629: next = current->s_next;
1630: capa_mfree((char*)current);
1631: current = next;
1632: }
1633: }
1634:
1635: /*----------------------------------------------------------*/
1636: /* INPUT: set the X in dateX.db */
1637: /* dates a pointer to the dates pointer */
1638: /* ACTION: takes a linked list of date information and */
1639: /* and writes the info to a file */
1640: /* RETURN: -1 file error */
1641: /* 1 success */
1642: /*----------------------------------------------------------*/
1643: int capa_set_all_dates (int set,T_dates *dates)
1644: {
1645: T_dates *current = dates;
1646: int result;
1647: FILE* fp;
1648: char filename[FILE_NAME_LENGTH];
1649:
1650: sprintf(filename,"records/date%d.db",set);
1651: if ( ((fp=fopen(filename,"w")) == NULL) ) { result = -1; } else {
1652: result=1;
1653: while ( current != NULL ) {
1654: if ( current->section_start == DATE_DEFAULTS ) {
1655: fprintf(fp,"<< DEFAULTS >> ");
1656: } else {
1657: fprintf(fp,"[%d, %d] ", current->section_start,current->section_end);
1658: }
1659: fprintf(fp,"%s,%s,%s,%s %d,%d\n", current->open_date,current->due_date,
1660: current->answer_date,current->duration,current->inhibit_response,
1661: current->view_problems_after_due);
1662: current = current->s_next;
1663: }
1664: fclose(fp);
1665: }
1666: return result;
1667: }
1668:
1669: /*----------------------------------------------------------*/
1670: /* INPUT: set the X in logX.db */
1671: /* OUTPUT: none */
1672: /* */
1673: /* RETURN: -1 file error */
1674: /* 0 no login */
1675: /* >0 number of logins in that logX.db file */
1676: /*----------------------------------------------------------*/
1677:
1678: #define FIFTEEN_MINUTES (15*60)
1679: #define TEN_MINUTES (600)
1680: #define ONE_DAY (86400)
1681: int /* RETURNS: 1 first time login, 2 second time login, 0 not ok, -1 file error */
1682: login_check(student_number) /* ARGUMENTS: */
1683: char *student_number; /* Student # */
1684: { /* LOCALS: */
1685: FILE *fp;
1686:
1687: int errcode=0;
1688: int found;
1689: char filename[FILE_NAME_LENGTH];
1690: char line[SMALL_LINE_BUFFER], new_line[SMALL_LINE_BUFFER];
1691: struct tm *theDT;
1692: time_t login_time, record_time;
1693: long offsetL, offsetR, offsetEnd,left_leng;
1694: char s_number[MAX_STUDENT_NUMBER+1];
1695: char tty_name[FILE_NAME_LENGTH];
1696: int log_tries, p_id;
1697: int month, day, year, hour, min, sec;
1698: char *tmp_buffer;
1699:
1700: sprintf(filename,"records/active.log");
1701:
1702: if( capa_access(filename,F_OK) < 0 ) { /*<------------- File not exist */
1703: if ((fp=fopen(filename,"w"))==NULL) { /* create if non-existant */
1704: /*printf("Error: can't create %s\n",filename);*/
1705: return (-1);
1706: }
1707: fclose(fp);
1708: }
1709: if ((fp=fopen(filename,"r"))==NULL) {
1710: /*printf("Error: can't open %s\n",filename);*/
1711: return (-1);
1712: }
1713: flockstream(fp); /* lock exclusively and perform read/write operation */
1714:
1715: found = 0;
1716: while( (!found) && ( fgets(line,SMALL_LINE_BUFFER-1,fp) != NULL) ) {
1717: if( !strncasecmp(line,student_number,MAX_STUDENT_NUMBER) ) found = 1;
1718: }
1719: offsetR = ftell(fp);
1720: offsetL = offsetR - strlen(line);
1721: funlockstream(fp); fclose(fp);
1722:
1723: if( found && (strlen(line) != 0) ) {
1724: /* printf("FOUND:%slen=%d\n",line,strlen(line)); */
1725: sscanf(line,"%s , %d , %d , /dev/%s ,(%d/%d/%d %d:%d:%d)\n", s_number,&log_tries,&p_id,tty_name,&month,&day,&year,&hour,&min,&sec);
1726: record_time = time(NULL);
1727: theDT = localtime(&record_time);
1728: theDT->tm_sec = sec; theDT->tm_min = min;
1729: theDT->tm_hour = hour; theDT->tm_mday = day;
1730: theDT->tm_mon = month-1; theDT->tm_year = year;
1731: theDT->tm_wday = weekday(year,month,day);
1732: theDT->tm_yday = julianday(year,month,day);
1733: record_time = mktime( theDT );
1734: time(&login_time); theDT = localtime(&login_time);
1735: switch(log_tries) {
1736: case 0: log_tries = 1; errcode = 1; break;
1737: case 1: log_tries = 2; errcode = 2;
1738: break;
1739: case 2: log_tries = 3; errcode = 0; break;
1740: case 3: if( (login_time - record_time) >= TEN_MINUTES ) {
1741: log_tries = 1; errcode = 1;
1742: } else {
1743: log_tries = 3; errcode = 2;
1744: return (0);
1745: }
1746: break;
1747: default: printf("ERROR: Number of logins UNKNOWN\n");
1748: log_tries = 1; errcode = 1;
1749: break;
1750: }
1751: sprintf(new_line,"%s , %2d , %5d , %s ,(%02d/%02d/%02d %02d:%02d:%02d)\n", student_number, log_tries, getpid(),ttyname(0), theDT->tm_mon + 1, theDT->tm_mday, theDT->tm_year, theDT->tm_hour, theDT->tm_min ,theDT->tm_sec);
1752: if ((fp=fopen(filename,"r+"))==NULL) {
1753: /*printf("Error: can't open %s\n",filename);*/
1754: return (-1);
1755: }
1756: flockstream(fp);
1757: tmp_buffer = (char *)malloc(8*1024*56);
1758: found = 0;
1759: while( (!found) && ( fgets(line,SMALL_LINE_BUFFER-1,fp) != NULL) ) {
1760: if( !strncasecmp(line,student_number,MAX_STUDENT_NUMBER) ) found = 1;
1761: }
1762: offsetR = ftell(fp); offsetL = offsetR - strlen(line);
1763: fseek(fp,0L,SEEK_END); offsetEnd = ftell(fp);
1764: left_leng = offsetEnd - offsetR;
1765: fseek(fp,offsetR,SEEK_SET);
1766: left_leng = fread(tmp_buffer, 1, left_leng+1, fp);
1767: tmp_buffer[left_leng] = 0;
1768: fseek(fp,offsetL,SEEK_SET);
1769: if ( fprintf(fp,"%s%s",new_line,tmp_buffer) < 0 ) {
1770: /*printf("Error: cannot write active.log\n");*/
1771: errcode = -1;
1772: }
1773: fflush(fp);
1774: free( (char *)tmp_buffer);
1775: funlockstream(fp);
1776: fclose(fp);
1777: } else { /********************************** First time login */
1778: if ((fp=fopen(filename,"a+"))==NULL) {
1779: /*printf("Error: can't open %s\n",filename);*/
1780: return (-1);
1781: }
1782: log_tries = 1;
1783: time(&login_time);
1784: theDT = localtime(&login_time);
1785: sprintf(line,"%s , %2d , %5d , %s ,(%02d/%02d/%02d %02d:%02d:%02d)\n", student_number, log_tries, getpid(),ttyname(0), theDT->tm_mon + 1, theDT->tm_mday, theDT->tm_year, theDT->tm_hour, theDT->tm_min ,theDT->tm_sec);
1786: /*
1787: leng = strlen(line);
1788: for(idx = 0, len_idx = 0; idx<(leng-1); idx++) {
1789: if(line[idx] == '\n' && line[idx+1] == '\n') {
1790: line[idx+1] = 0;
1791: }
1792: }
1793: */
1794: flockstream(fp);
1795: if ( !fwrite((char *)line, strlen(line), 1, fp) ) {
1796: /*printf("ERROR: cannot write active.log\n");*/
1797: errcode = -1;
1798: } else {
1799: errcode = 1;
1800: }
1801: fflush(fp);
1802: funlockstream(fp);
1803: fclose(fp);
1804: }
1805: return (errcode);
1806:
1807: }
1808:
1809: /******************************************************************************/
1810: /* Logout check */
1811: /******************************************************************************/
1812: int /* RETURNS: 1 successful, 0 otherwise, -1 file error */
1813: logout_check(student_number) /* ARGUMENTS: */
1814: char *student_number; /* Student # */
1815: { /* LOCALS: */
1816: FILE *fp;
1817:
1818: int errcode=0;
1819: int found;
1820: char filename[FILE_NAME_LENGTH];
1821: char line[SMALL_LINE_BUFFER];
1822: long offsetL, offsetR, offsetEnd,left_leng;
1823: char s_number[MAX_STUDENT_NUMBER+1];
1824: char tty_name[FILE_NAME_LENGTH];
1825: int log_tries, p_id;
1826: int month, day, year, hour, min, sec;
1827: char *tmp_buffer;
1828:
1829:
1830: sprintf(filename,"records/active.log");
1831: if ((fp=fopen(filename,"r"))==NULL) {
1832: /*printf("Error: can't open %s\n",filename);*/
1833: return (-1);
1834: }
1835: flockstream(fp); /* lock exclusively and perform read/write operation */
1836:
1837: found = 0;
1838: while( (!found) && ( fgets(line,SMALL_LINE_BUFFER-1,fp) != NULL) ) {
1839: if( !strncasecmp(line,student_number,MAX_STUDENT_NUMBER) ) found = 1;
1840: }
1841: offsetR = ftell(fp);
1842: offsetL = offsetR - strlen(line);
1843:
1844: funlockstream(fp);
1845: fclose(fp);
1846:
1847: if( found ) {
1848: #ifdef __alpha
1849: sscanf(line,"%s , %d , %d , /dev/%s ,(%d/%d/%d %d:%d:%d)\n", s_number,&log_tries,&p_id,tty_name,&month,&day,&year,&hour,&min,&sec);
1850: #else
1851: sscanf(line,"%s , %d , %d , /dev/%s ,(%d/%d/%d %d:%d:%d)\n", \
1852: s_number,&log_tries,&p_id,tty_name,&month,&day,&year,&hour,&min,&sec);
1853: #endif
1854: switch(log_tries) {
1855: case 0: log_tries = 0;
1856: break;
1857: case 1: log_tries = 0;
1858: break;
1859: case 2: log_tries = 0;
1860: break;
1861: default: printf("ERROR: Number of logins UNKNOWN\n");
1862: log_tries = 0;
1863: break;
1864: }
1865: #ifdef __alpha
1866: sprintf(line,"%s , %2d , %5d , /dev/%s ,(%02d/%02d/%02d %02d:%02d:%02d)\n", s_number,log_tries, p_id, tty_name, month, day, year, hour, min, sec);
1867: #else
1868: sprintf(line,"%s , %2d , %5d , /dev/%s ,(%02d/%02d/%02d %02d:%02d:%02d)\n", \
1869: s_number,log_tries, p_id, tty_name, month, day, year, hour, min, sec);
1870: #endif
1871:
1872: if ((fp=fopen(filename,"r+"))==NULL) {
1873: /*printf("Error: can't open %s\n",filename);*/
1874: return (-1);
1875: }
1876: flockstream(fp);
1877: tmp_buffer = (char *)malloc(8*1024*56);
1878: fseek(fp,0L,SEEK_END);
1879: offsetEnd = ftell(fp);
1880: left_leng = offsetEnd - offsetR;
1881: fseek(fp,offsetR,SEEK_SET);
1882: fread(tmp_buffer, left_leng, 1, fp);
1883: tmp_buffer[left_leng] = 0;
1884: /*
1885: for(idx=0, l_idx = 0; idx< (left_leng-1); idx++) {
1886: if( tmp_buffer[idx] == '/n' && tmp_buffer[idx+1] == '/n' ) {
1887: }
1888: }
1889: */
1890: fseek(fp,offsetL,SEEK_SET);
1891: if ( fprintf(fp,"%s%s",line,tmp_buffer) < 0 ) {
1892: /*printf("Error: write error\n");*/
1893: errcode = -1;
1894: } else {
1895: errcode = 1;
1896: }
1897: fflush(fp);
1898: free( (char *)tmp_buffer);
1899: funlockstream(fp);
1900: fclose(fp);
1901: } else {
1902: errcode = -1;
1903: }
1904: return (errcode);
1905:
1906: }
1907: /*********************************************/
1908: /* SIZE of char =1, int=4, long=4, double=8 */
1909: void
1910: capa_seed(seed1,seed2,student_number)long *seed1;long *seed2;char *student_number;
1911: {
1912: int class_pin1, class_pin2;
1913: int s_pin1, s_pin2, s_pin3;
1914: int i;
1915: char dest[16], tmpSN[MAX_STUDENT_NUMBER+1];
1916: char *class,*capadefault="capadefault";
1917: long part1, part2;
1918: #if defined(NeXT)
1919: char cwd[FILE_NAME_LENGTH];
1920: #endif
1921: int big_endian;
1922:
1923: big_endian = endian(); /* determine what type of CPU we are on */
1924:
1925: #if defined(NeXT)
1926: class = getwd(cwd);
1927: if( class == NULL ) { class = cwd; }
1928: #else
1929: class = getcwd(NULL,255);
1930: #endif
1931: class_pin1 = class_pin2 = 2;
1932: s_pin1 = s_pin2 = s_pin3 = 2;
1933:
1934: if( class == NULL ) {
1935: printf("capa_seed(): Current working directory unknown! Using capadefault\n");
1936: class=capa_malloc(strlen(capadefault)+1,1);
1937: strcpy(class,capadefault);
1938: }
1939: if( big_endian ) {
1940: for(i=0;i<4;i++) dest[i] = class[strlen(class)-8+i];
1941: for(i=4;i<8;i++) dest[i] = 0;
1942: memcpy((char *)(&class_pin1), dest, 4);
1943: for(i=0;i<4;i++) dest[i] = class[strlen(class)-4+i];
1944: for(i=4;i<8;i++) dest[i] = 0;
1945: memcpy((char *)(&class_pin2), dest, 4);
1946: } else {
1947: for(i=0;i<4;i++) dest[i] = class[strlen(class)-i-5];
1948: for(i=4;i<8;i++) dest[i] = 0;
1949: memcpy((char *)(&class_pin1), dest, 4);
1950: for(i=0;i<4;i++) dest[i] = class[strlen(class)-i-1];
1951: for(i=4;i<8;i++) dest[i] = 0;
1952: memcpy((char *)(&class_pin2), dest, 4);
1953: }
1954: for(i=0;i<MAX_STUDENT_NUMBER;i++) {
1955: if(islower(student_number[i])) {
1956: tmpSN[i] = toupper(student_number[i]);
1957: } else {
1958: tmpSN[i] = student_number[i];
1959: }
1960: }
1961: tmpSN[MAX_STUDENT_NUMBER] = 0;
1962:
1963: if( big_endian ) { /* big endian ** SUN, BlackNeXT 68xxx , PowerPC */
1964: for(i=0;i<4;i++) dest[i] = tmpSN[i];
1965: for(i=4;i<8;i++) dest[i] = 0;
1966: memcpy((char *)(&s_pin1), dest, 4); /* 012345678 -> "0123" */
1967: for(i=0;i<4;i++) dest[i] = tmpSN[i+2];
1968: for(i=4;i<8;i++) dest[i] = 0;
1969: memcpy((char *)(&s_pin2), dest, 4); /* 012345678 -> "2345" */
1970: for(i=0;i<4;i++) dest[i] = tmpSN[i+5];
1971: for(i=4;i<8;i++) dest[i] = 0;
1972: memcpy((char *)(&s_pin3), dest, 4); /* 012345678 -> "5678" */
1973: } else { /* Intel 386, 486 */
1974: for(i=0;i<4;i++) dest[i] = tmpSN[3-i];
1975: for(i=4;i<8;i++) dest[i] = 0;
1976: memcpy((char *)(&s_pin1), dest, 4); /* 012345678 -> "0123" */
1977: for(i=0;i<4;i++) dest[i] = tmpSN[5-i];
1978: for(i=4;i<8;i++) dest[i] = 0;
1979: memcpy((char *)(&s_pin2), dest, 4); /* 012345678 -> "2345" */
1980: for(i=0;i<4;i++) dest[i] = tmpSN[8-i];
1981: for(i=4;i<8;i++) dest[i] = 0;
1982: memcpy((char *)(&s_pin3), dest, 4); /* 012345678 -> "5678" */
1983: }
1984:
1985:
1986: part1 = s_pin1 + s_pin3+ class_pin2; if(part1 < 0) part1 = part1 * (-1);
1987: part2 = s_pin2 + class_pin1; if(part2 < 0) part2 = part2 * (-1);
1988:
1989: #ifdef SEED_DBG
1990: printf("S_PIN(%d,%d, %d) C_PIN(%d,%d)\n",s_pin1, s_pin2, s_pin3, class_pin1, class_pin2);
1991: printf("SEED(%ld,%ld)\n",part1, part2);
1992: #endif
1993: {
1994: extern void gsrgs(long getset,long *qvalue);
1995: static long qrgnin;
1996: gsrgs(0L,&qrgnin);
1997: if(!qrgnin)
1998: setall(part1, part2);
1999: }
2000: (*seed1) = part1;
2001: (*seed2) = part2;
2002: free(class);
2003: }
2004: /* ======================================================= PIN number */
2005: /* pin should only called once for each student. */
2006: /* if not called at the beginning of problem set, try to call it automatically */
2007:
2008: int /* RETURNS: pin number for login set */
2009: capa_PIN(student_number, set, guess) /* ARGUMENTS: */
2010: char *student_number;
2011: int set; /* Problem set number */
2012: int guess;
2013: { /* LOCALS: */
2014: int current=0, /* Current pin for set */
2015: i,j, /* Array indices */
2016: nope,
2017: correct=0,
2018: all_pins[ONE_K];
2019: long part1, part2;
2020: long orig_gen, new_gen;
2021:
2022: capa_seed(&part1, &part2, student_number);
2023: gscgn(GET_GENERATOR, &orig_gen);
2024: new_gen = PIN_G;
2025: gscgn(SET_GENERATOR, &new_gen);
2026: setsd(part1, part2);
2027: /* Generate 4-digit pin (1000-9999) */
2028: for (i=1; i<=set; i++) {
2029: current=1000+ignlgi()%9000;
2030: do {
2031: nope=0;
2032: for (j=1; j<i; j++) {
2033: if (current == all_pins[j]) {
2034: current=1000+ignlgi()%9000;
2035: nope++;
2036: }
2037: }
2038: } while (nope);
2039: all_pins[i]=current;
2040: if (guess && guess==current) correct=i;
2041: }
2042: gscgn(SET_GENERATOR, &orig_gen);
2043: if (guess) return (correct);
2044: return (current);
2045: }
2046:
2047: /* -------------------------------------------------------------------- */
2048: /* returns a longer pin, the first four characters are the same as the */
2049: /* normal capaId, additionally the result is a capa_malloc string */
2050: /* containing the number */
2051: /* NOTE!-> the result is a string of letters where A=1..I=9,J=0 */
2052: /* -------------------------------------------------------------------- */
2053: char*
2054: capa_id_plus(student_number, set, plus)
2055: char *student_number;
2056: int set;
2057: int plus;
2058: {
2059: long part1,part2,orig_gen,new_gen,pin,rout,k,i;
2060: char *result;
2061: char letters[10]={'J','A','B','C','D','E','F','G','H','I'};
2062: capa_seed(&part1, &part2, student_number);
2063: gscgn(GET_GENERATOR, &orig_gen);
2064: new_gen = PIN_G;
2065: gscgn(SET_GENERATOR, &new_gen);
2066: setsd(part1, part2);
2067: pin=capa_PIN(student_number,set,0);
2068: result=(char *)capa_malloc(sizeof(char), plus+MAX_PIN_CHAR+1);
2069: k=1;
2070: for(i=1;i<=MAX_PIN_CHAR;i++) {
2071: result[MAX_PIN_CHAR-i] = letters[(pin%(k*10))/k];
2072: k*=10;
2073: }
2074: for(i=MAX_PIN_CHAR;i<MAX_PIN_CHAR+plus;i++) {
2075: rout = ignlgi()%10;
2076: result[i] = letters[rout];
2077: }
2078: result[i] = '\0';
2079: gscgn(SET_GENERATOR, &orig_gen);
2080: return result;
2081: }
2082: /* -------------------------------------------------------------------- */
2083: /* need to set problem_p = NULL after this call */
2084: /* -------------------------------------------------------------------- */
2085: void
2086: free_problems(problem_p) Problem_t *problem_p;
2087: {
2088: Problem_t *p, *next;
2089:
2090: for (p=problem_p; p!=NULL ; p=next) {
2091: next=p->next;
2092: if (p->question != NULL) capa_mfree(p->question);
2093: if (p->answer != NULL) capa_mfree(p->answer);
2094: if (p->ans_cnt > 1 ) { AnswerInfo_t *a,*b;
2095: for(a = p->ans_list; a != NULL ; a = b) {
2096: b = a->ans_next;
2097: if (a->ans_str != NULL) capa_mfree(a->ans_str);
2098: if (a->ans_id_list != NULL ) capa_mfree(a->ans_id_list);
2099: if (a->ans_pts_list) {
2100: free_ptslist(a->ans_pts_list);
2101: }
2102: if (a->ans_unit) {
2103: freelist_unit_e(a->ans_unit->u_list);
2104: if (a->ans_unit != NULL) capa_mfree((char *)a->ans_unit);
2105: }
2106: capa_mfree((char *)a);
2107: }
2108: }
2109: if (p->id_list != NULL ) capa_mfree(p->id_list);
2110: if (p->pts_list!= NULL ) {
2111: free_ptslist(p->pts_list);
2112: }
2113: if (p->hint != NULL ) capa_mfree(p->hint);
2114: if (p->explain != NULL ) capa_mfree(p->explain);
2115: if (p->ans_unit !=NULL ) {
2116: freelist_unit_e(p->ans_unit->u_list);
2117: capa_mfree((char *)p->ans_unit);
2118: }
2119: capa_mfree((char *)p);
2120: p=NULL;
2121: }
2122: problem_p=NULL;
2123: }
2124:
2125: /******************************************************************************/
2126: /* PARSE SOURCE FILE AND RETURN BLOCKS OF TEXT */
2127: /******************************************************************************/
2128: int
2129: capa_parse(set,problem,student_number,num_questions,func_ptr)
2130: int set;Problem_t **problem;char *student_number;int *num_questions;
2131: void (*func_ptr)();
2132: {
2133: char filename[QUARTER_K];
2134: int errcode;
2135: FILE *fp;
2136: extern FILE *Input_stream[MAX_OPENED_FILE];
2137: extern char Opened_filename[MAX_OPENED_FILE][QUARTER_K];
2138: extern int Lexi_line;
2139: extern int Lexi_qnum;
2140: extern Problem_t *FirstProblem_p;
2141: extern Problem_t *LastProblem_p;
2142: extern Problem_t *LexiProblem_p;
2143: extern char *StartText_p;
2144: extern char *EndText_p;
2145: extern char *ErrorMsg_p;
2146: extern int ErrorMsg_count;
2147: extern char Parse_class[QUARTER_K];
2148: extern int Parse_section;
2149: extern int Parse_set;
2150: extern char Parse_name[MAX_NAME_CHAR+1];
2151: extern char Parse_student_number[MAX_STUDENT_NUMBER+1];
2152: extern int Symb_count;
2153: extern int first_run;
2154: extern int Stop_Parser;
2155: extern void (*Status_Func)();
1.11 albertel 2156: #ifdef TTH
2157: extern void tth_restart();
2158: extern char* tth_err;
2159: #endif /*TTH*/
1.1 albertel 2160: long seed1, seed2;
2161: T_student a_student;
2162: char *class, *classname, warn_msg[WARN_MSG_LENGTH];
2163: #if defined(NeXT)
2164: char cwd[FILE_NAME_LENGTH];
2165:
2166: class = getwd(cwd);
2167: if( class == NULL ) { class = cwd; }
2168: #else
2169: class = getcwd(NULL,255);
2170:
2171: #endif
2172:
2173: if(class == NULL) { /* printf("capa_parse(): Current working directory unknown!"); */ return (-1); }
2174: classname = rindex(class,'/'); classname++; /*** hpux complained */
2175: sprintf(Parse_class,"%s", classname);
2176: free(class);
2177: if( capa_get_student(student_number, &a_student) < 1 ) {
2178: /*printf("Error: capa_parse() encountered a student which is not in classl file\n"); */
2179: return (-1);
2180: }
2181: sprintf(filename,"capa.config");
2182: if ((fp=fopen(filename,"r"))==NULL) {
2183: /* printf("Error: can't open %s\n",filename);*/
2184: return (-1);
2185: }
2186: u_getunit(fp);
2187: fclose(fp);
1.11 albertel 2188: #ifdef TTH
2189: if(tth_err) { free(tth_err); tth_err=NULL; }
2190: tth_restart();
2191: #endif /*TTH*/
1.1 albertel 2192: strncpy(Parse_name,a_student.s_nm,MAX_NAME_CHAR+1);
2193: strncpy(Parse_student_number,student_number,MAX_STUDENT_NUMBER+1);
2194: Parse_section = a_student.s_sec;
2195: if(ErrorMsg_p) { capa_mfree(ErrorMsg_p); ErrorMsg_p = NULL; }
2196: if(EndText_p) { capa_mfree(EndText_p); EndText_p = NULL; }
2197: if(StartText_p) { capa_mfree(StartText_p); StartText_p = NULL; }
2198: ErrorMsg_p = NULL; first_run = 1; EndText_p = NULL;
2199: free_symtree(); Symb_count = ErrorMsg_count = Lexi_line = Lexi_qnum = 0;
2200: FirstProblem_p = LastProblem_p = NULL;
2201: LexiProblem_p = (Problem_t *)capa_malloc(sizeof(Problem_t),1);
2202: problem_default(LexiProblem_p);
2203: /*LexiProblem_p->capaidplus=NULL;*/
2204: Parse_set = set;
2205: Status_Func=func_ptr;
2206: sprintf(filename,"set%d.qz",set);
2207: #ifdef AVOIDYYINPUT
2208: yyin=fopen(filename,"r");
2209: #else
2210: if ( (Input_stream[0]=fopen(filename,"r")) == NULL) {
2211: /* printf("Error: can't open %s\n",filename);*/
2212: sprintf(warn_msg,"capa_parse(): CANNOT OPEN FILE\"%s\", file does not exist or is not readable.\n", filename);
2213: capa_msg(MESSAGE_ERROR,warn_msg);
2214: return (-1);
2215: }
2216: #endif
2217: sprintf(Opened_filename[0],"%s",filename);
2218:
2219: capa_seed(&seed1, &seed2, student_number); setall(seed1,seed2);
2220:
2221: yyrestart(yyin);
2222: Stop_Parser=0;
2223: if ( !yyparse() ) { errcode = Lexi_qnum; } else { errcode = 0; }
2224: /* fclose(Input_stream[0]);*/ /* The Lexer handles closing this */
2225: /* print_symb_stat(); */
2226: free_symtree();
2227: /*
2228: capa_mfree((char *)LexiProblem_p);
2229: LexiProblem_p = NULL;
2230: */
2231: (*problem) = FirstProblem_p;
2232: (*num_questions) = Lexi_qnum;
2233: return (errcode);
2234: }
2235:
2236: /******************************************************************************/
2237: /* PARSE SOURCE FILE AND RETURN BLOCKS OF TEXT, unlike capa_parse_student */
2238: /******************************************************************************/
2239: int
2240: capa_parse_student(set,problem,a_student,num_questions,func_ptr)
2241: int set;Problem_t **problem;T_student *a_student;int *num_questions;
2242: void (*func_ptr)();
2243: {
2244: char filename[QUARTER_K];
2245: int errcode;
2246: FILE *fp;
2247: extern FILE *Input_stream[MAX_OPENED_FILE];
2248: extern char Opened_filename[MAX_OPENED_FILE][QUARTER_K];
2249: extern int Lexi_line;
2250: extern int Lexi_qnum;
2251: extern Problem_t *FirstProblem_p;
2252: extern Problem_t *LastProblem_p;
2253: extern Problem_t *LexiProblem_p;
2254: extern char *StartText_p;
2255: extern char *EndText_p;
2256: extern char *ErrorMsg_p;
2257: extern int ErrorMsg_count;
2258: extern char Parse_class[QUARTER_K];
2259: extern int Parse_section;
2260: extern int Parse_set;
2261: extern char Parse_name[MAX_NAME_CHAR+1];
2262: extern char Parse_student_number[MAX_STUDENT_NUMBER+1];
2263: extern int Symb_count;
2264: extern int first_run;
2265: extern void (*Status_Func)();
2266: long seed1, seed2;
2267: char *class, *classname, warn_msg[WARN_MSG_LENGTH];
2268:
2269: #if defined(NeXT)
2270: char cwd[FILE_NAME_LENGTH];
2271:
2272: class = getwd(cwd);
2273: if( class == NULL ) { class = cwd; }
2274: #else
2275: class = getcwd(NULL,255);
2276:
2277: #endif
2278:
2279: if(class == NULL) { /* printf("capa_parse(): Current working directory unknown!"); */ return (-1); }
2280: classname = rindex(class,'/'); classname++; /*** hpux complained */
2281: sprintf(Parse_class,"%s", classname);
2282: free(class);
2283:
2284: sprintf(filename,"capa.config");
2285: if ((fp=fopen(filename,"r"))==NULL) {
2286: /* printf("Error: can't open %s\n",filename);*/
2287: sprintf(warn_msg,"capa_parse(): CANNOT OPEN FILE\"%s\", file does not exist or is not readable.\n", filename);
2288: capa_msg(MESSAGE_ERROR,warn_msg);
2289: return (-1);
2290: }
2291: u_getunit(fp);
2292: fclose(fp);
2293: strncpy(Parse_name,a_student->s_nm,MAX_NAME_CHAR+1);
2294: strncpy(Parse_student_number,a_student->s_sn,MAX_STUDENT_NUMBER+1);
2295: Parse_section = a_student->s_sec;
2296: if(ErrorMsg_p) { capa_mfree(ErrorMsg_p); ErrorMsg_p = NULL; }
2297: if(EndText_p) { capa_mfree(EndText_p); EndText_p = NULL; }
2298: if(StartText_p) { capa_mfree(StartText_p); StartText_p = NULL; }
2299: ErrorMsg_p = NULL; first_run = 1; EndText_p = NULL;
2300: free_symtree(); Symb_count = ErrorMsg_count = Lexi_line = Lexi_qnum = 0;
2301: FirstProblem_p = LastProblem_p = NULL;
2302: LexiProblem_p = (Problem_t *)capa_malloc(sizeof(Problem_t),1);
2303: problem_default(LexiProblem_p);
2304: /*LexiProblem_p->capaidplus=NULL;*/
2305: Parse_set = set;
2306: Status_Func=func_ptr;
2307: sprintf(filename,"set%d.qz",set);
2308: #ifdef AVOIDYYINPUT
2309: yyin=fopen(filename,"r");
2310: #else
2311: if ( (Input_stream[0]=fopen(filename,"r")) == NULL) {
2312: /* printf("Error: can't open %s\n",filename);*/
2313: sprintf(warn_msg,"capa_parse(): CANNOT OPEN FILE\"%s\", file does not exist or is not readable.\n", filename);
2314: capa_msg(MESSAGE_ERROR,warn_msg);
2315: return (-1);
2316: }
2317: #endif
2318: sprintf(Opened_filename[0],"%s",filename);
2319:
2320: capa_seed(&seed1, &seed2, a_student->s_sn); setall(seed1,seed2);
2321:
2322: yyrestart(yyin);
2323: if ( !yyparse() ) { errcode = Lexi_qnum; } else { errcode = 0; }
2324: /* fclose(Input_stream[0]);*/ /*The Lexer handles closing this*/
2325: /* print_symb_stat(); */
2326: free_symtree();
2327: /*
2328: capa_mfree((char *)LexiProblem_p);
2329: LexiProblem_p = NULL;
2330: */
2331: (*problem) = FirstProblem_p;
2332: (*num_questions) = Lexi_qnum;
2333: return (errcode);
2334: }
2335:
2336: /* =================================================================== */
2337: /* A utility method to convert a date string and time string to time_t */
2338: /* dateStr: yyyy/mm/dd */
2339: /* timeStr: hh:mm */
2340: time_t
2341: convertTime(dateStr,timeStr)char *dateStr; char *timeStr;
2342: {
2343: struct tm *theTimeData;
2344: time_t result;
2345: int dateTime[5];
2346: int year, month, day, mm, hh;
2347:
2348: sscanf(dateStr,"%4d/%2d/%2d",&year,&month,&day);
2349: dateTime[0] = month;
2350: dateTime[1] = day;
2351: dateTime[2] = year;
2352: sscanf(timeStr,"%2d:%2d",&hh,&mm);
2353: dateTime[3] = hh;
2354: dateTime[4] = mm;
2355: result = time(NULL);
2356: theTimeData = localtime(&result);
2357: theTimeData->tm_sec = 0;
2358: theTimeData->tm_min = dateTime[4];
2359: theTimeData->tm_hour = dateTime[3];
2360: theTimeData->tm_mday = dateTime[1];
2361: theTimeData->tm_mon = dateTime[0]-1;
2362: theTimeData->tm_year = dateTime[2]-1900;/* tm_year is years since 1900 */
2363: /* these fields are ignored by mktime
2364: theTimeData->tm_wday = weekday(year,month,day);
2365: theTimeData->tm_yday = julianday(year,month,day);
2366: */
2367: result = mktime( theTimeData );
2368: return (result);
2369: }
2370:
2371: int
2372: weekday( year, month, day) int year; int month; int day;
2373: {
2374: register int dow;
2375: #if defined(hpux)
2376: int juldays[13];
2377: juldays[0]=0;juldays[1]=0;juldays[2]=31;juldays[3]=59;
2378: juldays[4]=90;juldays[5]=120;juldays[6]=151;juldays[7]=181;
2379: juldays[8]=212;juldays[9]=243;juldays[10]=273;juldays[11]=304;juldays[12]=334;
2380: #else
2381: int juldays[13] = {0, 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334};
2382: #endif
2383:
2384: dow = 7 + year + year/4 - year/100 + year/400 + juldays[month] + day;
2385: if( (month < 3) && ( leap_year(year) ) ) dow--;
2386: dow %= 7;
2387: return (dow);
2388: } /* weekday */
2389:
2390: int
2391: julianday( year, month, day)int year;int month;int day;
2392: {
2393: register int doy;
2394: #if defined(hpux)
2395: int juldays[13];
2396: juldays[0]=0;juldays[1]=0;juldays[2]=31;juldays[3]=59;
2397: juldays[4]=90;juldays[5]=120;juldays[6]=151;juldays[7]=181;
2398: juldays[8]=212;juldays[9]=243;juldays[10]=273;juldays[11]=304;juldays[12]=334;
2399: #else
2400: int juldays[13] = {0, 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334};
2401: #endif
2402:
2403: doy = juldays[month];
2404: if((month > 2) && (leap_year(year)) ) doy++;
2405: doy += day;
2406: return (doy);
2407: } /* julianday */
2408:
2409: int
2410: check_int( an_int ) char *an_int;
2411: {
2412: int ii, leng;
2413: int result=0;
2414:
2415: if( (an_int[0] == '-') || (an_int[0]== '+') ) an_int++;
2416: leng = strlen(an_int);
2417: for(ii=0;ii<leng;ii++) {
2418: if( !isdigit(an_int[ii]) ) result = 1;
2419: }
2420: return (result);
2421: }
2422: /* --------------------------- */
2423: /* 0 OK , 1 NOT a real number */
2424: int
2425: check_real( a_real ) char *a_real;
2426: {
2427: int ii, leng;
2428: int result=0;
2429:
2430: if( (a_real[0] == '-') || (a_real[0]== '+') ) a_real++;
2431: leng = strlen(a_real);
2432: for(ii=0;ii<leng;ii++) {
2433: if( (!isdigit(a_real[ii])) && (a_real[ii]!='e') && (a_real[ii]!='E') &&
2434: (a_real[ii]!='.') && (a_real[ii]!='+') && (a_real[ii]!='-') ) result = 1;
2435: }
2436: return (result);
2437: }
2438:
2439: int
2440: check_input_usymb(u_symb)char *u_symb;
2441: {
2442: int result=0;
2443:
2444:
2445: return (result);
2446: }
2447:
2448: /* <== This routine determine emperically where to split a character */
2449: /* string into two portions, one for numerical answer and the */
2450: /* other for units */
2451: /* ----------------------------------------------------------------- */
2452: /* inputs : buf : answer string */
2453: /* outputs: num : the numerical part */
2454: /* num_p : the numerical part in string */
2455: /* unit_p : the unit string */
2456: /* num_p is used to calculate sig figs */
2457: /* return : 0 empty string */
2458: /* 1 number without units */
2459: /* 2 empty number with units */
2460: /* 3 number with units */
2461: /* */
2462: int split_num_unit(buf,num,num_p,unit_p)
2463: char *buf;double *num; char *num_p; char *unit_p;
2464: {
2465: char num_str[ANSWER_STRING_LENG], unit_str[ANSWER_STRING_LENG];
2466: char base_str[ANSWER_STRING_LENG], exp_str[ANSWER_STRING_LENG];
2467: int idx=0, errcode=0;
2468: int len, ii, n_idx=0, b_idx=0, e_idx=0, u_idx=0;
2469: double n_part, x_part, b_part, e_part, result;
2470:
2471: unit_str[0]=0; /* initialize unit_str[] */
2472: len = strlen(buf);
2473: while( isspace(buf[idx]) ) { idx++; } /* ignore white spaces */
2474: num_str[n_idx]=0; /* initialize number string */
2475: if( buf[idx] == '+' || buf[idx] == '-' ) {
2476: /* the first char is either '+' or '-' */
2477: num_str[n_idx++]= buf[idx++];
2478: }
2479: /* skip over alphabet char and those that are not '.' */
2480: while( (!isdigit( buf[idx] )) && buf[idx] != '.' ) { idx++; }
2481: while( isdigit( buf[idx] ) || buf[idx] == '.' ) { /* collect decimal numbers */
2482: num_str[n_idx++]= buf[idx++];
2483: }
2484: num_str[n_idx] = 0; /* end the string with a '\0' */
2485: sprintf(num_p,"%s",num_str); /* put the collected numerical string in num_p */
2486: /* skip over white spaces */
2487: while( isspace(buf[idx]) ) { idx++; }
2488: if( buf[idx] == 'e' || buf[idx] == 'E' ) { /* optional e or E part */
2489: /* peek further one char to see if it belongs to one of the following */
2490: if( buf[idx+1] == '-' || buf[idx+1] == '+' || isspace(buf[idx+1]) || isdigit(buf[idx+1])) {
2491: num_str[n_idx++] = buf[idx++]; /* should be 'e' or 'E' */
2492: while( isspace(buf[idx]) ) { idx++; } /* skip over spaces */
2493: num_str[n_idx++] = buf[idx++]; /* the second char '-', '+' or digit */
2494: while( isdigit(buf[idx]) ) { /* only integer is allowed, not '.' */
2495: num_str[n_idx++] = buf[idx++];
2496: }
2497: }
2498: num_str[n_idx] = 0; /* terminiate the numerical string */
2499: while( isspace(buf[idx]) ) { idx++; }
2500: sscanf(num_str, "%lg", &result); /* put the numerical value into a double variable */
2501: errcode = errcode | 1;
2502: } else if( buf[idx] == 'x' || buf[idx] == 'X') { /* optional x or X part */
2503: idx++; /* skip x or X */
2504: while( isspace(buf[idx]) ) { idx++; }
2505:
2506: e_part = 1.0; /* default power */
2507: base_str[b_idx] = 0; /* initialize base_str[] */
2508: while( isdigit(buf[idx]) || buf[idx] == '.' ) { /* should start with a digit or . */
2509: base_str[b_idx++] = buf[idx++];
2510: }
2511: base_str[b_idx] = 0; /* terminate base_str[] */
2512: while( isspace(buf[idx]) ) { idx++; } /* skip over white spaces */
2513: if( buf[idx] == '^' ) { /* power */
2514: idx++;
2515: exp_str[e_idx] = 0; /* initialize exp_str[] */
2516: while( isspace(buf[idx]) ) { idx++; }
2517: if( buf[idx] == '{'|| buf[idx] == '(' ) { /* matching right bracket */
2518: idx++;
2519: }
2520: while( isspace(buf[idx]) ) { idx++; }
2521: if( isdigit(buf[idx]) || buf[idx] == '+' || buf[idx] == '-' ) {
2522: exp_str[e_idx] = 0; /* initialize exp_str[], again */
2523: while( isdigit(buf[idx]) || buf[idx] == '.' || buf[idx] == '+' || buf[idx] == '-' ) {
2524: exp_str[e_idx++] = buf[idx++];
2525: }
2526: exp_str[e_idx] = 0; /* terminate exp_str[] */
2527: }
2528: while( isspace(buf[idx]) ) { idx++; }
2529: if( buf[idx] == '}' || buf[idx] == ')' ) {
2530: idx++;
2531: }
2532: sscanf(exp_str, "%lg", &e_part);
2533: }
2534: if( strlen(base_str) > 0 ) {
2535: sscanf(base_str, "%lg", &b_part);
2536: x_part = pow(b_part, e_part);
2537: } else {
2538: x_part = 0.0;
2539: }
2540: if( strlen(num_str) > 0 ) {
2541: sscanf(num_str, "%lg", &n_part);
2542: } else {
2543: n_part=0.0;
2544: }
2545: result = n_part * x_part;
2546: errcode = errcode | 1;
2547: } else if ( buf[idx] == '^' ) { /* number ^ */
2548: idx++;
2549: e_part = 1.0;
2550: while( isspace(buf[idx]) ) { idx++; }
2551: if( buf[idx] == '{'|| buf[idx] == '(' ) { /* matching right bracket */
2552: idx++;
2553: }
2554: while( isspace(buf[idx]) ) { idx++; }
2555: if( isdigit(buf[idx]) || buf[idx] == '+' || buf[idx] == '-' ) {
2556: exp_str[e_idx] = 0;
2557: while( isdigit(buf[idx]) || buf[idx] == '.' || buf[idx] == '+' || buf[idx] == '-' ) {
2558: exp_str[e_idx++] = buf[idx++];
2559: }
2560: exp_str[e_idx] = 0;
2561: }
2562: while( isspace(buf[idx]) ) { idx++; }
2563: if( buf[idx] == '}' || buf[idx] == ')' ) {
2564: idx++;
2565: }
2566: sscanf(exp_str, "%lg", &e_part);
2567: sscanf(num_str, "%lg", &n_part);
2568: result = pow(n_part,e_part);
2569: errcode = errcode | 1;
2570: } else { /* number unit */
2571: if( strlen(num_str) > 0 ) {
2572: sscanf(num_str, "%lg", &result);
2573: errcode = errcode | 1;
2574: }
2575: }
2576:
2577: if( idx < len ) { /* collect the rest as unit string */
2578: for(ii=idx;ii< len; ii++ ) {
2579:
2580: unit_str[u_idx++] = buf[ii];
2581: }
2582: unit_str[u_idx]=0; /* terminate unit_str[] */
2583: if(u_idx>0) {
2584: errcode = errcode | 2;
2585: }
2586: }
2587: if( strlen(num_str) > 0 ) {
2588: *num = result;
2589: } else { /* empty number string */
2590: *num = 0.0;
2591: }
2592: sprintf(unit_p,"%s", unit_str);
2593: return (errcode);
2594: }
2595:
2596: char *
2597: answers_string(mode, p)int mode;Problem_t *p;
2598: {
2599: char *fmted_ans, lower[ANSWER_STRING_LENG], upper[ANSWER_STRING_LENG];
2600: char *str_aa, *str_bb, *str_cc, *ans_str, *sub_ans_str, *tmp_str;
2601: int len_aa=0, len_bb=0, len_cc=0,len_dd=0, total_len, num_answer;
2602: double d_answer;
2603:
2604: if( p->ans_type == ANSWER_IS_SUBJECTIVE ) {
2605: char *a="Subjective Answer\n";
2606: ans_str = (char *)capa_malloc(strlen(a)+1,1);
2607: strcpy(ans_str,a);
2608: return (ans_str);
2609: }
2610: num_answer = calc_ansrange(p->ans_type,p->calc, p->answer, p->ans_fmt, p->tol_type,
2611: p->tolerance, lower, upper);
2612:
2613: if( p->ans_type == ANSWER_IS_FLOAT ) {
2614: fmted_ans = capa_malloc(SMALL_LINE_BUFFER,1);
2615: d_answer = (double)atof(p->answer);
2616: sprintf(fmted_ans,p->ans_fmt,d_answer);
2617: } else {
2618: fmted_ans = capa_malloc(strlen(p->answer)+2,1);
2619: strcpy(fmted_ans,p->answer);
2620: }
2621:
2622: len_aa = strlen(fmted_ans);
2623: if (lower != NULL ) len_bb = strlen(lower); else len_bb = 0;
2624: if (upper != NULL ) len_cc = strlen(upper); else len_cc = 0;
2625: if ( p->unit_str != NULL ) len_dd = strlen(p->unit_str); else len_dd = 0;
2626:
2627: switch(mode) {
2628: case TeX_MODE:
2629: if(num_answer==2) {
2630: /* 16 is by adding up characters ' [,] \n\n' and others */
2631: str_aa = format_toTeX(fmted_ans);
2632: total_len = strlen(str_aa) + len_dd + 16;
2633: str_bb = format_toTeX(lower);
2634: total_len += strlen(str_bb);
2635: str_cc = format_toTeX(upper);
2636: total_len += strlen(str_cc);
2637: ans_str = (char *)capa_malloc(total_len,1);
2638: if(len_dd == 0 ) { /* no unit_str */
2639: sprintf(ans_str," %s [%s,%s]\n\n", str_aa,str_bb,str_cc);
2640: } else {
2641: sprintf(ans_str," %s [%s,%s] $%s$\n\n", str_aa,str_bb,str_cc,p->unit_str);
2642: }
2643: capa_mfree((char *)str_aa);
2644: capa_mfree((char *)str_bb);
2645: capa_mfree((char *)str_cc);
2646: } else { /* only one answer */
2647: if ( (p->ans_type == ANSWER_IS_INTEGER) ||
2648: (p->ans_type == ANSWER_IS_FLOAT )) {
2649: str_bb = format_toTeX(lower);
2650: } else { /* answer could be string, choice */
2651: str_bb = (char *)capa_malloc(strlen(lower)+MAX_BUFFER_SIZE,1);
1.10 albertel 2652: if (p->verbatim == DO_VERBATIM)
1.1 albertel 2653: sprintf(str_bb,"\\begin{verbatim}%s\\end{verbatim}",lower);
2654: else
2655: strcpy(str_bb,lower);
2656: }
2657: total_len = strlen(str_bb) + len_dd + 8;
2658: /* 4 is by adding up characters ' \\\n' plus four */
2659: ans_str = (char *)capa_malloc(sizeof(char),total_len);
2660: if(len_dd == 0 ) { /* no unit_str */
2661: sprintf(ans_str," %s\n", str_bb);
2662: } else {
2663: sprintf(ans_str," %s $%s$\n", str_bb,p->unit_str);
2664: }
2665: capa_mfree((char *)str_bb);
2666: }
2667: break;
2668: case ASCII_MODE:
2669: total_len = len_aa + len_bb + len_cc + len_dd + 8;
2670: /* 8 is by adding up characters ' [,] \n\n' plus one */
2671: ans_str = (char *)capa_malloc(sizeof(char),total_len);
2672: if(num_answer==2) {
2673: if(len_dd == 0 ) { /* no unit_str */
2674: sprintf(ans_str,"%s [%s,%s]\n\n", fmted_ans,lower,upper);
2675: } else {
2676: sprintf(ans_str,"%s [%s,%s] %s\n\n", fmted_ans,lower,upper,p->unit_str);
2677: }
2678: } else {
2679: if(len_dd == 0 ) { /* no unit_str */
2680: sprintf(ans_str,"%s\n\n", lower);
2681: } else {
2682: sprintf(ans_str,"%s %s\n\n", lower,p->unit_str);
2683: }
2684: }
2685: break;
2686: case ANSWER_STRING_MODE:
2687: total_len = len_aa + len_bb + len_cc + len_dd + 8;
2688: /* 8 is by adding up characters ' [,] \n\n' plus one */
2689: ans_str = (char *)capa_malloc(sizeof(char),total_len);
2690: if(num_answer==2) {
2691: if(len_dd == 0 ) { /* no unit_str */
2692: sprintf(ans_str,"%s", fmted_ans);
2693: } else {
2694: sprintf(ans_str,"%s %s", fmted_ans,p->unit_str);
2695: }
2696: } else {
2697: if(len_dd == 0 ) { /* no unit_str */
2698: sprintf(ans_str,"%s", lower);
2699: } else {
2700: sprintf(ans_str,"%s %s", lower,p->unit_str);
2701: }
2702: }
2703: break;
2704: case HTML_MODE:
2705: if(num_answer==2) { /* this indicates that answer should be either float or int
2706: */
2707: str_aa = format_toHTML(fmted_ans);
2708: total_len = strlen(str_aa) + len_dd + 8;
2709: str_bb = format_toHTML(lower);
2710: total_len += strlen(str_bb);
2711: str_cc = format_toHTML(upper);
2712: total_len += strlen(str_cc);
2713: /* 8 is by adding up characters ' [,] \n\n' plus one */
2714: ans_str = (char *)capa_malloc(sizeof(char),total_len);
2715: if(len_dd == 0 ) { /* no unit_str */
2716: sprintf(ans_str,"%s [%s,%s]\n\n", str_aa,str_bb,str_cc);
2717: } else {
2718: sprintf(ans_str,"%s [%s,%s] %s\n\n", str_aa,str_bb,str_cc,p->unit_str);
2719: }
2720: capa_mfree((char *)str_aa); capa_mfree((char *)str_bb); capa_mfree((char
2721: *)str_cc);
2722: } else {
2723: if ( (p->ans_type == ANSWER_IS_INTEGER) ||
2724: (p->ans_type == ANSWER_IS_FLOAT )) {
2725: str_bb = format_toHTML(lower);
2726: } else { /* answer could be string, choice */
2727: str_bb = (char *)capa_malloc(strlen(lower)+MAX_BUFFER_SIZE,1);
2728: if (p->ans_type == ANSWER_IS_FORMULA || 1)
2729: sprintf(str_bb,"<PRE>\n%s\n</PRE>",lower);
2730: else
2731: strcpy(str_bb,lower);
2732: }
2733: total_len = strlen(str_bb) + len_dd + 4;
2734: /* 4 is by adding up characters ' \n\n' plus one */
2735: ans_str = (char *)capa_malloc(sizeof(char),total_len);
2736: if(len_dd == 0 ) { /* no unit_str */
2737: sprintf(ans_str,"%s\n\n", str_bb);
2738: } else {
2739: sprintf(ans_str,"%s %s\n\n", str_bb,p->unit_str);
2740: }
2741: capa_mfree((char *)str_bb);
2742: }
2743: break;
2744: }
2745: capa_mfree(fmted_ans);
2746:
2747: if( p->ans_cnt > 1 ) {
2748: AnswerInfo_t *ai;
2749: for( ai = p->ans_list; ai; ai = ai->ans_next) {
2750: num_answer = calc_ansrange(ai->ans_type,ai->ans_calc, ai->ans_str, ai->ans_fmt,
2751: ai->ans_tol_type,ai->ans_tol,lower,upper);
2752: if( ai->ans_type == ANSWER_IS_FLOAT ) {
2753: fmted_ans = capa_malloc(SMALL_LINE_BUFFER,1);
2754: d_answer = (double)atof(ai->ans_str);
2755: sprintf(fmted_ans,ai->ans_fmt,d_answer);
2756: } else {
2757: fmted_ans = capa_malloc(strlen(ai->ans_str)+2,1);
2758: strcpy(fmted_ans,ai->ans_str);
2759: }
2760: len_aa = strlen(fmted_ans);
2761: len_bb = strlen(lower);
2762: len_cc = strlen(upper);
2763: len_dd = strlen(ai->ans_unit_str);
2764: switch(mode) {
2765: case TeX_MODE:
2766: if(num_answer==2) {
2767: /* 16 is by adding up characters ' [,] \n\n' and others */
2768:
2769: str_aa = format_toTeX(fmted_ans);
2770: total_len = strlen(str_aa) + len_dd + 16;
2771: str_bb = format_toTeX(lower);
2772: total_len += strlen(str_bb);
2773: str_cc = format_toTeX(upper);
2774: total_len += strlen(str_cc);
2775:
2776: sub_ans_str = (char *)capa_malloc(sizeof(char),total_len);
2777:
2778: if(len_dd == 0 ) { /* no unit_str */
2779: sprintf(sub_ans_str," %s [%s,%s]\n\n", str_aa,str_bb,str_cc);
2780: } else {
2781: sprintf(sub_ans_str," %s [%s,%s] $%s$\n\n",
2782: str_aa,str_bb,str_cc,ai->ans_unit_str);
2783: }
2784: capa_mfree((char *)str_aa); capa_mfree((char *)str_bb); capa_mfree((char *)str_cc);
2785: } else { /* only one answer */
2786: if ( (ai->ans_type == ANSWER_IS_INTEGER) ||
2787: (ai->ans_type == ANSWER_IS_FLOAT )) {
2788: str_bb = format_toTeX(lower);
2789: } else { /* answer could be string, choice */
2790: str_bb = (char *)capa_malloc(strlen(lower)+MAX_BUFFER_SIZE,1);
2791: if (ai->ans_type == ANSWER_IS_FORMULA || 1)
2792: sprintf(str_bb,"\\begin{verbatim}%s\\end{verbatim}",lower);
2793: else
2794: strcpy(str_bb,lower);
2795: }
2796: total_len = strlen(str_bb) + len_dd + 8;
2797: /* 4 is by adding up characters ' \\\n' plus four */
2798: sub_ans_str = (char *)capa_malloc(sizeof(char),total_len);
2799: if(len_dd == 0 ) { /* no unit_str */
2800: sprintf(sub_ans_str," %s\n", str_bb);
2801: } else {
2802: sprintf(sub_ans_str," %s $%s$\n", str_bb,ai->ans_unit_str);
2803: }
2804: capa_mfree((char *)str_bb);
2805: }
2806: break;
2807: case ASCII_MODE:
2808: total_len = len_aa + len_bb + len_cc + len_dd + 8;
2809: /* 8 is by adding up characters ' [,] \n\n' plus one */
2810: sub_ans_str = (char *)capa_malloc(sizeof(char),total_len);
2811: if(num_answer==2) {
2812: if(len_dd == 0 ) { /* no unit_str */
2813: sprintf(sub_ans_str,"%s [%s,%s]\n\n", fmted_ans,lower,upper);
2814: } else {
2815: sprintf(sub_ans_str,"%s [%s,%s] %s\n\n",
2816: fmted_ans,lower,upper,ai->ans_unit_str);
2817: }
2818: } else {
2819: if(len_dd == 0 ) { /* no unit_str */
2820: sprintf(sub_ans_str,"%s\n\n", lower);
2821: } else {
2822: sprintf(sub_ans_str,"%s %s\n\n", lower,ai->ans_unit_str);
2823: }
2824: }
2825: break;
2826: case ANSWER_STRING_MODE:
2827: total_len = len_aa + len_bb + len_cc + len_dd + 8;
2828: /* 8 is by adding up characters ' [,] \n\n' plus one */
2829: sub_ans_str = (char *)capa_malloc(sizeof(char),total_len);
2830: if(num_answer==2) {
2831: if(len_dd == 0 ) { /* no unit_str */
2832: sprintf(sub_ans_str,", %s", fmted_ans);
2833: } else {
2834: sprintf(sub_ans_str,", %s %s", fmted_ans,ai->ans_unit_str);
2835: }
2836: } else {
2837: if(len_dd == 0 ) { /* no unit_str */
2838: sprintf(sub_ans_str,", %s", lower);
2839: } else {
2840: sprintf(sub_ans_str,", %s %s", lower,ai->ans_unit_str);
2841: }
2842: }
2843: break;
2844: case HTML_MODE:
2845: if(num_answer==2) {
2846: str_aa = format_toHTML(fmted_ans);
2847: total_len = strlen(str_aa) + len_dd + 8;
2848: str_bb = format_toHTML(lower);
2849: total_len += strlen(str_bb);
2850: str_cc = format_toHTML(upper);
2851: total_len += strlen(str_cc);
2852: /* 8 is by adding up characters ' [,] \n\n' plus one */
2853: sub_ans_str = (char *)capa_malloc(sizeof(char),total_len);
2854: if(len_dd == 0 ) { /* no unit_str */
2855: sprintf(sub_ans_str,"%s [%s,%s]\n\n", str_aa,str_bb,str_cc);
2856: } else {
2857: sprintf(sub_ans_str,"%s [%s,%s] %s\n\n",
2858: str_aa,str_bb,str_cc,ai->ans_unit_str);
2859: }
2860: capa_mfree((char *)str_aa); capa_mfree((char *)str_bb); capa_mfree((char
2861: *)str_cc);
2862: } else {
2863: if ( (ai->ans_type == ANSWER_IS_INTEGER) ||
2864: (ai->ans_type == ANSWER_IS_FLOAT )) {
2865: str_bb = format_toHTML(lower);
2866: } else { /* answer could be string, choice */
2867: str_bb = (char *)capa_malloc(strlen(lower)+MAX_BUFFER_SIZE,1);
2868: if (ai->ans_type == ANSWER_IS_FORMULA || 1)
2869: sprintf(str_bb,"<PRE>\n%s\n</PRE>",lower);
2870: else
2871: strcpy(str_bb,lower);
2872: }
2873: total_len = strlen(str_bb) + len_dd + 4;
2874: /* 4 is by adding up characters ' \n\n' plus one */
2875: sub_ans_str = (char *)capa_malloc(sizeof(char),total_len);
2876: if(len_dd == 0 ) { /* no unit_str */
2877: sprintf(sub_ans_str,"%s\n\n", str_bb);
2878: } else {
2879: sprintf(sub_ans_str,"%s %s\n\n", str_bb,ai->ans_unit_str);
2880: }
2881: capa_mfree((char *)str_bb);
2882: }
2883: break;
2884: } /* end of switch */
2885: total_len = strlen(ans_str);
2886: total_len += (strlen(sub_ans_str) + 1);
2887: tmp_str = (char *)capa_malloc(sizeof(char),total_len);
2888: strncpy(tmp_str, ans_str, strlen(ans_str)+1);
2889: strcat(tmp_str, sub_ans_str);
2890: capa_mfree(ans_str); capa_mfree(sub_ans_str);
2891: capa_mfree(fmted_ans);
2892: ans_str = tmp_str;
2893: } /* end of for */
2894: } /* end of if */
2895:
2896: return (ans_str); /* the calling routing needs to deallocate it */
2897: }
2898:
2899:
2900:
2901: /* ------------------------------ called from capalogin */
2902: /* impose stronger checking on the user input string *answer */
2903: /* */
2904:
2905: /* <== This routine checks user input string *ans against correct answer *s ==> */
2906: int
1.10 albertel 2907: capa_check_ans(ai,ans, error) AnswerInfo_t *ai; char *ans; char **error;
1.1 albertel 2908: {
2909: int t; /* ans_type */
2910: char *s; /* ans_str */
2911: int c; /* ans_calc */
2912: int tt; /* ans_tol_type */
2913: double to; /* ans_tol */
2914: int su; /* ans_sig_ub */
2915: int sl; /* ans_sig_lb */
2916: char *fm; /* ans_fmt */
2917: char *us; /* ans_unit_str */
2918: Unit_t *u_p; /* ans_unit */
2919: int input_len, all_alphabet = 1, idx, ii, type;
2920: int outcome, result = INCORRECT;
2921: int sig, corr_len;
2922: int choice[ANSWER_STRING_LENG];
2923: char num_str[ANSWER_STRING_LENG], unit_str[ANSWER_STRING_LENG];
2924: char fmted[ANSWER_STRING_LENG], correct[ANSWER_STRING_LENG], answer[ANSWER_STRING_LENG];
2925: double n_part;
2926: double given, target, ratio, fmted_target, target_u, target_l, scale=1.0;
2927: double delta;
2928:
2929: t = ai->ans_type; s = ai->ans_str; c = ai->ans_calc;
2930: tt = ai->ans_tol_type; to = ai->ans_tol;
2931: su = ai->ans_sig_ub; sl = ai->ans_sig_lb;
2932: fm = ai->ans_fmt;
2933: us = ai->ans_unit_str; u_p = ai->ans_unit;
2934:
2935: switch(t) {
2936: case ANSWER_IS_INTEGER:
2937: case ANSWER_IS_FLOAT:
2938: {
2939: input_len = strlen(ans);
2940: all_alphabet = 1;
2941: for(idx=0;idx<input_len;idx++) {
2942: if( isdigit(ans[idx]) ) {
2943: all_alphabet = 0;
2944: }
2945: }
2946: if( !all_alphabet ) { /* answer string is not all alphabets */
2947: outcome = split_num_unit(ans,&n_part,num_str,unit_str);
2948: if( outcome > 1 ) { /* with both num and unit parts or only unit part */
2949: if( u_p != NULL ) {
1.10 albertel 2950: if (UNIT_FAIL == (result = check_correct_unit(unit_str,u_p,&scale))) {
2951: *error=strsave(unit_str);
2952: }
1.1 albertel 2953: } else { /* what to do when no unit is specified but student entered a unit? */
2954: result = UNIT_NOTNEEDED;
1.10 albertel 2955: *error=strsave(unit_str);
1.1 albertel 2956: }
2957: } else {
2958: if( u_p != NULL ) {
2959: result = NO_UNIT;
2960: }
2961: }
2962: if( (result != NO_UNIT) && (result != UNIT_FAIL) && ( result != UNIT_NOTNEEDED) ) {
2963: if( t == ANSWER_IS_FLOAT ) {
2964: target = (double)atof(s); /* real number */
2965: } else {
2966: target = (double)atol(s); /* Integer answer */
2967: }
2968: given = n_part * scale; /* convert the given answer into proper scale for units */
2969: sig = calc_sig( num_str );
1.10 albertel 2970: if( ((sig < sl ) || (sig > su )) && (sig!=0)) {
2971: result = SIG_FAIL;
2972: *error=capa_malloc(1,ANSWER_STRING_LENG);
2973: sprintf(*error,"%d",sig);
1.1 albertel 2974: } else {
2975: switch( tt ) { /* tolerence type */
2976: case TOL_ABSOLUTE:
2977: fmted_target = target; /* if answer type is integer */
2978: if( type == ANSWER_IS_FLOAT) { /* format the exact answer as specified */
2979: sprintf(fmted, fm, target);
2980: fmted_target = (double)atof(fmted);
2981: }
2982: to = fabs(to); /* tol must be positive */
2983: if( c == CALC_FORMATED) {
2984: target_l = fmted_target - to; target_u = fmted_target + to;
2985: } else {
2986: target_l = target - to; target_u = target + to;
2987: }
2988: if( (given >= target_l) && (given <= target_u) ) {
2989: result = APPROX_ANS;
2990: } else { result = INCORRECT; }
2991: break;
2992: case TOL_PERCENTAGE:
2993: if( target != 0.0 ) {
2994: ratio = (double)(to / 100.0);
2995: fmted_target = target; /* if answer type is integer */
2996: if( type == ANSWER_IS_FLOAT) { /* format the exact answer as specified */
2997: sprintf(fmted, fm, target);
2998: fmted_target = (double)atof(fmted);
2999: }
3000: delta = (double)fabs((double)ratio*target);
3001: if( c == CALC_FORMATED) {
3002: target_l = fmted_target - delta; target_u = fmted_target + delta;
3003: } else {
3004: target_l = target - delta; target_u = target + delta;
3005: }
3006: } else { target_l = target_u = target; }
3007: if ( (given >= target_l) && (given <= target_u) ) {
3008: result = APPROX_ANS;
3009: } else { result = INCORRECT; }
3010: break;
3011: }
3012: } /* end sig check */
3013: } /* end if unit check */
3014: } else { /* user entered alphabets, but no number */
1.10 albertel 3015: result = WANTED_NUMERIC;
1.1 albertel 3016: }
3017: }
3018: break;
3019: case ANSWER_IS_CHOICE:
3020: {
3021: corr_len = strlen(s); input_len = strlen(ans);
3022: if( corr_len == input_len ) {
3023: for(idx=0;idx<ANSWER_STRING_LENG;idx++) choice[idx] = 0;
3024: result = EXACT_ANS;
3025: for(ii=0;ii<corr_len; ii++) {
1.17 albertel 3026: idx = toupper(s[ii]) - 'A'; choice[idx] = 1;
1.1 albertel 3027: }
3028: for(ii=0;ii<input_len;ii++) {
1.17 albertel 3029: idx = toupper(ans[ii]) - 'A';
1.1 albertel 3030: if(choice[idx] != 1 ) result = INCORRECT;
3031: }
3032: } else { result = INCORRECT; }
3033: break;
3034: }
3035: case ANSWER_IS_STRING_CI:
3036: if (strcasecmp(ans, s)) { result = INCORRECT; } else { result = EXACT_ANS; }
3037: break;
3038: case ANSWER_IS_STRING_CS:
3039: if (strcmp(ans, s)) { result = INCORRECT; } else { result = EXACT_ANS; }
3040: break;
3041: case ANSWER_IS_FORMULA:
3042: result = check_formula_ans(s,ans,ai->ans_id_list,ai->ans_pts_list,tt,to);
3043: break;
3044: case ANSWER_IS_EXTERNAL: /* Not yet implemented */
1.7 albertel 3045:
1.9 albertel 3046:
3047:
1.1 albertel 3048: break;
3049: }
3050: return (result);
3051: }
3052:
3053: /* =============================================================================== */
3054: /* calling sequence capa_check_answers() --> capa_check_answer() */
3055: /* --> capa_check_ans() */
3056:
3057:
3058: /* How we check the correct answer against user input string */
3059: /*
3060: If the correct answer is a number (either integer or real number)
3061: check if user input string consists of only alphabet characters
3062: use split_num_unit() heuristic function to split the input string into two parts
3063: numerical part and units part.
3064: if the outcome contains units, check if the units is correct or not
3065:
3066: */
3067:
3068:
3069: int
1.10 albertel 3070: capa_check_answer(p, answer, error) Problem_t *p; char *answer; char **error;
1.1 albertel 3071: {
3072: int type;
3073: char *correct;
3074: char input[ANSWER_STRING_LENG], unit_str[ANSWER_STRING_LENG];
3075: int tol_type, calc_type;
3076: double tol, n_part;
3077: int sig_l;
3078: int sig_u;
3079: char *fmt;
3080: int choice[ANSWER_STRING_LENG], ii, idx, corr_len, input_len;
3081: int result = INCORRECT, sig, outcome, all_alphabet;
3082: char fmted[FORMAT_STRING_LENG];
3083: double given, target, ratio, fmted_target, target_u, target_l, scale=1.0;
3084: double delta;
3085:
3086: type = p->ans_type;
3087: correct = p->answer;
3088: tol_type = p->tol_type;
3089: tol = p->tolerance;
3090: sig_l = p->sig_lbound;
3091: sig_u = p->sig_ubound;
3092: fmt = p->ans_fmt;
3093: calc_type = p->calc;
3094: unit_str[0]=0;
3095:
3096: switch(type) {
3097: case ANSWER_IS_INTEGER:
3098: case ANSWER_IS_FLOAT:
3099: {
3100: input_len = strlen(answer);
3101: all_alphabet = 1;
3102: for(idx=0;idx<input_len;idx++) {
3103: if( isdigit(answer[idx]) ) {
3104: all_alphabet = 0;
3105: }
3106: }
3107: if( !all_alphabet ) {
3108: outcome = split_num_unit(answer,&n_part,input,unit_str);
3109: if( outcome > 1 ) { /* with both num and unit parts or only unit part */
3110: if( p->ans_unit != NULL ) {
1.10 albertel 3111: if ( UNIT_FAIL == ( result = check_correct_unit(unit_str,p->ans_unit,&scale) ) ) {
3112: *error=strsave(unit_str);
3113: }
1.1 albertel 3114: } else { /* what to do when no unit is specified but student entered a unit? */
3115: result = UNIT_NOTNEEDED;
1.10 albertel 3116: *error=strsave(unit_str);
1.1 albertel 3117: }
3118: } else {
3119: if( p->ans_unit != NULL ) {
3120: result = NO_UNIT;
3121: }
3122: }
3123: if( (result != NO_UNIT) && (result != UNIT_FAIL) && ( result != UNIT_NOTNEEDED) ) {
3124: if( type == ANSWER_IS_FLOAT ) {
3125: target = (double)atof(correct); /* real number */
3126: } else {
3127: target = (double)atol(correct); /* Integer answer */
3128: }
3129: given = n_part * scale; /* convert the given answer into proper scale for units */
3130: sig = calc_sig( input );
1.5 albertel 3131: if( ((sig < sig_l) || (sig > sig_u)) && (sig!=0)) {
1.1 albertel 3132: result = SIG_FAIL;
1.10 albertel 3133: *error=capa_malloc(1,ANSWER_STRING_LENG);
3134: sprintf(*error,"%d",sig);
1.1 albertel 3135: } else {
3136: switch( tol_type ) {
3137: case TOL_ABSOLUTE:
3138: fmted_target = target; /* if answer type is integer */
3139: if( type == ANSWER_IS_FLOAT) { /* format the exact answer as specified */
3140: sprintf(fmted, fmt, target);
3141: fmted_target = (double)atof(fmted);
3142: }
3143: tol = fabs(tol); /* tol must be positive */
3144: if( calc_type == CALC_FORMATED) {
3145: target_l = fmted_target - tol; target_u = fmted_target + tol;
3146: } else {
3147: target_l = target - tol; target_u = target + tol;
3148: }
3149: if( (given >= target_l) && (given <= target_u) ) {
3150: result = APPROX_ANS;
3151: } else { result = INCORRECT; }
3152: break;
3153: case TOL_PERCENTAGE:
3154: if( target != 0.0 ) {
3155: ratio = (double)(tol / 100.0);
3156: fmted_target = target; /* if answer type is integer */
3157: if( type == ANSWER_IS_FLOAT) { /* format the exact answer as specified */
3158: sprintf(fmted, fmt, target);
3159: fmted_target = (double)atof(fmted);
3160: }
3161: delta = (double)fabs((double)ratio*target);
3162: if( calc_type == CALC_FORMATED) {
3163: target_l = fmted_target - delta; target_u = fmted_target + delta;
3164: } else {
3165: target_l = target - delta; target_u = target + delta;
3166: }
3167: } else { target_l = target_u = target; }
3168: if ( (given >= target_l) && (given <= target_u) ) {
3169: result = APPROX_ANS;
3170: } else { result = INCORRECT; }
3171: break;
3172: }
3173: } /* end sig check */
3174: } /* end if unit check */
3175: } else { /* user entered alphabet, but no number */
1.10 albertel 3176: result = WANTED_NUMERIC;
1.1 albertel 3177: }
3178: }
3179: break;
3180: case ANSWER_IS_CHOICE:
3181: {
3182: corr_len = strlen(correct); input_len = strlen(answer);
3183: if( corr_len == input_len ) {
3184: for(ii=0;ii<ANSWER_STRING_LENG;ii++) choice[ii] = 0; result = EXACT_ANS;
3185: for(ii=0;ii<corr_len; ii++) {
3186: idx = toupper(correct[ii]) - 'A'; choice[idx] = 1;
3187: }
3188: for(ii=0;ii<input_len;ii++) {
3189: idx = toupper(answer[ii]) - 'A';
3190: if(choice[idx] != 1 ) result = INCORRECT;
3191: }
3192: } else { result = INCORRECT; }
3193: break;
3194: }
3195: case ANSWER_IS_STRING_CI:
3196: if (strcasecmp(answer, correct)) { result = INCORRECT; } else { result = EXACT_ANS; }
3197: break;
3198: case ANSWER_IS_STRING_CS:
3199: if (strcmp(answer, correct)) { result = INCORRECT; } else { result = EXACT_ANS; }
3200: break;
3201: case ANSWER_IS_FORMULA:
3202: result = check_formula_ans(correct,answer,p->id_list,p->pts_list,tol_type,tol);
3203: break;
3204: case ANSWER_IS_EXTERNAL: /* not yet implemented */
1.5 albertel 3205: /* we assume the external program is called through popen() */
3206: /* and the result will be given back as 0 or 1 to indicate the */
3207: /* given answer is correct or not */
1.7 albertel 3208: /* arguments are given to the program as */
1.16 albertel 3209: /* before running the program, check its existance first */
3210: /* should we specify a time out period in capa.config file? */
3211: /* set up a timer for this purpose */
3212: /* FILE *popen (const char *command,const char *type ); */
1.7 albertel 3213:
1.1 albertel 3214: break;
3215:
3216: }
3217: return (result);
3218: }
3219:
1.16 albertel 3220: /* -------------------------------------------------------------------------- */
1.1 albertel 3221: /* assumming the formula is *fml_str and the student input is *input_str */
3222: /* according to the type of tolerance, we form the final formula as */
3223: /* absolute tolerance: (*fml_str) - (*input_str) */
3224: /* relative tolerance: (*input_str) / (*fml_str) */
3225: int
3226: check_formula_ans(fml_str,input_str,var_list,pts_list,tol_type,tol)
3227: char *fml_str;char *input_str;char *var_list;PointsList_t *pts_list;int tol_type; double tol;
3228: {
3229: char *check_fml_str;
3230: int f_len, i_len, outcome, error_code;
3231: PointsList_t *pt, *next;
3232: double formula_val, diff;
3233:
3234: f_len = strlen(fml_str);
3235: i_len = strlen(input_str);
3236:
3237: check_fml_str = (char *)capa_malloc((f_len + i_len + 16), sizeof(char));
3238: if( tol_type == TOL_ABSOLUTE ) {
3239: sprintf(check_fml_str,"abs((%s) - (%s))",fml_str, input_str);
3240: } else {
3241: sprintf(check_fml_str,"(%s) / (%s)",input_str,fml_str);
3242: }
3243: outcome = APPROX_ANS;
3244: for(pt= pts_list; pt!=NULL ; pt=next) {
3245: next=pt->pts_next;
3246: error_code = f_eval_formula(&formula_val,check_fml_str, var_list, pt->pts_str);
3247: if( ! error_code ) {
3248: if( tol_type == TOL_ABSOLUTE ) {
3249: diff = tol - formula_val;
3250: if( diff < 0.0 ) {
3251: outcome = INCORRECT;
3252: }
3253: } else {
3254: diff = abs(1.0 - formula_val) * 100.0 ;
1.20 ! albertel 3255: if( diff > tol ) {
1.1 albertel 3256: outcome = INCORRECT;
3257: }
3258: }
3259: } else {
3260: outcome = BAD_FORMULA;
3261: break;
3262: }
3263: }
3264: capa_mfree((char *)check_fml_str);
3265:
3266: return (outcome);
3267:
3268: }
3269: /* inputs: type :: answer type, calc_type :: input string format string tolerance type */
3270: /* returns: lower upper */
3271:
3272: int
3273: calc_ansrange(type, calc_type, input, fmt, tol_type, tol, lower, upper)
3274: int type;int calc_type;char *input;char *fmt;
3275: int tol_type;double tol;char *lower;char *upper;
3276: {
3277: int result = 2, leng;
3278: char fmted[ANSWER_STRING_LENG];
3279: double target, fmted_target, ratio, target_l, target_u, tmp, delta;
3280:
3281:
3282: if( (type == ANSWER_IS_FORMULA) ||
3283: (type == ANSWER_IS_EXTERNAL ) ) {
3284: strcpy(lower, input);
3285: result = 1;
3286: return (result);
3287: } else {
3288: if( tol == 0.0 ) { /* answer could be ANSWER_IS_FLOAT ANSWER_IS_INTEGER,
3289: ANSWER_IS_STRING_CI ANSWER_IS_STRING_CS
3290: ANSWER_IS_CHOICE
3291: */
3292: result = 1; /* only one answer */
3293: if( type == ANSWER_IS_FLOAT ) {
3294: target = (double)atof(input);
3295: sprintf(fmted, fmt, target);
3296: leng = strlen(fmted)+1;
3297:
3298: strcpy(lower, fmted);
3299: } else { /* could be integer, choice, string ci, string cs */
3300: strcpy(lower, input);
3301: }
3302: } else { /* we have tolerence */
3303:
3304: target = (double)atof(input);
3305: switch( tol_type ) {
3306: case TOL_ABSOLUTE:
3307: fmted_target = target; /* if answer type is integer */
3308: if( type == ANSWER_IS_FLOAT) { /* format the exact answer as specified */
3309: sprintf(fmted, fmt, target);
3310: fmted_target = (double)atof(fmted);
3311: }
3312: tol = fabs(tol); /* tol must be positive */
3313: if( calc_type == CALC_FORMATED) {
3314: target_l = fmted_target - tol; target_u = fmted_target + tol;
3315: } else {
3316: target_l = target - tol; target_u = target + tol;
3317: }
3318: if(type == ANSWER_IS_FLOAT) {
3319: sprintf(fmted, fmt, target_l ); strcpy(lower, fmted);
3320: sprintf(fmted, fmt, target_u ); strcpy(upper, fmted);
3321: } else {
3322: sprintf(fmted, "%.15g", target_l ); strcpy(lower, fmted);
3323: sprintf(fmted, "%.15g", target_u ); strcpy(upper, fmted);
3324: }
3325: break;
3326: case TOL_PERCENTAGE:
3327: if( target != 0.0 ) {
3328: ratio = (double)(tol / 100.0);
3329: fmted_target = target; /* if answer type is integer */
3330: if( type == ANSWER_IS_FLOAT) { /* format the exact answer as specified */
3331: sprintf(fmted, fmt, target);
3332: fmted_target = (double)atof(fmted);
3333: }
3334: delta = (double)fabs((double)ratio*target);
3335: if( calc_type == CALC_FORMATED) {
3336: target_l = fmted_target - delta; target_u = fmted_target + delta;
3337: } else {
3338: target_l = target - delta; target_u = target + delta;
3339: }
3340: if( target_l > target_u ) { tmp = target_u; target_u = target_l; target_l = tmp; }
3341: if(type == ANSWER_IS_FLOAT) {
3342: sprintf(fmted, fmt, target_l ); strcpy(lower, fmted);
3343: sprintf(fmted, fmt, target_u ); strcpy(upper, fmted);
3344: } else {
3345: sprintf(fmted, "%.15g", target_l ); strcpy(lower, fmted);
3346: sprintf(fmted, "%.15g", target_u ); strcpy(upper, fmted);
3347: }
3348: } else { strcpy(lower, "0.0"); strcpy(upper, "0.0"); result = 1;}
3349: break;
3350: }
3351: }
3352: }
3353:
3354: return (result);
3355: }
3356:
3357: /* Algorithms : check ALL units first */
3358: /* sig figs second */
3359: /* numerical, string comparisons last */
3360: /* result from capa_check_ans() could be */
3361:
3362: /* New check answers routine checks the /AND and /OR group of answers */
3363: /* use array of char pointers char **a */
3364: int
1.10 albertel 3365: capa_check_answers(p,answers,cnt,error)
3366: Problem_t *p; char **answers; int cnt; char **error;
1.1 albertel 3367: {
3368: AnswerInfo_t *ai;
3369: int ii, done, result;
3370: int *outcomes;
1.10 albertel 3371: char **errormsg;
1.1 albertel 3372:
1.10 albertel 3373: errormsg=(char**)capa_malloc(cnt,sizeof(char*));
1.1 albertel 3374: if(p->ans_op == ANS_AND) { /* ans /and ans */
3375: if( (cnt != p->ans_cnt) ) { return (ANS_CNT_NOT_MATCH); }
1.10 albertel 3376: if( cnt == 1 ) { return (capa_check_answer(p, answers[0], error)); } /* there is only one answer */
1.1 albertel 3377: outcomes = (int *)capa_malloc(sizeof(int),cnt);
3378: for(ii=0;ii<cnt;ii++) outcomes[ii]=0; /* initialize the outcomes array */
1.10 albertel 3379: outcomes[0] = capa_check_answer(p, answers[0], &errormsg[0]);
1.16 albertel 3380: #ifdef COMMON_DBUG
1.17 albertel 3381: printf("CAPA_CHECK_ANSWER(%s,%s):: outcome[0]=%d\n",
3382: p->answer,answers[0],outcomes[0]);
1.16 albertel 3383: #endif
1.1 albertel 3384: for(ii=1, ai = p->ans_list; ai; ii++,ai = ai->ans_next ) {
1.10 albertel 3385: outcomes[ii] = capa_check_ans(ai,answers[ii],&(errormsg[ii]));
1.16 albertel 3386: #ifdef COMMON_DBUG
1.17 albertel 3387: printf("CAPA_CHECK_ANS(%s,%s): outcome[%d]=%d\n", ai->ans_str,answers[ii],ii,outcomes[ii]);
1.16 albertel 3388: #endif
1.1 albertel 3389: }
3390: done = ii = 0;
3391: result = 0;
3392: while( !done ) { /* check if any of the outcome has failed on units */
3393: if( (outcomes[ii] == UNIT_FAIL) ||
3394: (outcomes[ii] == NO_UNIT) ||
3395: (outcomes[ii] == UNIT_NOTNEEDED) ) {
3396: result = outcomes[ii];
1.10 albertel 3397: if (result != NO_UNIT) { *error=strsave(errormsg[ii]); }
1.1 albertel 3398: done = 1;
3399: }
3400: ii++;
3401: if(ii==cnt) done = 1;
3402: }
1.15 albertel 3403: if( result == 0 ) {
3404: /* check if any of the outcome has failed to be a numeric
3405: or was a malformed equation */
1.10 albertel 3406: done = ii = 0;
3407: while( !done ) {
1.15 albertel 3408: if( outcomes[ii] == WANTED_NUMERIC || outcomes[ii] == BAD_FORMULA ) {
1.10 albertel 3409: result = outcomes[ii];
3410: done = 1;
3411: }
3412: ii++;
3413: if(ii==cnt) done = 1;
3414: }
3415: }
1.15 albertel 3416: if( result == 0 ) {/*check if any of the outcome has failed on sig figs*/
1.1 albertel 3417: done = ii = 0;
3418: while( !done ) {
3419: if( outcomes[ii] == SIG_FAIL ) {
3420: result = outcomes[ii];
1.10 albertel 3421: *error = strsave(errormsg[ii]);
1.1 albertel 3422: done = 1;
3423: }
3424: ii++;
3425: if(ii==cnt) done = 1;
3426: }
3427: }
3428: if( result == 0 ) { /* check if any of the outcome is incorrect */
3429: done = ii = 0;
3430: while( !done ) {
3431: if( outcomes[ii] == INCORRECT ) {
3432: result = outcomes[ii];
3433: done = 1;
3434: }
3435: ii++;
3436: if(ii==cnt) done = 1;
3437: }
3438: }
1.10 albertel 3439: for (ii=0;ii<cnt;ii++) {
3440: if( (outcomes[ii] == UNIT_FAIL) ||
3441: (outcomes[ii] == SIG_FAIL) ||
3442: (outcomes[ii] == UNIT_NOTNEEDED) ) {
3443: capa_mfree(errormsg[ii]);
3444: }
3445: }
3446: capa_mfree((char *)errormsg);
1.1 albertel 3447: capa_mfree((char *)outcomes);
3448: if( result == 0 ) {
3449: result = APPROX_ANS; /* all answers are correct */
3450: }
1.10 albertel 3451:
1.1 albertel 3452: } else { /* should be ANS_OR , user answer count should always be 1 */
3453: if( cnt != 1 ) { return (ANS_CNT_NOT_MATCH); }
1.10 albertel 3454: if( p->ans_cnt == 1 ) { return (capa_check_answer(p, answers[0], error)); }
3455: result = capa_check_answer(p, answers[0], error);
1.1 albertel 3456: ii = 1; ai = p->ans_list;
3457: while( (ii<p->ans_cnt) && ( (result != EXACT_ANS) && (result != APPROX_ANS) ) ) {
1.10 albertel 3458: if((ii!=1)&&((result==UNIT_FAIL)||(result==SIG_FAIL)||(result==UNIT_NOTNEEDED))) {
3459: capa_mfree((char*)error);
3460: }
3461: result = capa_check_ans(ai,answers[0],error);
3462: ai = ai->ans_next; ii++;
1.1 albertel 3463: }
3464: }
3465: return (result);
3466: }
3467:
3468:
3469:
3470:
3471:
3472:
3473:
3474:
3475: /* ========================================================================= */
3476: int w_getclassdir(cpath_p, cown_p, class)
3477: char **cpath_p; char **cown_p; char *class;
3478: {
3479: FILE *fp;
3480: char filename[SMALL_LINE_BUFFER];
3481: char *cname_p;
3482: int done;
3483: char c;
3484:
3485: sprintf(filename,"class.conf");
3486: if ((fp=fopen(filename,"r"))==NULL) {
3487: sprintf(filename,"../class.conf");
3488: if ((fp=fopen(filename,"r"))==NULL) {
3489: printf("Error: can't open %s\n",filename);
3490: exit (1);
3491: }
3492: }
3493: do {
3494: c_ignorewhite(fp);
3495: c = getc(fp); ungetc(c,fp);
3496: if( c != EOF ) {
3497: cname_p = c_getword(fp);
3498: *cpath_p = c_getword(fp);
3499: *cown_p = c_getword(fp);
3500: throwaway_line(fp);
3501: if( ! strcasecmp(cname_p, class) ) {
3502: done = 1;
3503: } else {
3504: free(cname_p); free(*cpath_p); free(*cown_p);
3505: done = 0;
3506: }
3507: } else {
3508: done = 1;
3509: }
3510: } while ( ! done );
3511: fclose(fp);
3512: free(cname_p);
3513: return (1);
3514: }
3515:
3516: /* ----------------------------------------------------------------- */
3517: /* read_capa_config gets a value out of the capa.config file
3518: in the read resultant string all " are removed expect for \" occurances"
3519: in fact all case of \ then another character become just the last
3520: character
3521:
3522: inputs : key_word - a string that is searched for on the lefthand side
3523: of an equals sign
3524: outputs : value - a char pointer that the value of the key_word as defined
3525: in the config file is copied into
3526: return : -1 - unable to find or acces the capa.config file
3527: 0 - the requested keyword was not found
3528: >0 - length of the string that was returned in value
3529: */
3530: /* ----------------------------------------------------------------- */
3531: int read_capa_config(key_word,value)
3532: char *key_word;char *value;
3533: {
3534: FILE *fp;
3535: char filename[SMALL_LINE_BUFFER];
3536: char left[MAX_BUFFER_SIZE],right[MAX_BUFFER_SIZE],c;
3537: int failed=0,done=0,num=0,result=-1,found=0,returnVal=0,i,j;
3538:
3539: sprintf(filename,"capa.config");
3540: if ((fp=fopen(filename,"r"))==NULL) {
3541: return (-1);
3542: }
3543: do {
3544: num = fscanf(fp,"%[^ \n\t#] = %[^\n]",left,right);
3545: if (num == 2) { result = strcasecmp(left,key_word); }
3546: if (result==0) { done=1; }
3547: if (num==EOF) { failed=1; }
3548: if (num!=2) {
3549: found=0;
3550: while(1) {
3551: c=fgetc(fp);
3552: if (found) {
3553: if (c!='\n') {
3554: ungetc(c,fp);
3555: break;
3556: }
3557: }
3558: if (c=='\n') found=1;
1.18 albertel 3559: if (((char)c)==((char)EOF)) {failed=1;break;}
1.1 albertel 3560: }
3561: }
3562: } while (!done && !failed);
3563:
3564: fclose(fp);
3565:
3566: if (done) {
1.4 albertel 3567: trim_response_ws(right); /*get rid of leading and trailing spaces*/
1.1 albertel 3568: for(i=0,j=0;i<(strlen(right)+1);i++) {
3569: value[j]='\0';
3570: if (right[i] == '\\' && (i < (strlen(right))) ) {
3571: i++;value[j]=right[i];j++;
3572: } else if (right[i] != '\"' ) {
3573: value[j]=right[i];j++;
3574: }
3575: }
3576: value[j]='\0';
3577: returnVal=j;
3578: }
3579: return returnVal;
3580: }
3581:
3582: int capa_access(const char *pathname, int mode)
3583: {
3584: pid_t euid,egid;
3585: struct stat status;
3586:
3587: euid=geteuid();
3588: egid=getegid();
3589: if ( -1 == stat(pathname,&status) ) { return -1; }
3590: /*printf("mode:%x F_OK:%x mode&F_OK:%x\n",mode,F_OK,(mode&F_OK));*/
3591: /*printf("st_mode:%x S_IFMT:%x st_mode&S_IFMT:%x\n",
3592: status.st_mode,S_IFMT,(status.st_mode&S_IFMT));*/
3593: if (!(status.st_mode & S_IFMT)) { return -1; }
3594: /*printf("euid: %d\t egid: %d\tstatus.st_uid: %d\tstatus.st_gid: %d\n",
3595: euid,egid,status.st_uid,status.st_gid);*/
3596: /*printf("mode:%x R_OK:%x mode&R_OK:%x\n",mode,R_OK,(mode&R_OK));*/
3597: /*printf("mode:%x W_OK:%x mode&W_OK:%x\n",mode,R_OK,(mode&R_OK));*/
3598: /*printf("mode:%x X_OK:%x mode&X_OK:%x\n",mode,R_OK,(mode&R_OK));*/
3599: if (euid==status.st_uid) {
3600: /*printf("here1\n");*/
3601: if ((mode & R_OK) && (!(status.st_mode & S_IRUSR))) { return -1; }
3602: if ((mode & W_OK) && (!(status.st_mode & S_IWUSR))) { return -1; }
3603: if ((mode & X_OK) && (!(status.st_mode & S_IXUSR))) { return -1; }
3604: } else {
3605: if (egid==status.st_gid) {
3606: /*printf("here2\n");*/
3607: if ((mode & R_OK) && (!(status.st_mode & S_IRGRP))) { return -1; }
3608: if ((mode & W_OK) && (!(status.st_mode & S_IWGRP))) { return -1; }
3609: if ((mode & X_OK) && (!(status.st_mode & S_IXGRP))) { return -1; }
3610: } else {
3611: /*printf("here3\n");*/
3612: if ((mode & R_OK) && (!(status.st_mode & S_IROTH))) { return -1; }
3613: if ((mode & W_OK) && (!(status.st_mode & S_IWOTH))) { return -1; }
3614: if ((mode & X_OK) && (!(status.st_mode & S_IXOTH))) { return -1; }
3615: }
3616: }
3617: return 0;
3618: }
3619:
3620: /*checks if the string is all whitespace*/
3621: /*returns 0 if it isn't */
3622: /*returns 1 if it is */
3623: int is_all_ws(char* answer)
3624: {
3625: int length,result=1,i;
3626: if (answer!=NULL) {
3627: length=strlen(answer);
3628: for(i=0;i<length;i++) {
3629: if (!isspace(answer[i])) {result=0;break;}
3630: }
3631: }
3632: return result;
3633: }
3634:
3635: void trim_response_ws(char* answer)
3636: {
3637: char *temp;
3638: int i,j=0,length;
3639: length=strlen(answer);
3640: temp=capa_malloc(length+1,1);
3641: strcpy(temp,answer);
3642: for(i=0; i<length;i++) if (!(isspace(temp[i]))) break;
3643: for(j=length-1;j>=0;j--) if (!(isspace(temp[j]))) break;
3644: temp[++j]='\0';
3645: strcpy(answer,&temp[i]);
3646: }
3647:
3648: void throwaway_line(FILE* fp)
3649: {
3650: int c;
3651: do {
3652: c = getc(fp);
3653: } while ( (c != '\n') && (c != EOF) );
3654: }
3655:
3656: char* capa_get_seat(char* studentnum,char* seatfile)
3657: {
3658: FILE* fp;
3659: T_student student;
3660: char *result,*defaultseatfile="seatingchart";
3661: char line[TMP_LINE_LENGTH],*lineend;
3662: int stuline=0,seatline=0;
3663:
3664: stuline = capa_get_student(studentnum,&student);
3665: if (stuline < 1 ) goto error;
3666: if (seatfile == NULL) seatfile=defaultseatfile;
3667: if ((fp=fopen(seatfile,"r"))==NULL) goto error;
3668: while( (stuline>seatline) && (fgets(line,TMP_LINE_LENGTH-1,fp)) ) seatline++;
3669: if (seatline< stuline) goto error;
3670: if ((lineend=index(line,' '))!=NULL) lineend='\0';
3671: result=capa_malloc(strlen(line)+1,1);
3672: strcpy(result,line);
3673: return result;
3674:
3675: error:
3676: result= capa_malloc(8,1);
3677: sprintf(result,"No Seat");
3678: return result;
3679:
3680: }
3681:
3682: void protect_log_string(char* log_string)
3683: {
3684: int i,len=strlen(log_string);
3685: for(i=0;i<len;i++) {
3686: switch (log_string[i]) {
3687: case '\n': case '\t': case '\r':
3688: log_string[i]=' ';
3689: break;
3690: }
3691: }
3692: }
3693:
3694: int capa_get_login_time(char *student_number,int set,time_t *logintime)
3695: {
3696: FILE *fp;
3697: int found,temp=0;
3698: char filename[FILE_NAME_LENGTH],line[SMALL_LINE_BUFFER];
3699:
3700: *logintime=0;
3701: sprintf(filename,"records/access%d.log",set);
3702:
3703: if ((fp=fopen(filename,"r"))==NULL) return (-1);
3704: found = 0;
3705: while( (!found) && ( fgets(line,SMALL_LINE_BUFFER-1,fp) != NULL) ) {
3706: if( !strncasecmp(line,student_number,MAX_STUDENT_NUMBER) ) found = 1;
3707: }
3708: fclose(fp);
3709: if (found) sscanf(rindex(line,':'),":%d",&temp);
3710: *logintime=(time_t)temp;
3711: return found;
3712: }
3713:
3714: /*----------------------------------------------------------*/
3715: /* INPUT: set the X in logX.db */
3716: /* OUTPUT: creates the accessX.log file if it doesn't exist */
3717: /* and inserts stunum:time(NULL) if stunum isn't */
3718: /* in ther already. */
3719: /* */
3720: /* RETURN: -1 file error */
3721: /* 0 already set */
3722: /* 1 succesfully logged a login time */
3723: /*----------------------------------------------------------*/
3724: int capa_set_login_time(char *student_number,int set)
3725: {
3726: FILE *fp;
3727: int errcode=0;
3728: int found=0;
3729: char filename[FILE_NAME_LENGTH],line[SMALL_LINE_BUFFER];
3730:
3731: sprintf(filename,"records/access%d.log",set);
3732:
3733: if ((fp=fopen(filename,"r"))!=NULL) {
3734: while( (!found) && ( fgets(line,SMALL_LINE_BUFFER-1,fp) != NULL) ) {
3735: if( !strncasecmp(line,student_number,MAX_STUDENT_NUMBER) ) found = 1;
3736: }
3737: fclose(fp);
3738: }
3739:
3740: if (found) return 0;
3741:
3742: sprintf(line,"%s:%d\n", student_number,(int)time(NULL));
3743: if ((fp=fopen(filename,"a+"))==NULL) return (-1);
3744: flockstream(fp);
3745: fseek(fp,0L,SEEK_END);
3746: if ( !fwrite((char *)line, strlen(line), 1, fp) ) {
3747: errcode = -1;
3748: } else {
3749: errcode = 1;
3750: }
3751: fflush(fp);
3752: funlockstream(fp);
3753: fclose(fp);
3754: return (errcode);
3755: }
3756: /* =||>|===================== End of capaCommon.c =====================|<||= */
3757:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/back.gif){kind=icon}
Return to capaCommon.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [LON-CAPA] / capa / capa51 / pProj