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