Annotation of loncom/homework/CAPA-converter/capaGrammarDef.y, revision 1.1
1.1 ! albertel 1: /* ========================================================================== */
! 2: /* capaGrammarDef.y created by Isaac Tsai */
! 3: /* 1998, 1999 copyrighted by Isaac Tsai */
! 4: /* no longer there is a length constrain on string concatenation July 13 1998 */
! 5: /* /RMAP() function */
! 6: /* TODO: new mechanism to collect answer informations */
! 7: /*****************************************************************************/
! 8: /*****************************************************************************/
! 9: /*****************************************************************************/
! 10: %{
! 11: #include <stdio.h>
! 12: #include <ctype.h>
! 13: #include <string.h>
! 14: #include <math.h>
! 15: #include "capaParser.h" /* _symbol structure def */
! 16: #include "capaCommon.h"
! 17: #include "capaFunction.h"
! 18: #include "capaRQO.h"
! 19: #ifdef __hpux
! 20: #include <stdlib.h>
! 21: #include <alloca.h>
! 22: #endif
! 23:
! 24: #ifdef YACC_DBUG
! 25: #define YYDBUG_PR1(xx) { printf(xx); fflush(stdout); }
! 26: #define YYDBUG_PR2(xx,yy) { printf(xx,yy); fflush(stdout); }
! 27: #define YYDBUG_PR3(xx,yy,zz) { printf(xx,yy,zz); fflush(stdout); }
! 28: #define YYDBUG_PR4(xx,yy,zz,aa) { printf(xx,yy,zz,aa); fflush(stdout); }
! 29: #define YYDBUG_SYM(xx) { switch((xx)->s_type) { \
! 30: case IDENTIFIER: \
! 31: printf("ID(%s)\n",(xx)->s_name); break; \
! 32: case I_VAR: case I_CONSTANT: \
! 33: printf("INT(%d)\n",(xx)->s_int); break; \
! 34: case R_VAR: case R_CONSTANT: \
! 35: printf("REAL(%.16g)\n",(xx)->s_real); break; \
! 36: case S_VAR: case S_CONSTANT: \
! 37: printf("STR(%s)\n",(xx)->s_str); break; \
! 38: } }
! 39: #else /* YACC_DBUG */
! 40: #define YYDBUG_PR1(xx) { }
! 41: #define YYDBUG_PR2(xx,yy) { }
! 42: #define YYDBUG_PR3(xx,yy,zz) { }
! 43: #define YYDBUG_PR4(xx,yy,zz,aa) { }
! 44: #define YYDBUG_SYM(xx) { }
! 45: #endif /* YACC_DBUG */
! 46:
! 47: int yylex();
! 48: void yyerror(char*);
! 49: void free_calc_expr(Symbol*);
! 50: void assign_pts (Symbol *, Symbol *, Symbol *);
! 51: /******************************************************************************/
! 52: /* GLOBAL VARIABLES */
! 53: /******************************************************************************/
! 54: int Lexi_qnum;
! 55:
! 56: extern int Lexi_line;
! 57: extern int Lexi_pos[MAX_OPENED_FILE];
! 58: extern char Opened_filename[MAX_OPENED_FILE][QUARTER_K];
! 59: extern int Input_idx;
! 60: int Current_line[MAX_OPENED_FILE];
! 61: extern int Func_idx;
! 62: extern Symbol FuncStack[MAX_FUNC_NEST];
! 63: extern int IFstatus[MAX_FUNC_NEST];
! 64: extern int IFcount;
! 65: /*extern int gUnitError;*/
! 66:
! 67: int Parsemode_f; /* Parser mode flag */
! 68:
! 69: Problem_t *FirstProblem_p; /* First problem */
! 70: Problem_t *LastProblem_p; /* Last problem */
! 71: Problem_t *LexiProblem_p; /* Current problem */
! 72: char *EndText_p;
! 73: char *StartText_p;
! 74: char *ErrorMsg_p;
! 75: int ErrorMsg_count;
! 76: WarnMsg_t *WarnMsg_p;
! 77: int WarnMsg_count;
! 78: int Answer_infospec;
! 79: void (*Status_Func)();
! 80: AnswerInfo_t CurrAnsInfo;
! 81:
! 82: RandQO_t *QuestionOrder;
! 83: PointsList_t *CurrPtsList;
! 84: PointsList_t *LastPtsList;
! 85:
! 86:
! 87:
! 88:
! 89: #ifdef YYSTYPE
! 90: #undef YYSTYPE
! 91: #endif
! 92: #define YYSTYPE Symbol_p
! 93:
! 94:
! 95: #define ADD_op 1
! 96: #define SUB_op 2
! 97: #define MUL_op 3
! 98: #define DIV_op 4
! 99: #define IDIV_op 5
! 100: #define NOT_DEFINED_op 9
! 101:
! 102: /*#define yyerror printf*/
! 103:
! 104: %}
! 105: %token NEW_ID
! 106: %token I_CONSTANT R_CONSTANT S_CONSTANT
! 107: %token I_VAR R_VAR S_VAR
! 108:
! 109: %token IDENTIFIER FUNCTION_ID ARRAY_ID
! 110: %token HINT_LINE EXPLAIN_LINE TEXT_LINE IMPORT_LINE
! 111: %token CAPA_LET CAPA_DEF CAPA_DIS CAPA_END CAPA_VAR
! 112: %token CAPA_ESC CAPA_MAP CAPA_FIG CAPA_ANS CAPA_RMAP
! 113: %token CAPA_IF CAPA_ELSE CAPA_ENDIF CAPA_SUBJ CAPA_WHILE
! 114: %token CAPA_ENDWHILE CAPA_START
! 115: %token ANS_AND ANS_BOX_SHOW ANS_CALC ANS_CI ANS_COMPARE ANS_CS
! 116: %token ANS_EVAL ANS_EXPLAIN ANS_EXTERNAL ANS_FMT
! 117: %token ANS_FORMULA ANS_HINT ANS_MC ANS_MINUS
! 118: %token ANS_OFF ANS_ON ANS_OR ANS_ORDERED
! 119: %token ANS_PATH ANS_PCREDIT ANS_PLUS ANS_RANGE
! 120: %token ANS_SHOW_BR ANS_SIG ANS_TOLERANCE ANS_TRY ANS_TYPE
! 121: %token ANS_UNFMT ANS_UNIT ANS_VERBATIM ANS_WEIGHT
! 122: %token VAR_RANGE VERBATIM
! 123: %token SLASH FORMAT
! 124: %token EQ_op NE_op GT_op GE_op LT_op LE_op AND_op OR_op EoL
! 125:
! 126: %start prob_set
! 127:
! 128: %%
! 129:
! 130: prob_set : startQ questions CAPA_END { YYDBUG_PR1(" prob_set := startQ questions END\n\n"); }
! 131: ;
! 132:
! 133: questions : a_line { YYDBUG_PR1(" questions <= a_line");
! 134: if (Status_Func != NULL) Status_Func();
! 135: }
! 136: | questions a_line { YYDBUG_PR1(" questions <= questions a_line");
! 137: if (Status_Func != NULL) Status_Func();
! 138: }
! 139: ;
! 140:
! 141: startL : CAPA_LET { YYDBUG_PR1("\n begin_let::"); }
! 142: ;
! 143:
! 144: startV : CAPA_VAR { YYDBUG_PR1(" begin_var"); }
! 145: ;
! 146:
! 147: startA : CAPA_ANS { YYDBUG_PR1("\n START ANSWER(/ANS)::\n");
! 148: init_answerinfo();
! 149: }
! 150: ;
! 151:
! 152: startSA : CAPA_SUBJ { YYDBUG_PR1("\n START SUBJECT ANSWER(/SUBJECTIVE)::\n");
! 153: init_answerinfo();
! 154: }
! 155: ;
! 156:
! 157: startM : CAPA_MAP { YYDBUG_PR1("\n begin_map::"); }
! 158: ;
! 159:
! 160: startR : CAPA_RMAP { YYDBUG_PR1("\n begin_rmap::"); }
! 161: ;
! 162:
! 163: ans_and_op : ANS_AND { add_answer_cnt(ANS_AND); YYDBUG_PR1("(AND ,new an answer info)"); }
! 164: ;
! 165:
! 166: ans_or_op : ANS_OR { add_answer_cnt(ANS_OR); YYDBUG_PR1("(OR ,new an answer info)"); }
! 167: ;
! 168:
! 169: a_line : startL statement EoL { YYDBUG_PR1(" a_line <= startL statement CR\n"); }
! 170: | CAPA_END { YYDBUG_PR1(" a_line <= END\n\n"); }
! 171: | CAPA_START { YYDBUG_PR1(" aline <= CAPA_START\n");
! 172: start_question_over();
! 173: }
! 174: | HINT_LINE { append_hint($1->s_str);
! 175: YYDBUG_PR2(" a_line <= Hint_line(%s)\n",$1->s_str);
! 176: capa_mfree($1->s_str); capa_mfree((char *)$1);
! 177: }
! 178: | EXPLAIN_LINE { append_explain($1->s_str);
! 179: YYDBUG_PR2(" a_line <= Explain_line(%s)\n",$1->s_str);
! 180: capa_mfree($1->s_str); capa_mfree((char*)$1);
! 181: }
! 182: | IMPORT_LINE EoL { YYDBUG_PR1(" a_line <= import_line CR\n"); }
! 183: | q_text EoL { YYDBUG_PR1(" a_line <= Qtext CR\n"); append_text("\n"); }
! 184: | answer_expr { YYDBUG_PR1(" a_line <= answer_expr (init a new prob) CR\n");
! 185: init_new_prob(); }
! 186: | if_expr { YYDBUG_PR1(" a_line <= if_expr\n"); }
! 187: | while_expr { YYDBUG_PR1(" a_line <= while_expr\n"); }
! 188: | map_expr EoL { YYDBUG_PR1(" a_line <= map_expr CR\n"); }
! 189: | EoL { YYDBUG_PR1(" a_line <= (CR)\n"); }
! 190: | VERBATIM { YYDBUG_PR1(" a_line <= (VERBATIM)\n");
! 191: switch(Parsemode_f) {
! 192: case TeX_MODE: append_text("\\begin{verbatim}");
! 193: break;
! 194: case HTML_MODE: append_text("<PRE>");
! 195: break;
! 196: }
! 197: append_text($1->s_str);
! 198: capa_mfree($1->s_str); capa_mfree((char *)$1);
! 199: switch(Parsemode_f) {
! 200: case TeX_MODE: append_text("\\end{verbatim}\n");
! 201: break;
! 202: case HTML_MODE: append_text("</PRE>\n");
! 203: break;
! 204: }
! 205: }
! 206: | error EoL { char warn_msg[WARN_MSG_LENGTH];
! 207: YYDBUG_PR1(" a_line := ERROR(CR)\n");
! 208: sprintf(warn_msg," Question %d: Syntax error.\n", Lexi_qnum+1);
! 209: capa_msg(MESSAGE_ERROR,warn_msg);
! 210: begin_text();
! 211: }
! 212:
! 213: ;
! 214:
! 215: statement : IDENTIFIER '=' calc_expr
! 216: { char warn_msg[WARN_MSG_LENGTH];
! 217:
! 218: if ( $1 != $3 ) { /* /LET a = a */
! 219: switch($1->s_type) {
! 220: case IDENTIFIER:
! 221: case I_VAR: case I_CONSTANT:
! 222: case R_VAR: case R_CONSTANT: break;
! 223: case S_VAR: case S_CONSTANT:
! 224: capa_mfree($1->s_str); $1->s_str = NULL; break;
! 225: default: break;
! 226: }
! 227: switch($3->s_type) {
! 228: case IDENTIFIER:
! 229: sprintf(warn_msg,"var \"%s\" not defined before use.\n",$3->s_name);
! 230: capa_msg(MESSAGE_ERROR,warn_msg);
! 231: break;
! 232: case I_VAR: case I_CONSTANT:
! 233: $1->s_type = I_VAR;
! 234: $1->s_int = $3->s_int;
! 235: break;
! 236: case R_VAR: case R_CONSTANT:
! 237: $1->s_type = R_VAR;
! 238: $1->s_real = $3->s_real;
! 239: break;
! 240: case S_VAR: case S_CONSTANT:
! 241: $1->s_type = S_VAR;
! 242: $1->s_str = strsave($3->s_str);
! 243: break;
! 244: }
! 245: YYDBUG_PR1(" statement <= ID = calc_expr:: "); YYDBUG_SYM($3);
! 246: free_calc_expr($3);
! 247: }
! 248: }
! 249: | ARRAY_ID '[' calc_expr ']' '=' calc_expr
! 250: { Symbol *s_p;
! 251: char warn_msg[WARN_MSG_LENGTH];
! 252:
! 253: s_p = get_array_symbol($1,$3,1);
! 254: switch(s_p->s_type) {
! 255: case IDENTIFIER:
! 256: case I_VAR: case I_CONSTANT:
! 257: case R_VAR: case R_CONSTANT: break;
! 258: case S_VAR: case S_CONSTANT:
! 259: capa_mfree(s_p->s_str); s_p->s_str = NULL; break;
! 260: default: break;
! 261: }
! 262: switch($6->s_type) {
! 263: case IDENTIFIER:
! 264: sprintf(warn_msg,"var \"%s\" not defined before use.\n",$6->s_name);
! 265: capa_msg(MESSAGE_ERROR,warn_msg);
! 266: break;
! 267: case I_VAR: case I_CONSTANT:
! 268: s_p->s_type = I_VAR;
! 269: s_p->s_int = $6->s_int;
! 270: break;
! 271: case R_VAR: case R_CONSTANT:
! 272: s_p->s_type = R_VAR;
! 273: s_p->s_real = $6->s_real;
! 274: break;
! 275: case S_VAR: case S_CONSTANT:
! 276: s_p->s_type = S_VAR;
! 277: s_p->s_str = strsave($6->s_str);
! 278: break;
! 279: }
! 280: free_calc_expr($6);
! 281: }
! 282: ;
! 283:
! 284:
! 285: q_text : TEXT_LINE { append_text($1->s_str);
! 286: capa_mfree($1->s_str); capa_mfree((char *)$1);
! 287: }
! 288: | var_expr { }
! 289: | q_text var_expr { }
! 290: | q_text TEXT_LINE { append_text($2->s_str);
! 291: capa_mfree($2->s_str); capa_mfree((char *)$2);
! 292: }
! 293: ;
! 294:
! 295: if_expr : CAPA_IF '(' calc_expr ')'
! 296: { int leng=0; /* begin_next_line(); no use, can be get rid of */
! 297: YYDBUG_PR2("(IF expr <IFcount=%d>)\n",IFcount);
! 298: switch($3->s_type) {
! 299: case IDENTIFIER:
! 300: IFstatus[IFcount] = IF_FALSE;
! 301: begin_next_line();
! 302: break;
! 303: case I_CONSTANT: case I_VAR:
! 304: if(!$3->s_int) {
! 305: IFstatus[IFcount] = IF_FALSE;
! 306: begin_if_skip();
! 307: } else {
! 308: IFstatus[IFcount] = IF_TRUE;
! 309: begin_next_line();
! 310: }
! 311: break;
! 312: case R_CONSTANT: case R_VAR:
! 313: if($3->s_real == 0.0) {
! 314: IFstatus[IFcount] = IF_FALSE;
! 315: begin_if_skip();
! 316: }else{
! 317: IFstatus[IFcount] = IF_TRUE;
! 318: begin_next_line();
! 319: }
! 320: break;
! 321: case S_CONSTANT:
! 322: if ( $3->s_str) {
! 323: leng = strlen($3->s_str);
! 324: capa_mfree($3->s_str);
! 325: }
! 326: if(leng == 0) {
! 327: IFstatus[IFcount] = IF_FALSE;
! 328: begin_if_skip();
! 329: }else{
! 330: IFstatus[IFcount] = IF_TRUE;
! 331: begin_next_line();
! 332: }
! 333: break;
! 334: case S_VAR:
! 335: if ( $3->s_str) {
! 336: leng = strlen($3->s_str);
! 337: capa_mfree($3->s_str);
! 338: }
! 339: if(leng == 0) {
! 340: IFstatus[IFcount] = IF_FALSE;
! 341: begin_if_skip();
! 342: }else{
! 343: IFstatus[IFcount] = IF_TRUE;
! 344: begin_next_line();
! 345: }
! 346: break;
! 347: }
! 348: capa_mfree((char*)$3);
! 349: }
! 350: ;
! 351:
! 352: while_expr : CAPA_WHILE '(' calc_expr ')'
! 353: {
! 354: int leng;
! 355: YYDBUG_PR1("(WHILE expr)\n");
! 356: switch($3->s_type) {
! 357: case IDENTIFIER: /* undefined identifier regarded as false */
! 358: begin_while_skip();
! 359: break;
! 360: case I_CONSTANT: case I_VAR:
! 361: if(!$3->s_int) {
! 362: begin_while_skip();
! 363: } else {
! 364: begin_next_line(); /* skip to EoL and begin S_TEXT */
! 365: }
! 366: break;
! 367: case R_CONSTANT: case R_VAR:
! 368: if($3->s_real == 0.0) {
! 369: begin_while_skip();
! 370: }else{
! 371: begin_next_line(); /* skip to EoL and begin S_TEXT */
! 372: }
! 373: break;
! 374: case S_CONSTANT:
! 375: leng = strlen($3->s_str);
! 376: capa_mfree($3->s_str);
! 377: if(leng == 0) {
! 378: begin_while_skip();
! 379: }else{
! 380: begin_next_line(); /* skip to EoL and begin S_TEXT */
! 381: }
! 382: break;
! 383: case S_VAR:
! 384: leng = strlen($3->s_str);
! 385: if(leng == 0) {
! 386: begin_while_skip();
! 387: }else{
! 388: begin_next_line(); /* skip to EoL and begin S_TEXT */
! 389: }
! 390: break;
! 391: }
! 392: capa_mfree((char*)$3);
! 393: }
! 394: ;
! 395:
! 396: var_expr : startV '(' formated_ans ')'
! 397: { display_var( $3 ) ; }
! 398: ;
! 399:
! 400: answer_expr : answer_spec { finish_answer_info();
! 401: }
! 402: | answer_expr ans_and_op answer_spec
! 403: { finish_answer_info();
! 404: YYDBUG_PR1(" answer_expr <-- AND answers (copy answerinfo)\n"); }
! 405: | answer_expr ans_or_op answer_spec
! 406: { finish_answer_info();
! 407: YYDBUG_PR1(" answer_expr <-- OR answers (copy answerinfo)\n");
! 408: } | startSA '(' answer_info ')'
! 409: { YYDBUG_PR1("\n subjective answer\n");
! 410: finish_answer_info();
! 411: LexiProblem_p->ans_type = ANSWER_IS_SUBJECTIVE;
! 412: }
! 413: | startSA '(' ')'
! 414: { YYDBUG_PR1("\n subjective answer\n");
! 415: finish_answer_info();
! 416: LexiProblem_p->ans_type = ANSWER_IS_SUBJECTIVE;
! 417: }
! 418:
! 419: ;
! 420:
! 421: answer_spec : startA '(' formated_ans ')'
! 422: { assign_answer( $3 );
! 423: YYDBUG_PR1("\nASSIGN Answer\n");
! 424: }
! 425: | startA '(' formated_ans ',' answer_info ')'
! 426: { assign_answer( $3 );
! 427: YYDBUG_PR1("\nASSIGN Answers + Answer Info\n");
! 428: }
! 429: ;
! 430:
! 431: answer_info : ans_infospec
! 432: | answer_info ',' ans_infospec
! 433: ;
! 434:
! 435:
! 436: ans_infospec : ANS_TOLERANCE '=' a_number
! 437: { YYDBUG_PR1(" ans_infospec:= TOL=a_number");
! 438: assign_tolerance(TOL_ABSOLUTE,$3);
! 439: }
! 440: | ANS_TOLERANCE '=' IDENTIFIER
! 441: { assign_tolerance(TOL_ABSOLUTE,$3);
! 442: }
! 443: | ANS_TOLERANCE '=' IDENTIFIER '%'
! 444: { assign_tolerance(TOL_PERCENTAGE,$3);
! 445: }
! 446: | ANS_TOLERANCE '=' a_number '%'
! 447: { assign_tolerance(TOL_PERCENTAGE,$3);
! 448: }
! 449: | ANS_COMPARE '=' answer_comp { }
! 450: | ANS_SIG '=' answer_sig { }
! 451: | ANS_WEIGHT '=' an_integer
! 452: { assign_weight( $3 );
! 453: }
! 454: | ANS_WEIGHT '=' IDENTIFIER
! 455: { assign_weight( $3 );
! 456: }
! 457: | ANS_HINT '=' an_integer { assign_hint( $3 );
! 458: }
! 459: | ANS_HINT '=' IDENTIFIER { assign_hint( $3 );
! 460: }
! 461: | ANS_PCREDIT '=' ANS_ON { LexiProblem_p->partial_cdt = 1;
! 462: }
! 463: | ANS_PCREDIT '=' ANS_OFF { LexiProblem_p->partial_cdt = 0;
! 464: }
! 465: | ANS_SHOW_BR '=' ANS_ON { LexiProblem_p->show_br = DO_SHOW;
! 466: }
! 467: | ANS_SHOW_BR '=' ANS_OFF { LexiProblem_p->show_br = DONOT_SHOW;
! 468: }
! 469: | ANS_VERBATIM '=' ANS_ON { LexiProblem_p->verbatim = DO_VERBATIM;
! 470: }
! 471: | ANS_VERBATIM '=' ANS_OFF { LexiProblem_p->verbatim = DONOT_VERBATIM;
! 472: }
! 473: | ANS_BOX_SHOW '=' ANS_ON { LexiProblem_p->show_ans_box = DO_SHOW;
! 474: }
! 475: | ANS_BOX_SHOW '=' ANS_OFF { LexiProblem_p->show_ans_box = DONOT_SHOW;
! 476: }
! 477: | ANS_CALC '=' ANS_FMT { CurrAnsInfo.ans_calc = CALC_FORMATED;
! 478: }
! 479: | ANS_CALC '=' ANS_UNFMT { CurrAnsInfo.ans_calc = CALC_UNFORMATED;
! 480: }
! 481: | ANS_TRY '=' an_integer { assign_try_limits( $3 );
! 482: }
! 483: | ANS_TRY '=' IDENTIFIER { assign_try_limits( $3 );
! 484: }
! 485: | ANS_UNIT '=' S_CONSTANT { assign_units( $3 ); capa_mfree($3->s_str); capa_mfree((char *)$3);
! 486: }
! 487: | ANS_UNIT '=' IDENTIFIER { assign_units( $3 );
! 488: }
! 489: | ANS_EVAL '=' var_range { CurrAnsInfo.ans_pts_list = CurrPtsList;
! 490: CurrPtsList=NULL; LastPtsList = NULL;
! 491: }
! 492: ;
! 493:
! 494:
! 495: var_range : '<' S_CONSTANT '@' pt_list '>' { assign_id_list( $2 );
! 496: capa_mfree($2->s_str);
! 497: capa_mfree((char *)$2);
! 498: }
! 499: | '<' IDENTIFIER '@' pt_list '>' { assign_id_list( $2 ); }
! 500: ;
! 501:
! 502: pt_list : pt_list ',' point_coord { int idx;
! 503: idx = LastPtsList->pts_idx; idx++;
! 504: /*LastPtsList->pts_next = new_ptslist( $3 );*/
! 505: LastPtsList = LastPtsList->pts_next;
! 506: LastPtsList->pts_idx = idx;
! 507: CurrPtsList->pts_idx = idx;
! 508: if( $3->s_type == S_CONSTANT ) {
! 509: capa_mfree($3->s_str); capa_mfree((char *)$3);
! 510: }
! 511: }
! 512: | pt_list ',' pt_range { }
! 513: | point_coord { /*CurrPtsList = new_ptslist( $1 );*/
! 514: LastPtsList = CurrPtsList;
! 515: if( $1->s_type == S_CONSTANT ) {
! 516: capa_mfree($1->s_str); capa_mfree((char *)$1);
! 517: }
! 518: }
! 519: | pt_range { }
! 520: ;
! 521:
! 522: pt_range : point_coord ':' point_coord '#' IDENTIFIER
! 523: {
! 524: assign_pts($1,$3,$5);
! 525: /*PointsList_t *pt;
! 526: if( LastPtsList != NULL ) {
! 527: LastPtsList->pts_next = gen_ptslist( $1, $3, $5 );
! 528: pt = LastPtsList->pts_next;
! 529: while( pt->pts_next != NULL ) {
! 530: pt = pt->pts_next;
! 531: }
! 532: LastPtsList = pt;
! 533: } else {
! 534: CurrPtsList = gen_ptslist( $1, $3, $5 );
! 535: LastPtsList = CurrPtsList;
! 536: }
! 537: if( $1->s_type == S_CONSTANT ) {
! 538: capa_mfree($1->s_str); capa_mfree((char *)$1);
! 539: }
! 540: if( $3->s_type == S_CONSTANT ) {
! 541: capa_mfree($3->s_str); capa_mfree((char *)$3);
! 542: }
! 543: */
! 544: }
! 545: | point_coord ':' point_coord '#' ARRAY_ID '[' calc_expr ']'
! 546: { assign_pts($1,$3,get_array_symbol($5,$7,1)); }
! 547: | point_coord ':' point_coord '#' a_number
! 548: {
! 549: assign_pts($1,$3,$5);
! 550: /*PointsList_t *pt;
! 551:
! 552: if( LastPtsList != NULL ) {
! 553: LastPtsList->pts_next = gen_ptslist( $1, $3, $5 );
! 554: pt = LastPtsList->pts_next;
! 555: while( pt->pts_next != NULL ) {
! 556: pt = pt->pts_next;
! 557: }
! 558: LastPtsList = pt;
! 559: } else {
! 560: CurrPtsList = gen_ptslist( $1, $3, $5 );
! 561: LastPtsList = CurrPtsList;
! 562: }
! 563: if( $1->s_type == S_CONSTANT ) {
! 564: capa_mfree($1->s_str); capa_mfree((char *)$1);
! 565: }
! 566: if( $3->s_type == S_CONSTANT ) {
! 567: capa_mfree($3->s_str); capa_mfree((char *)$3);
! 568: }
! 569: if( $5->s_type == I_CONSTANT || $5->s_type == R_CONSTANT) {
! 570: capa_mfree((char *)$5);
! 571: }
! 572: */
! 573: }
! 574: ;
! 575:
! 576:
! 577: point_coord : IDENTIFIER { $$ = $1; }
! 578: | ARRAY_ID '[' calc_expr ']' { $$ = get_array_symbol($1,$3,1); }
! 579: | S_CONSTANT { $$ = $1; }
! 580: ;
! 581:
! 582:
! 583:
! 584: formated_ans : calc_expr { $1->s_distype = DEFAULT_FORMAT;
! 585: $$ = $1;
! 586: $1->s_format = NULL;
! 587: YYDBUG_PR2(" formated_ans := calc_expr (type %d)",$1->s_type);
! 588: }
! 589: | calc_expr FORMAT { $1->s_distype = $2->s_distype;
! 590: $1->s_format = strsave($2->s_str); /* **** */
! 591: capa_mfree($2->s_str); capa_mfree((char *)$2);
! 592: $$ = $1;
! 593: YYDBUG_PR1(" formated_ans <= calc_expr FORMAT");
! 594: }
! 595: ;
! 596:
! 597:
! 598:
! 599: answer_sig : an_integer { assign_sigs( $1->s_int,$1->s_int);
! 600: capa_mfree((char *)$1);
! 601: }
! 602: | an_integer ANS_PLUS an_integer
! 603: { assign_sigs($1->s_int,$1->s_int + $3->s_int);
! 604: capa_mfree((char *)$1); capa_mfree((char *)$3);
! 605: }
! 606: | an_integer ANS_MINUS an_integer
! 607: { assign_sigs($1->s_int - $3->s_int,$1->s_int);
! 608: capa_mfree((char *)$1); capa_mfree((char *)$3);
! 609: }
! 610: | an_integer ANS_PLUS an_integer ANS_MINUS an_integer
! 611: { assign_sigs($1->s_int - $5->s_int,$1->s_int + $3->s_int);
! 612: capa_mfree((char *)$1); capa_mfree((char *)$3); capa_mfree((char *)$5);
! 613: }
! 614: | an_integer ANS_MINUS an_integer ANS_PLUS an_integer
! 615: { assign_sigs($1->s_int - $3->s_int,$1->s_int + $5->s_int);
! 616: capa_mfree((char *)$1); capa_mfree((char *)$3); capa_mfree((char *)$5);
! 617: }
! 618: ;
! 619:
! 620: answer_comp : ANS_CS { CurrAnsInfo.ans_type = ANSWER_IS_STRING_CS; }
! 621: | ANS_CI { CurrAnsInfo.ans_type = ANSWER_IS_STRING_CI; }
! 622: | ANS_MC { CurrAnsInfo.ans_type = ANSWER_IS_CHOICE; }
! 623: | ANS_FORMULA { CurrAnsInfo.ans_type = ANSWER_IS_FORMULA; }
! 624: | ANS_EXTERNAL { CurrAnsInfo.ans_type = ANSWER_IS_EXTERNAL; }
! 625: ;
! 626:
! 627:
! 628: map_expr : startM '(' basic_constr ';' var_list ';' arg_list ')'
! 629: { char key[SMALL_LINE_BUFFER];
! 630: char warn_msg[WARN_MSG_LENGTH];
! 631: int result=0;
! 632:
! 633: YYDBUG_PR1(" map_expr body executed\n");
! 634: sprintf(key,"%ld",$3->s_int);
! 635: if( $5->s_argc == $7->s_argc ) {
! 636: /*result=do_map(key, $5->s_argp, $7->s_argp, $5->s_argc, FORWARD_MAP);*/
! 637: } else {
! 638: if ($5->s_argc==1) {
! 639: Symbol *a_sp;
! 640: a_sp=build_array_list($5,$7->s_argc);
! 641: /*result=do_map(key, a_sp->s_argp, $7->s_argp, a_sp->s_argc, FORWARD_MAP);*/
! 642: /*free_arglist(a_sp->s_argp);*/
! 643: } else {
! 644: sprintf(warn_msg,"/MAP arg. counts are not matched.\n");
! 645: capa_msg(MESSAGE_ERROR,warn_msg);
! 646: }
! 647: }
! 648: if (result!=0) {
! 649: sprintf(warn_msg,
! 650: "/MAP had invalid arguments.\n");
! 651: capa_msg(MESSAGE_ERROR,warn_msg);
! 652: }
! 653: /*free_arglist($5->s_argp);*/
! 654: /*free_arglist($7->s_argp);*/
! 655: }
! 656: | startR '(' basic_constr ';' var_list ';' arg_list ')'
! 657: { char key[SMALL_LINE_BUFFER];
! 658: char warn_msg[WARN_MSG_LENGTH];
! 659: int result=0;
! 660:
! 661: YYDBUG_PR1(" rmap_expr body executed\n");
! 662: sprintf(key,"%ld",$3->s_int);
! 663: if( $5->s_argc == $7->s_argc ) {
! 664: /*result=do_map(key, $5->s_argp, $7->s_argp, $5->s_argc, REVERSE_MAP);*/
! 665:
! 666: } else {
! 667: if ($5->s_argc==1) {
! 668: Symbol *a_sp;
! 669: a_sp=build_array_list($5,$7->s_argc);
! 670: /*result=do_map(key, a_sp->s_argp, $7->s_argp, a_sp->s_argc, FORWARD_MAP);*/
! 671: /*free_arglist(a_sp->s_argp);*/
! 672: } else {
! 673: sprintf(warn_msg,"/RMAP arg. counts are not matched.\n");
! 674: capa_msg(MESSAGE_ERROR,warn_msg);
! 675: }
! 676: }
! 677: if (result!=0) {
! 678: sprintf(warn_msg,
! 679: "/MAP had invalid arguments.\n");
! 680: capa_msg(MESSAGE_ERROR,warn_msg);
! 681: }
! 682: /*free_arglist($5->s_argp);*/
! 683: /*free_arglist($7->s_argp);*/
! 684: }
! 685: ;
! 686:
! 687:
! 688:
! 689: calc_expr : calc_expr EQ_op block { $$ = symbols_op($1, $3, EQ_op); }
! 690: | calc_expr NE_op block { $$ = symbols_op($1, $3, NE_op); }
! 691: | calc_expr GE_op block { $$ = symbols_op($1, $3, GE_op); }
! 692: | calc_expr GT_op block { $$ = symbols_op($1, $3, GT_op); }
! 693: | calc_expr LE_op block { $$ = symbols_op($1, $3, LE_op); }
! 694: | calc_expr LT_op block { $$ = symbols_op($1, $3, LT_op); }
! 695: | calc_expr AND_op block { $$ = symbols_op($1, $3, AND_op); }
! 696: | calc_expr OR_op block { $$ = symbols_op($1, $3, OR_op); }
! 697: | block { $$ = $1;
! 698: YYDBUG_PR1(" calc_expr <= block "); YYDBUG_SYM($1); }
! 699: ;
! 700:
! 701: block : block '+' term { $$ = symbols_op($1, $3, ADD_op); YYDBUG_PR1("block <= block '+' term "); YYDBUG_SYM($$); }
! 702: | block '-' term { $$ = symbols_op($1, $3, SUB_op); }
! 703: | term { $$ = $1; YYDBUG_PR2(" block <= term YYSTATE(%d) ",yystate); YYDBUG_SYM($1); }
! 704: ;
! 705:
! 706: term : term '*' basic_constr { $$ = symbols_op($1, $3, MUL_op); }
! 707: | term '/' basic_constr { $$ = symbols_op($1, $3, DIV_op); }
! 708: | term '%' basic_constr { $$ = symbols_op($1, $3, IDIV_op); }
! 709: | basic_constr { $$ = $1;
! 710: YYDBUG_PR1(" term <= basic_constr "); YYDBUG_SYM($1); }
! 711: ;
! 712:
! 713: basic_constr : FUNCTION_ID '(' ')' { int tmp;
! 714:
! 715: Func_idx--;
! 716: if(Func_idx >= 0 ) {
! 717: /*tmp = match_function(FuncStack[Func_idx].s_name,0);*/
! 718: /*$$ = do_function(tmp, 0, NULL );*/
! 719: capa_mfree(FuncStack[Func_idx].s_name);
! 720: }
! 721:
! 722: }
! 723: | FUNCTION_ID '(' arg_list ')'
! 724: { int tmp;
! 725:
! 726: Func_idx--;
! 727: YYDBUG_PR4(" basic_constr <= FUNCTION<%s><argc=%d> YYSTATE(%d) ",
! 728: FuncStack[Func_idx].s_name,$3->s_argc,yystate);
! 729:
! 730: if(Func_idx >= 0 ) {
! 731: /*tmp = match_function(FuncStack[Func_idx].s_name,$3->s_argc);*/
! 732: /*$$ = do_function(tmp, $3->s_argc, $3->s_argp);*/
! 733: capa_mfree(FuncStack[Func_idx].s_name);
! 734: /*free_arglist($3->s_argp);*/
! 735: }
! 736: YYDBUG_PR1(" basic_constr <= RETURN FUNCT "); YYDBUG_SYM($$);
! 737:
! 738: }
! 739: | an_array { $$ = $1; }
! 740: | IDENTIFIER { /* do not free identifier */
! 741: $$ = $1;
! 742: }
! 743: | '-' basic_constr { $$ = $2;
! 744: switch($2->s_type) {
! 745: case I_VAR: $$ = (Symbol *)capa_malloc(sizeof(Symbol),1);
! 746: $$->s_type = I_CONSTANT;
! 747: case I_CONSTANT: $$->s_int = - $2->s_int; break;
! 748: case R_VAR: $$ = (Symbol *)capa_malloc(sizeof(Symbol),1);
! 749: $$->s_type = R_CONSTANT;
! 750: case R_CONSTANT: $$->s_real = (-1.0)*($2->s_real);
! 751: break;
! 752: case S_VAR:
! 753: case S_CONSTANT: break;
! 754: default: break;
! 755: }
! 756: }
! 757: | '+' basic_constr { $$ = $2; }
! 758: | S_CONSTANT { $$ = $1; }
! 759: | a_number { $$ = $1; }
! 760: | '(' calc_expr ')' { $$ = $2; }
! 761: ;
! 762:
! 763: arg_list : arg_list ',' calc_expr { $$ = $1;
! 764: $$->s_argc++;
! 765: /*$$->s_argp = addto_arglist($1->s_argp, $3);*/
! 766: }
! 767: | calc_expr { $$ = $1;
! 768: $$->s_argc = 1;
! 769: /*$$->s_argp = new_arglist($1);*/
! 770: }
! 771: ;
! 772:
! 773:
! 774: var_list : IDENTIFIER { /* do not free identifier */
! 775: YYDBUG_PR1(" var_list <= ID");
! 776: $$ = $1;
! 777: $$->s_argc = 1;
! 778: /*$$->s_argp = new_arglist($1);*/
! 779: }
! 780: | ARRAY_ID '[' calc_expr ']'{
! 781: YYDBUG_PR1(" var_list <= ARRAYID,calc");
! 782: $$ = get_array_symbol($1,$3,1);
! 783: $$->s_argc = 1;
! 784: /*$$->s_argp = new_arglist($$);*/
! 785: }
! 786: | var_list ',' ARRAY_ID '[' calc_expr ']' {
! 787: YYDBUG_PR1(" var_list <= var_list,ARRAYID,calc");
! 788: $$ = $1;
! 789: $$->s_argc++;
! 790: /*$$->s_argp = addto_arglist($1->s_argp,
! 791: get_array_symbol($3,$5,1));*/
! 792: }
! 793: | var_list ',' IDENTIFIER { /* do not free identifier */
! 794: YYDBUG_PR1(" var_list <= var_list,ID");
! 795: $$ = $1;
! 796: $$->s_argc++;
! 797: /*$$->s_argp = addto_arglist($1->s_argp, $3);*/
! 798: }
! 799: ;
! 800:
! 801:
! 802: a_number : an_integer { $$ = $1; }
! 803: | a_real { $$ = $1; }
! 804: ;
! 805:
! 806: an_integer : I_CONSTANT { $$ = $1; }
! 807: ;
! 808:
! 809: a_real : R_CONSTANT { $$ = $1; }
! 810: ;
! 811:
! 812: an_array : ARRAY_ID '[' calc_expr ']' {
! 813: YYDBUG_PR1(" an_array <= ARRAY_ID '['calc_expr ']' ");
! 814: $$=get_array_symbol($1,$3,1);
! 815: }
! 816: ;
! 817:
! 818: startQ : { /* first matching will occur before first line of input text */
! 819: YYDBUG_PR1(" startQ := begin_question\n");
! 820: begin_question(); Answer_infospec = 0;
! 821: }
! 822: ;
! 823:
! 824:
! 825:
! 826: %%
! 827: /* ============================================================================ */
! 828: ExpNode_p
! 829: mk_node(op, left, right) int op; ExpNode_p left; ExpNode_p right;
! 830: {
! 831: ExpNode *np;
! 832:
! 833: np = (ExpNode* )malloc(sizeof(ExpNode));
! 834: np->e_type = op;
! 835: np->e_lsibp = left;
! 836: np->e_rsibp = right;
! 837: left->e_parentp = np;
! 838: right->e_parentp = np;
! 839: return (np);
! 840: }
! 841:
! 842: ExpNode_p
! 843: mk_leaf(type, valp) int type; Symbol_p valp;
! 844: {
! 845: ExpNode *np;
! 846:
! 847: np = (ExpNode*)malloc(sizeof(ExpNode));
! 848: np->e_type = IDENTIFIER;
! 849: np->e_sp = valp;
! 850: return (np);
! 851:
! 852: }
! 853:
! 854: /* ------------------------------------------------------------- */
! 855: void free_calc_expr(Symbol *expr)
! 856: {
! 857: switch(expr->s_type) {
! 858: case I_CONSTANT:
! 859: case R_CONSTANT: capa_mfree((char *)expr); break;
! 860: case S_CONSTANT: capa_mfree(expr->s_str); capa_mfree((char *)expr); break;
! 861: default: break;
! 862: }
! 863: }
! 864:
! 865: /* this is the entry point to array symbol retrieval */
! 866: /* array main name and index are used to locate the symbol */
! 867: /* name of the array is used to retrieve the array symbol */
! 868:
! 869: Symbol* get_array_symbol ( name,index,free_symbols )
! 870: Symbol *name,*index;int free_symbols;
! 871: {
! 872: Symbol *s_p, *a_p;
! 873: char *key, *tmp;
! 874: int leng, idx_len;
! 875: leng = strlen(name->s_name)+8; /* [ ] */
! 876:
! 877: switch(index->s_type) {
! 878: case I_VAR:
! 879: case I_CONSTANT: tmp = (char *)capa_malloc(64,1);
! 880: sprintf(tmp,"%ld",index->s_int);
! 881: break;
! 882: case R_VAR:
! 883: case R_CONSTANT: tmp = (char *)capa_malloc(64,1);
! 884: sprintf(tmp,"%g",index->s_real);
! 885: break;
! 886: case S_VAR:
! 887: case S_CONSTANT: idx_len = strlen(index->s_str); tmp = (char *)capa_malloc(idx_len+4,1);
! 888: sprintf(tmp,"\"%s\"",index->s_str); /* string array index is a bit different from integer one */
! 889: break;
! 890: default: break;
! 891: }
! 892: idx_len = strlen(tmp);
! 893:
! 894: key = (char *)capa_malloc(idx_len+leng,1);
! 895: sprintf(key,"%s[%s]",name->s_name,tmp);
! 896:
! 897: /*a_p = find_arrayid(name->s_name);*/ /* use the array name to search array tree */
! 898: /* did not check for error! */
! 899: /*s_p = find_array_by_index(a_p,key);*/ /* use the index portion to search along array linked list */
! 900: capa_mfree((char *)tmp); capa_mfree((char *)key);
! 901:
! 902: if (free_symbols) { /* free both the name symbol and index symbol */
! 903: if( (index->s_type == I_CONSTANT) || (index->s_type == R_CONSTANT) )
! 904: capa_mfree((char *)index);
! 905: if(index->s_type == S_CONSTANT) {
! 906: capa_mfree(index->s_str); capa_mfree((char *)index);
! 907: }
! 908: capa_mfree(name->s_name); capa_mfree((char *)name);
! 909: }
! 910: return (s_p);
! 911: }
! 912:
! 913: Symbol * build_array_list(ar_name,num_elem)
! 914: Symbol *ar_name;int num_elem;
! 915: {
! 916: int i;
! 917: Symbol *arg_list,*a_p;
! 918: char idx_str[MAX_BUFFER_SIZE];
! 919:
! 920: /*a_p = find_arrayid(ar_name->s_name);*/
! 921: i = 1;
! 922: sprintf(idx_str,"%s[%d]",ar_name->s_name,i); /* create array elements with integer index */
! 923: /*arg_list = find_array_by_index(a_p,idx_str);*/ /* will create a new element if not found */
! 924: arg_list->s_argc=1;
! 925: /*arg_list->s_argp=new_arglist(arg_list);*/
! 926:
! 927: for (i=2;i<=num_elem;i++) {
! 928: sprintf(idx_str,"%s[%d]",ar_name->s_name,i);
! 929: arg_list->s_argc++;
! 930: /*arg_list->s_argp=addto_arglist(arg_list->s_argp,find_array_by_index(a_p,idx_str));*/
! 931: }
! 932: return arg_list;
! 933: }
! 934:
! 935:
! 936:
! 937:
! 938:
! 939:
! 940:
! 941: /* ------------------------------------------------------------- */
! 942: void
! 943: append_text(str) char *str;
! 944: {
! 945: char *q;
! 946: int i;
! 947:
! 948: if (!LexiProblem_p->question) {
! 949: if (!(q = capa_malloc(strlen(str)+1,1))) printf("No room to append.");
! 950: strncpy(q,str,strlen(str)+1);
! 951: } else {
! 952: i = strlen(LexiProblem_p->question);
! 953: i += (strlen(str)+1);
! 954: q = capa_malloc(i,1); /* *** */
! 955: if (!q) printf("No room to append().");
! 956: strcat(strncpy(q,LexiProblem_p->question, strlen(LexiProblem_p->question)+1), str);
! 957: capa_mfree(LexiProblem_p->question);
! 958: }
! 959: LexiProblem_p->question=q;
! 960: }
! 961:
! 962: /******************************************************************************/
! 963: /* ADD A STRING TO THE CURRENT HINT TEXT BLOCK */
! 964: /******************************************************************************/
! 965: void /* RETURNS: nothing */
! 966: append_hint(str) /* ARGUMENTS: */
! 967: char *str; /* String to add */
! 968: { /* LOCAL VARIABLES: */
! 969: char *q; /* New string */
! 970:
! 971: if (!LexiProblem_p->hint) {
! 972: if (!(q = capa_malloc(strlen(str)+1,1)))
! 973: printf("no room");
! 974: strncpy(q,str,strlen(str)+1);
! 975: } else {
! 976: if (!(q = capa_malloc(strlen(LexiProblem_p->hint)+strlen(str)+1,1)))
! 977: printf("no room");
! 978: strcat(strncpy(q,LexiProblem_p->hint,strlen(LexiProblem_p->hint)), str);
! 979: capa_mfree(LexiProblem_p->hint);
! 980: }
! 981: LexiProblem_p->hint=q;
! 982: /* printf("APPEND HINT: %s\n", str); */
! 983: }
! 984: /******************************************************************************/
! 985: /* ADD A STRING TO THE CURRENT EXPLAIN TEXT BLOCK */
! 986: /******************************************************************************/
! 987: void /* RETURNS: nothing */
! 988: append_explain(str) /* ARGUMENTS: */
! 989: char *str; /* String to add */
! 990: { /* LOCAL VARIABLES: */
! 991: char *q; /* New string */
! 992:
! 993: if (!LexiProblem_p->explain) {
! 994: if (!(q = capa_malloc(strlen(str)+1,1)))
! 995: printf("no room");
! 996: strncpy(q,str, strlen(str)+1);
! 997: } else {
! 998: if (!(q = capa_malloc(strlen(LexiProblem_p->explain)+strlen(str)+1,1)))
! 999: printf("no room");
! 1000: strcat(strncpy(q,LexiProblem_p->explain,strlen(LexiProblem_p->explain)+1), str);
! 1001: capa_mfree(LexiProblem_p->explain);
! 1002: }
! 1003: LexiProblem_p->explain=q;
! 1004: /* printf("APPEND EXPLAIN: %s\n", str); */
! 1005: }
! 1006:
! 1007: void
! 1008: append_error(str) char *str;
! 1009: {
! 1010: char *q;
! 1011: int i;
! 1012:
! 1013: ErrorMsg_count++;
! 1014: if (!ErrorMsg_p) {
! 1015: if (!(q = capa_malloc(strlen(str)+1,1))) printf("No room in append.");
! 1016: strncpy(q,str,strlen(str)+1);
! 1017: } else {
! 1018: i = strlen(ErrorMsg_p);
! 1019: i += (strlen(str)+1);
! 1020: q = capa_malloc(i,1); /* *** */
! 1021: if (!q) printf("No room in append()");
! 1022: strcat(strncpy(q,ErrorMsg_p, strlen(ErrorMsg_p)+1), str);
! 1023: capa_mfree(ErrorMsg_p);
! 1024: }
! 1025: ErrorMsg_p=q;
! 1026: /* printf("APPEND ERROR: %s\n", str); */
! 1027: }
! 1028: void
! 1029: append_warn(type,str) int type;char *str;
! 1030: {
! 1031: WarnMsg_t *p, *t;
! 1032: char *q;
! 1033:
! 1034: WarnMsg_count++;
! 1035: if (!WarnMsg_p) {
! 1036: if (!(p = (WarnMsg_t *)capa_malloc(sizeof(WarnMsg_t),1))) printf("No room in create WarnMsg_t.");
! 1037: if (!(q = capa_malloc(strlen(str)+1,1))) printf("No room in allocating space for warn msg.");
! 1038: strncpy(q,str,strlen(str)+1);
! 1039: p->warn_next = NULL;
! 1040: p->warn_type = type;
! 1041: p->warn_str = q;
! 1042: WarnMsg_p=p;
! 1043: } else {
! 1044: for(t=WarnMsg_p;t->warn_next;t=t->warn_next) { } /* do nothing within for loop */
! 1045: if (!(p = (WarnMsg_t *)capa_malloc(sizeof(WarnMsg_t),1))) printf("No room in create WarnMsg_t.");
! 1046: if (!(q = capa_malloc(strlen(str)+1,1))) printf("No room in allocating space for warn msg.");
! 1047: strncpy(q,str,strlen(str)+1);
! 1048: p->warn_next = NULL;
! 1049: p->warn_type = type;
! 1050: p->warn_str = q;
! 1051: t->warn_next = p;
! 1052: }
! 1053: }
! 1054:
! 1055: /*****************************************************************************/
! 1056: /*********** if *b is a constant symbol, destroy (free) b ********************/
! 1057: /*********** if *a is a var symbol, create a new symbol **********************/
! 1058: /* do not free(*a) */
! 1059: /* If either a or b is invalid it propagates the error up the parse tree */
! 1060: Symbol *
! 1061: symbols_op(a, b, op) Symbol *a; Symbol *b; int op;
! 1062: {
! 1063: int type, new, leng;
! 1064: long tmp_i, tmp_j;
! 1065: double tmp_p, tmp_q;
! 1066: char a_str[QUARTER_K], *b_str=NULL, *r_strp;
! 1067: char warn_msg[ONE_K];
! 1068: Symbol *a_symp;
! 1069:
! 1070: if( a->s_type == IDENTIFIER || b->s_type == IDENTIFIER ) {
! 1071: if(a->s_type == IDENTIFIER) { /* a is IDENTIFIER */
! 1072: sprintf(warn_msg,"var \"%s\" not defined before use.\n", a->s_name);
! 1073: capa_msg(MESSAGE_ERROR,warn_msg);
! 1074: return (a);
! 1075: } else { /* b is IDENTIFIER */
! 1076: sprintf(warn_msg,"var \"%s\" not defined before use.\n",b->s_name);
! 1077: capa_msg(MESSAGE_ERROR,warn_msg);
! 1078: return (b);
! 1079: }
! 1080: } else { /* a and b are neither identifiers */
! 1081: if( (a->s_type == I_VAR) ||
! 1082: (a->s_type == R_VAR) ||
! 1083: (a->s_type == S_VAR) ) {
! 1084: a_symp = (Symbol *)capa_malloc(sizeof(Symbol),1); /* *** */
! 1085: new = 1;
! 1086: } else {
! 1087: new = 0;
! 1088: a_symp = a; /* re-use symbol *a */
! 1089: }
! 1090: if( ((a->s_type == I_CONSTANT)||(a->s_type == I_VAR)) &&
! 1091: ((b->s_type == I_CONSTANT)||(b->s_type == I_VAR)) ) { /* both a and b are integer */
! 1092: type = I_CONSTANT;
! 1093: switch( op ) {
! 1094: case ADD_op: a_symp->s_int = a->s_int + b->s_int ; break;
! 1095: case SUB_op: a_symp->s_int = a->s_int - b->s_int ; break;
! 1096: case MUL_op: a_symp->s_int = a->s_int * b->s_int ; break;
! 1097: case DIV_op: if(b->s_int != 0) {
! 1098: a_symp->s_int = a->s_int / b->s_int ;
! 1099: } else {
! 1100: sprintf(warn_msg,"division (/) by zero!\n");
! 1101: capa_msg(MESSAGE_ERROR,warn_msg);
! 1102: } break;
! 1103: case IDIV_op: if(b->s_int != 0) {
! 1104: a_symp->s_int = (a->s_int % b->s_int );
! 1105: } else {
! 1106: sprintf(warn_msg,"integer division (%%) by zero!\n");
! 1107: capa_msg(MESSAGE_ERROR,warn_msg);
! 1108: } break;
! 1109: case EQ_op: a_symp->s_int = ((a->s_int == b->s_int)? 1: 0); break;
! 1110: case NE_op: a_symp->s_int = ((a->s_int == b->s_int)? 0: 1); break;
! 1111: case GT_op: a_symp->s_int = ((a->s_int > b->s_int)? 1: 0); break;
! 1112: case GE_op: a_symp->s_int = ((a->s_int >= b->s_int)? 1: 0); break;
! 1113: case LT_op: a_symp->s_int = ((a->s_int < b->s_int)? 1: 0); break;
! 1114: case LE_op: a_symp->s_int = ((a->s_int <= b->s_int)? 1: 0); break;
! 1115: case AND_op: a_symp->s_int = ((a->s_int && b->s_int)? 1: 0); break;
! 1116: case OR_op: a_symp->s_int = ((a->s_int || b->s_int)? 1: 0); break;
! 1117: }
! 1118: } else { /* a, b neither are integers */
! 1119: if( (a->s_type == S_VAR) || (a->s_type == S_CONSTANT) ||
! 1120: (b->s_type == S_VAR) || (b->s_type == S_CONSTANT) ) { /* either a or b is a string */
! 1121: type = S_CONSTANT; /* the return type is a string */
! 1122: if( (a->s_type == S_VAR) || (a->s_type == S_CONSTANT) ) { /* a is a string */
! 1123: if (a->s_str == NULL ||
! 1124: (((b->s_type == S_VAR) || (b->s_type == S_CONSTANT)) && b->s_str == NULL)) {
! 1125: if (a->s_str == NULL) {
! 1126: sprintf(warn_msg,"variable %s has not yet been assigned a value.\n",a->s_name);
! 1127: capa_msg(MESSAGE_ERROR,warn_msg);
! 1128: }
! 1129: if (((b->s_type == S_VAR) || (b->s_type == S_CONSTANT)) && b->s_str == NULL) {
! 1130: sprintf(warn_msg,"variable %s has not yet been assigned a value.\n",a->s_name);
! 1131: capa_msg(MESSAGE_ERROR,warn_msg);
! 1132: }
! 1133: } else { /* a is a valid string */
! 1134: switch( b->s_type ) {
! 1135: case I_VAR:
! 1136: case I_CONSTANT:
! 1137: leng = SMALL_LINE_BUFFER; /* assuming a long integer does not exceed 128 digits*/
! 1138: b_str= capa_malloc(sizeof(char), leng);
! 1139: sprintf(b_str,"%ld", b->s_int);
! 1140: break;
! 1141: case R_VAR:
! 1142: case R_CONSTANT:
! 1143: leng = SMALL_LINE_BUFFER;/*assuming a double does not exceed128chars*/
! 1144: b_str= capa_malloc(sizeof(char), leng);
! 1145: sprintf(b_str,"%.15g", b->s_real);
! 1146: break;
! 1147: case S_VAR:
! 1148: case S_CONSTANT: /* DONE: get rid of limitations on b_str[] */
! 1149: leng = strlen( b->s_str ) + 1;
! 1150: b_str= capa_malloc(sizeof(char), leng);
! 1151: sprintf(b_str,"%s",b->s_str);
! 1152: /*if(b->s_type == S_CONSTANT) capa_mfree(b->s_str);*/
! 1153: break;
! 1154: }
! 1155: switch( op ) {
! 1156: case ADD_op:
! 1157: leng = strlen( a->s_str ) + strlen(b_str) + 1;
! 1158: r_strp = capa_malloc(sizeof(char), leng); /* **** */
! 1159: strcat(r_strp, a->s_str);
! 1160: strcat(r_strp, b_str); /* concatenate two strings together */
! 1161: if( !new ) capa_mfree(a->s_str);
! 1162: a_symp->s_str = r_strp;
! 1163: break;
! 1164: case SUB_op:
! 1165: case MUL_op:
! 1166: case DIV_op:
! 1167: case IDIV_op:
! 1168: if( !new ) capa_mfree(a->s_str);
! 1169: a_symp->s_str = strsave("<<Op NOT DEFINED>>");
! 1170: sprintf(warn_msg,"integer division (%%) cannot accept string operand!\n");
! 1171: capa_msg(MESSAGE_ERROR,warn_msg);
! 1172: break;
! 1173: case EQ_op: a_symp->s_int = (strcmp(a->s_str, b_str) == 0? 1: 0);
! 1174: type = I_CONSTANT; break;
! 1175: case NE_op: a_symp->s_int = (strcmp(a->s_str, b_str) == 0? 0: 1);
! 1176: type = I_CONSTANT; break;
! 1177: case GT_op: a_symp->s_int = (strcmp(a->s_str, b_str) > 0? 1: 0);
! 1178: type = I_CONSTANT; break;
! 1179: case GE_op: a_symp->s_int = (strcmp(a->s_str, b_str) >= 0? 1: 0);
! 1180: type = I_CONSTANT; break;
! 1181: case LT_op: a_symp->s_int = (strcmp(a->s_str, b_str) < 0? 1: 0);
! 1182: type = I_CONSTANT; break;
! 1183: case LE_op: a_symp->s_int = (strcmp(a->s_str, b_str) <= 0? 1: 0);
! 1184: type = I_CONSTANT; break;
! 1185: case AND_op:
! 1186: if( (a->s_str[0] != 0) && (b_str[0] != 0)) {
! 1187: a_symp->s_int = 1;
! 1188: } else {
! 1189: a_symp->s_int = 0;
! 1190: }
! 1191: type = I_CONSTANT; break;
! 1192: case OR_op:
! 1193: if( (a->s_str[0] != 0) || (b_str[0] != 0)) {
! 1194: a_symp->s_int = 1;
! 1195: } else {
! 1196: a_symp->s_int = 0;
! 1197: }
! 1198: type = I_CONSTANT; break;
! 1199: }
! 1200: }
! 1201: if (b_str!=NULL) capa_mfree(b_str);
! 1202: } else { /* b is string and a is either integer or real */
! 1203: switch( a->s_type ) {
! 1204: case I_VAR:
! 1205: case I_CONSTANT:
! 1206: sprintf(a_str,"%ld", a->s_int); break;
! 1207: case R_VAR:
! 1208: case R_CONSTANT:
! 1209: sprintf(a_str,"%.15g", a->s_real); break;
! 1210: }
! 1211: switch( op ) {
! 1212: case ADD_op:
! 1213: leng = strlen( b->s_str ) + strlen(a_str) + 1;
! 1214: r_strp = capa_malloc(sizeof(char), leng); /* *** */
! 1215: strcat(r_strp, a_str);
! 1216: strcat(r_strp, b->s_str);
! 1217: /*if( b->s_type == S_CONSTANT ) capa_mfree(b->s_str);*/
! 1218: a_symp->s_str = r_strp; break;
! 1219: case SUB_op:
! 1220: case MUL_op:
! 1221: case DIV_op:
! 1222: case IDIV_op:
! 1223: a_symp->s_str = strsave("<<Op NOT DEFINED>>");
! 1224: sprintf(warn_msg,"integer division (%%) cannot accept string operand!\n");
! 1225: capa_msg(MESSAGE_ERROR,warn_msg);
! 1226: break;
! 1227: case EQ_op: a_symp->s_int = (strcmp(a_str, b->s_str) == 0? 1: 0);
! 1228: type = I_CONSTANT; break;
! 1229: case NE_op: a_symp->s_int = (strcmp(a_str, b->s_str) == 0? 0: 1);
! 1230: type = I_CONSTANT; break;
! 1231: case GT_op: a_symp->s_int = (strcmp(a_str, b->s_str) > 0? 1: 0);
! 1232: type = I_CONSTANT; break;
! 1233: case GE_op: a_symp->s_int = (strcmp(a_str, b->s_str) >= 0? 1: 0);
! 1234: type = I_CONSTANT; break;
! 1235: case LT_op: a_symp->s_int = (strcmp(a_str, b->s_str) < 0? 1: 0);
! 1236: type = I_CONSTANT; break;
! 1237: case LE_op: a_symp->s_int = (strcmp(a_str,b->s_str) <= 0? 1: 0);
! 1238: type = I_CONSTANT; break;
! 1239: case AND_op: if( (a_str[0] != 0) && (b->s_str[0] != 0)) {
! 1240: a_symp->s_int = 1;
! 1241: } else {
! 1242: a_symp->s_int = 0;
! 1243: }
! 1244: type = I_CONSTANT; break;
! 1245: case OR_op: if( (a_str[0] != 0) || (b_str[0] != 0)) {
! 1246: a_symp->s_int = 1;
! 1247: } else {
! 1248: a_symp->s_int = 0;
! 1249: }
! 1250: type = I_CONSTANT; break;
! 1251: }
! 1252: }
! 1253:
! 1254: } else { /* both a and b are real */
! 1255: type = R_CONSTANT;
! 1256: if( (a->s_type == R_CONSTANT)||(a->s_type == R_VAR) ) {
! 1257: tmp_p = a->s_real;
! 1258: } else {
! 1259: tmp_p = (double)a->s_int;
! 1260: }
! 1261: if( (b->s_type == R_CONSTANT)||(b->s_type == R_VAR) ) {
! 1262: tmp_q = b->s_real;
! 1263: } else {
! 1264: tmp_q = (double)b->s_int;
! 1265: }
! 1266: switch( op ) {
! 1267: case ADD_op: a_symp->s_real = tmp_p + tmp_q ; break;
! 1268: case SUB_op: a_symp->s_real = tmp_p - tmp_q ; break;
! 1269: case MUL_op: a_symp->s_real = tmp_p * tmp_q ; break;
! 1270: case DIV_op: if(tmp_q != 0.0) {
! 1271: a_symp->s_real = tmp_p / tmp_q ;
! 1272: } else {
! 1273: /* printf("FDIVISION by ZERO\n"); */
! 1274: sprintf(warn_msg,"division (/) by zero!\n");
! 1275: capa_msg(MESSAGE_ERROR,warn_msg);
! 1276: }
! 1277: break;
! 1278: case IDIV_op: if(tmp_q != 0.0 ) {
! 1279: tmp_i = (long)tmp_p;
! 1280: tmp_j = (long)tmp_q;
! 1281: a_symp->s_int = tmp_i % tmp_j;
! 1282: type = I_CONSTANT;
! 1283: } else {
! 1284: /* printf("DIVISION by ZERO\n"); */
! 1285: sprintf(warn_msg,"division (/) by zero!\n");
! 1286: capa_msg(MESSAGE_ERROR,warn_msg);
! 1287: }
! 1288: break;
! 1289: case EQ_op: type = I_CONSTANT;
! 1290: a_symp->s_int = ((tmp_p == tmp_q)? 1: 0); break;
! 1291: case NE_op: type = I_CONSTANT;
! 1292: a_symp->s_int = ((tmp_p == tmp_q)? 0: 1); break;
! 1293: case GT_op: type = I_CONSTANT;
! 1294: a_symp->s_int = ((tmp_p > tmp_q)? 1: 0); break;
! 1295: case GE_op: type = I_CONSTANT;
! 1296: a_symp->s_int = ((tmp_p >= tmp_q)? 1: 0); break;
! 1297: case LT_op: type = I_CONSTANT;
! 1298: a_symp->s_int = ((tmp_p < tmp_q)? 1: 0); break;
! 1299: case LE_op: type = I_CONSTANT;
! 1300: a_symp->s_int = ((tmp_p <= tmp_q)? 1: 0); break;
! 1301: case AND_op: type = I_CONSTANT;
! 1302: a_symp->s_int = ((tmp_p && tmp_q)? 1: 0); break;
! 1303: case OR_op: type = I_CONSTANT;
! 1304: a_symp->s_int = ((tmp_p || tmp_q)? 1: 0); break;
! 1305: }
! 1306: }
! 1307: }
! 1308: if( (b->s_type == I_CONSTANT) ||
! 1309: (b->s_type == R_CONSTANT) ) capa_mfree((char *)b); /* free symbol *b only */
! 1310: if( (b->s_type == S_CONSTANT) ) {
! 1311: capa_mfree((char *)b->s_str);
! 1312: capa_mfree((char *)b);
! 1313: }
! 1314: a_symp->s_type = type;
! 1315: return (a_symp);
! 1316: }
! 1317: }
! 1318:
! 1319: /* ------------------------------------------------------ */
! 1320: char *
! 1321: format_toTeX( real ) char *real;
! 1322: {
! 1323: int idx, length, fraclength, i_exp;
! 1324: char *expo_p, fracS[SMALL_LINE_BUFFER], result[ONE_K], *areal;
! 1325: char warn_msg[WARN_MSG_LENGTH];
! 1326:
! 1327: length = strlen(real);
! 1328: if( index( real, 'e' ) == NULL ) {
! 1329: if( index( real, 'E' ) == NULL ) {
! 1330: sprintf(result,"%s", real);
! 1331: } else {
! 1332: expo_p = index(real, 'E'); /*** hpux complained */
! 1333: fraclength = length - strlen(expo_p);
! 1334: expo_p++; if(expo_p[0] == '+') expo_p++;
! 1335: sscanf(expo_p,"%d",&i_exp);
! 1336: for(idx=0;idx<fraclength;idx++) fracS[idx] = real[idx];
! 1337: fracS[fraclength] = 0;
! 1338: if(i_exp == 0 ) {
! 1339: sprintf(result,"$%s$", fracS);
! 1340: } else {
! 1341: sprintf(result,"$%s \\times 10^{%d}$", fracS, i_exp);
! 1342: }
! 1343: }
! 1344: } else {
! 1345: if( index( real, 'E' ) == NULL ) {
! 1346: expo_p = index(real, 'e'); /*** hpux complained */
! 1347: fraclength = length - strlen(expo_p);
! 1348: expo_p++; if(expo_p[0] == '+') expo_p++;
! 1349: sscanf(expo_p,"%d",&i_exp);
! 1350: for(idx=0;idx<fraclength;idx++) fracS[idx] = real[idx];
! 1351: fracS[fraclength] = 0;
! 1352: if(i_exp == 0 ) {
! 1353: sprintf(result,"$%s$", fracS);
! 1354: } else {
! 1355: sprintf(result,"$%s \\times 10^{%d}$", fracS, i_exp);
! 1356: }
! 1357: } else {
! 1358: sprintf(result,"<<Ill-formed REAL>>");
! 1359: sprintf(warn_msg,"number %s is not a valid real number!\n",real);
! 1360: capa_msg(MESSAGE_ERROR,warn_msg);
! 1361: }
! 1362: }
! 1363: areal = (char *) capa_malloc(strlen(result)+1, 1);
! 1364: strcpy(areal,result);
! 1365: return (areal);
! 1366: }
! 1367: /* ------------------------------------------------------ */
! 1368: char *
! 1369: format_toHTML( real ) char *real;
! 1370: {
! 1371: int idx, length, fraclength, i_exp;
! 1372: char *expo_p, fracS[SMALL_LINE_BUFFER], result[ONE_K], *areal;
! 1373: char warn_msg[WARN_MSG_LENGTH];
! 1374:
! 1375: length = strlen(real);
! 1376: if( index( real, 'e' ) == NULL ) {
! 1377: if( index( real, 'E' ) == NULL ) {
! 1378: sprintf(result,"%s", real);
! 1379: } else {
! 1380: expo_p = index(real, 'E'); /*** hpux complained */
! 1381: fraclength = length - strlen(expo_p);
! 1382: expo_p++; if(expo_p[0] == '+') expo_p++;
! 1383: sscanf(expo_p,"%d",&i_exp);
! 1384: for(idx=0;idx<fraclength;idx++) fracS[idx] = real[idx];
! 1385: fracS[fraclength] = 0;
! 1386: if(i_exp == 0 ) {
! 1387: sprintf(result,"%s", fracS);
! 1388: } else {
! 1389: sprintf(result,"%s×10<sup>%d</sup>", fracS, i_exp); /* × is code for x */
! 1390: }
! 1391: }
! 1392: } else { /* the string contains 'e' char */
! 1393: if( index( real, 'E' ) == NULL ) {
! 1394: expo_p = index(real, 'e'); /*** hpux complained */
! 1395: fraclength = length - strlen(expo_p);
! 1396: expo_p++; if(expo_p[0] == '+') expo_p++;
! 1397: sscanf(expo_p,"%d",&i_exp);
! 1398: for(idx=0;idx<fraclength;idx++) fracS[idx] = real[idx];
! 1399: fracS[fraclength] = 0;
! 1400: if(i_exp == 0 ) {
! 1401: sprintf(result,"%s", fracS);
! 1402: } else {
! 1403: sprintf(result,"%s×10<sup>%d</sup>", fracS, i_exp); /* × is code for x */
! 1404: }
! 1405: } else {
! 1406: sprintf(result,"<<Ill-formed REAL>>");
! 1407: sprintf(warn_msg,"number %s is not a valid real number!\n",real);
! 1408: capa_msg(MESSAGE_ERROR,warn_msg);
! 1409: }
! 1410: }
! 1411: areal = (char *) capa_malloc(strlen(result)+1, 1);
! 1412: strcpy(areal,result);
! 1413: return (areal);
! 1414: }
! 1415: /* -- This routine is called when a /ANS is encountered -- */
! 1416: void
! 1417: init_answerinfo()
! 1418: {
! 1419:
! 1420: CurrAnsInfo.ans_str = NULL;
! 1421: CurrAnsInfo.ans_type = 0;
! 1422: CurrAnsInfo.ans_calc = CALC_DEFAULT;
! 1423: CurrAnsInfo.ans_tol_type = TOL_ABSOLUTE;
! 1424: CurrAnsInfo.ans_tol = TOL_DEFAULT;
! 1425: CurrAnsInfo.ans_sig_ub = SIG_UB_DEFAULT;
! 1426: CurrAnsInfo.ans_sig_lb = SIG_LB_DEFAULT;
! 1427: CurrAnsInfo.ans_id_list = NULL;
! 1428: CurrAnsInfo.ans_pts_list = NULL;
! 1429: CurrAnsInfo.ans_fmt[0] = '\0';
! 1430: CurrAnsInfo.ans_unit_str[0] = '\0';
! 1431: CurrAnsInfo.ans_unit = NULL;
! 1432: CurrAnsInfo.ans_next = NULL;
! 1433: }
! 1434: /* when encountered a /DIS(variable) */
! 1435: void
! 1436: display_var( s )Symbol *s;
! 1437: {
! 1438: char *aline;
! 1439: char *tmp_p;
! 1440: char warn_msg[WARN_MSG_LENGTH];
! 1441:
! 1442:
! 1443: switch(s->s_type) {
! 1444: case IDENTIFIER:
! 1445: aline = (char *)capa_malloc(sizeof(char)*ONE_K,1);
! 1446: sprintf(aline,"VAR \"%s\" NOT DEFINED!", s->s_name);
! 1447: sprintf(warn_msg,"display var \"%s\" not defined before use.\n",s->s_name);
! 1448: capa_msg(MESSAGE_ERROR,warn_msg);
! 1449: break;
! 1450: case I_VAR: case I_CONSTANT:
! 1451: aline = (char *)capa_malloc(sizeof(char)*ONE_K,1);
! 1452: sprintf(aline, "%ld", s->s_int);
! 1453: break;
! 1454: case R_VAR: case R_CONSTANT:
! 1455: aline = (char *)capa_malloc(sizeof(char)*ONE_K,1);
! 1456: if(Parsemode_f == TeX_MODE) {
! 1457: if(s->s_distype == DEFAULT_FORMAT ) {
! 1458: sprintf(aline,"%.15g",s->s_real);
! 1459: } else {
! 1460: sprintf(aline,s->s_format,s->s_real);
! 1461: }
! 1462: tmp_p = format_toTeX(aline);
! 1463: sprintf(aline,"%s",tmp_p);
! 1464: capa_mfree( (char *)tmp_p);
! 1465:
! 1466: } else {
! 1467: if(Parsemode_f == HTML_MODE ) {
! 1468: if(s->s_distype == DEFAULT_FORMAT ) {
! 1469: sprintf(aline,"%.15g",s->s_real);
! 1470: } else {
! 1471: sprintf(aline,s->s_format,s->s_real);
! 1472: }
! 1473: tmp_p = format_toHTML(aline);
! 1474: sprintf(aline,"%s",tmp_p);
! 1475: capa_mfree( (char *)tmp_p);
! 1476: } else {
! 1477: if(s->s_distype == DEFAULT_FORMAT ) {
! 1478: sprintf(aline,"%.15g",s->s_real);
! 1479: } else {
! 1480: sprintf(aline,s->s_format,s->s_real);
! 1481: }
! 1482: }
! 1483: }
! 1484: break;
! 1485: case S_VAR: case S_CONSTANT:
! 1486: if (s->s_str == NULL) {
! 1487: sprintf(warn_msg,"variable %s has not yet been assigned a value.\n",
! 1488: s->s_name);
! 1489: capa_msg(MESSAGE_ERROR,warn_msg);
! 1490: aline=(char *)capa_malloc(9,1);
! 1491: sprintf(aline,"NO VALUE");
! 1492: } else {
! 1493: aline = (char *)capa_malloc(strlen(s->s_str)+1,1);
! 1494: sprintf(aline,"%s",s->s_str);
! 1495: }
! 1496: break;
! 1497: }
! 1498: append_text(aline);
! 1499: capa_mfree((char *)aline);
! 1500: if(s->s_format) { capa_mfree((char *)s->s_format); }
! 1501: s->s_format = NULL;
! 1502: switch(s->s_type) { /* free up spaces taken by constants */
! 1503: case I_CONSTANT:
! 1504: case R_CONSTANT: capa_mfree((char *)s); break;
! 1505: case S_CONSTANT: capa_mfree(s->s_str); capa_mfree((char *)s); break;
! 1506: default: break;
! 1507: }
! 1508:
! 1509: }
! 1510:
! 1511: /* Assign the correct answer to CurrAnsInfo first */
! 1512: void
! 1513: assign_answer( s ) Symbol *s;
! 1514: {
! 1515: char aline[QUARTER_K];
! 1516: char warn_msg[WARN_MSG_LENGTH];
! 1517:
! 1518: /*problem_default(LexiProblem_p);*/
! 1519: switch(s->s_type) {
! 1520: case IDENTIFIER:
! 1521: sprintf(warn_msg,"File %s, Line %3d: in /ANS, var %s not defined before use.\n",
! 1522: Opened_filename[Input_idx],Current_line[Input_idx],s->s_name);
! 1523: capa_msg(MESSAGE_ERROR,warn_msg);
! 1524: CurrAnsInfo.ans_str = strsave("ANSWER NOT DEFINED!");
! 1525: CurrAnsInfo.ans_type = ANSWER_IS_STRING_CI;
! 1526: sprintf(CurrAnsInfo.ans_fmt,"%%s");
! 1527: if (CurrAnsInfo.ans_tol == 0.0) {
! 1528: sprintf(warn_msg, "File %s, Line %3d: answer has a numerical value of %ld and an implicit zero tolerance.\n",
! 1529: Opened_filename[Input_idx],Current_line[Input_idx],s->s_int);
! 1530: capa_msg(MESSAGE_WARN,warn_msg);
! 1531: }
! 1532: break;
! 1533: case I_VAR: case I_CONSTANT:
! 1534: sprintf(aline, "%ld", s->s_int);
! 1535: CurrAnsInfo.ans_str = strsave(aline);
! 1536: CurrAnsInfo.ans_type = ANSWER_IS_INTEGER;
! 1537: sprintf(CurrAnsInfo.ans_fmt,"%%ld");
! 1538: break;
! 1539: case R_VAR: case R_CONSTANT:
! 1540: if(s->s_distype == DEFAULT_FORMAT ) {
! 1541: sprintf(aline,"%.15g",s->s_real);
! 1542: sprintf(CurrAnsInfo.ans_fmt,"%%.15g");
! 1543: } else {
! 1544: sprintf(aline,"%.15g",s->s_real);
! 1545: strcpy(CurrAnsInfo.ans_fmt,s->s_format);
! 1546: }
! 1547: CurrAnsInfo.ans_str = strsave(aline);
! 1548: CurrAnsInfo.ans_type = ANSWER_IS_FLOAT;
! 1549: if( CurrAnsInfo.ans_tol == 0.0 ) {
! 1550: sprintf(warn_msg,"File %s, Line %3d: answer has a numerical value of %s and a zero tolerance.\n",
! 1551: Opened_filename[Input_idx],Current_line[Input_idx],aline);
! 1552: capa_msg(MESSAGE_WARN,warn_msg);
! 1553: }
! 1554: break;
! 1555: case S_VAR: case S_CONSTANT:
! 1556: CurrAnsInfo.ans_str = strsave(s->s_str);
! 1557: if (s->s_str!=NULL && (strlen(s->s_str)>ANSWER_STRING_LENG-1)) {
! 1558: sprintf(warn_msg,"File %s, Line %3d: answer is too long, max allowed length is %d, current answer is %d\n",
! 1559: Opened_filename[Input_idx],Current_line[Input_idx],
! 1560: ANSWER_STRING_LENG-1, strlen(s->s_str));
! 1561: capa_msg(MESSAGE_ERROR,warn_msg);
! 1562: CurrAnsInfo.ans_str[ANSWER_STRING_LENG-1]='\0';
! 1563: }
! 1564: if ( !CurrAnsInfo.ans_type ) { /* not yet specified by str= answer info */
! 1565: CurrAnsInfo.ans_type = ANSWER_IS_STRING_CI;
! 1566: }
! 1567: sprintf(CurrAnsInfo.ans_fmt,"%%s");
! 1568: break;
! 1569: }
! 1570: if(s->s_format) {
! 1571: capa_mfree((char *)s->s_format);
! 1572: }
! 1573: s->s_format = NULL;
! 1574: switch(s->s_type) {
! 1575: case I_CONSTANT:
! 1576: case R_CONSTANT: capa_mfree((char *)s); break;
! 1577: case S_CONSTANT: capa_mfree(s->s_str); capa_mfree((char *)s); break;
! 1578: default: break;
! 1579: }
! 1580:
! 1581: }
! 1582:
! 1583: /* Assign tolerance to CurrAnsInfo first */
! 1584: void
! 1585: assign_tolerance(tol_type, s) int tol_type; Symbol *s;
! 1586: {
! 1587: char warn_msg[WARN_MSG_LENGTH];
! 1588:
! 1589: CurrAnsInfo.ans_tol_type = tol_type;
! 1590: switch( s->s_type ) {
! 1591: case IDENTIFIER:
! 1592: sprintf(warn_msg,"TOL = var, \"%s\" not defined before use.\n",s->s_name);
! 1593: capa_msg(MESSAGE_ERROR,warn_msg);
! 1594: CurrAnsInfo.ans_tol = 0.0;
! 1595: break;
! 1596: case I_VAR: case I_CONSTANT:
! 1597: CurrAnsInfo.ans_tol =(double)s->s_int;
! 1598: break;
! 1599: case R_VAR: case R_CONSTANT:
! 1600: CurrAnsInfo.ans_tol = s->s_real;
! 1601: break;
! 1602: case S_VAR: case S_CONSTANT: CurrAnsInfo.ans_tol = 0.0;
! 1603: break;
! 1604: }
! 1605: free_calc_expr(s);
! 1606: }
! 1607:
! 1608: /* Problem weight is per problem based */
! 1609: void
! 1610: assign_weight( s ) Symbol *s;
! 1611: { char warn_msg[WARN_MSG_LENGTH];
! 1612: YYDBUG_PR1(" weight = identifier\n");
! 1613: switch( s->s_type ) {
! 1614: case IDENTIFIER:
! 1615: sprintf(warn_msg,"WGT = var, \"%s\" not defined before use.\n", s->s_name);
! 1616: capa_msg(MESSAGE_ERROR,warn_msg);
! 1617: LexiProblem_p->weight = WEIGHT_DEFAULT;
! 1618: break;
! 1619: case I_VAR: case I_CONSTANT:
! 1620: if( s->s_int < 0 ) {
! 1621: sprintf(warn_msg,"WGT = %ld, weight cannot be less than zero.\n", s->s_int);
! 1622: capa_msg(MESSAGE_ERROR,warn_msg);
! 1623: LexiProblem_p->weight = WEIGHT_DEFAULT;
! 1624: } else {
! 1625: LexiProblem_p->weight = s->s_int;
! 1626: }
! 1627: break;
! 1628: case R_VAR: case R_CONSTANT:
! 1629: if( s->s_real < 0.0 ) {
! 1630: sprintf(warn_msg,"WGT = %g, weight cannot be less than zero.\n", s->s_real);
! 1631: capa_msg(MESSAGE_ERROR,warn_msg);
! 1632: LexiProblem_p->weight = WEIGHT_DEFAULT;
! 1633: } else {
! 1634: LexiProblem_p->weight = (int)(s->s_real);
! 1635: }
! 1636: break;
! 1637: case S_VAR: case S_CONSTANT: LexiProblem_p->weight = WEIGHT_DEFAULT; break;
! 1638: }
! 1639: free_calc_expr(s);
! 1640: }
! 1641: /* Answer try limit is per problem based */
! 1642: void
! 1643: assign_try_limits( s ) Symbol *s;
! 1644: { char warn_msg[WARN_MSG_LENGTH];
! 1645: switch( s->s_type ) {
! 1646: case IDENTIFIER:
! 1647: sprintf(warn_msg,"TRY = var, \"%s\" not defined before use.\n",s->s_name);
! 1648: capa_msg(MESSAGE_ERROR,warn_msg);
! 1649: LexiProblem_p->tries = MAX_TRIES;
! 1650: break;
! 1651: case I_VAR: case I_CONSTANT:
! 1652: if(s->s_int <= 0) {
! 1653: sprintf(warn_msg,"TRIES = %ld, tries cannot be less than or equal to zero.\n",s->s_int);
! 1654: capa_msg(MESSAGE_ERROR,warn_msg);
! 1655: LexiProblem_p->tries = MAX_TRIES;
! 1656: } else {
! 1657: LexiProblem_p->tries = s->s_int;
! 1658: }
! 1659: break;
! 1660: case R_VAR: case R_CONSTANT:
! 1661: if(s->s_real <= 0.0) {
! 1662: sprintf(warn_msg,"TRIES = %g, tries cannot be less than or equal to zero.\n",s->s_real);
! 1663: capa_msg(MESSAGE_ERROR,warn_msg);
! 1664: LexiProblem_p->tries = MAX_TRIES;
! 1665: } else {
! 1666: LexiProblem_p->tries = (int)(s->s_real);
! 1667: }
! 1668: break;
! 1669: case S_VAR: case S_CONSTANT: LexiProblem_p->tries = MAX_TRIES; break;
! 1670: }
! 1671: free_calc_expr(s);
! 1672: }
! 1673: /* Answer hint is per problem based */
! 1674: void
! 1675: assign_hint( s ) Symbol *s;
! 1676: { char warn_msg[WARN_MSG_LENGTH];
! 1677:
! 1678: switch( s->s_type ) {
! 1679: case IDENTIFIER:
! 1680: sprintf(warn_msg,"HINT = var, \"%s\" not defined before use.\n", s->s_name);
! 1681: capa_msg(MESSAGE_ERROR,warn_msg);
! 1682: LexiProblem_p->show_hint = SHOW_HINT_DEFAULT;
! 1683: break;
! 1684: case I_VAR: case I_CONSTANT:
! 1685: if( s->s_int < 0 ) {
! 1686: sprintf(warn_msg,"HINT = %ld, show hint cannot be less than zero.\n", s->s_int);
! 1687: capa_msg(MESSAGE_ERROR,warn_msg);
! 1688: LexiProblem_p->show_hint = SHOW_HINT_DEFAULT;
! 1689: } else {
! 1690: LexiProblem_p->show_hint = s->s_int;
! 1691: }
! 1692: break;
! 1693: case R_VAR: case R_CONSTANT:
! 1694: if( s->s_real < 0.0 ) {
! 1695: sprintf(warn_msg,"HINT = %g, show hint cannot be less than zero.\n", s->s_real);
! 1696: capa_msg(MESSAGE_ERROR,warn_msg);
! 1697: LexiProblem_p->show_hint = SHOW_HINT_DEFAULT;
! 1698: } else {
! 1699: LexiProblem_p->weight = (int)(s->s_real);
! 1700: }
! 1701: break;
! 1702: case S_VAR: case S_CONSTANT: LexiProblem_p->show_hint = SHOW_HINT_DEFAULT; break;
! 1703: }
! 1704: free_calc_expr(s);
! 1705: }
! 1706:
! 1707: /* Assign answer units string to CurrAnsInfo first */
! 1708: void
! 1709: assign_units( s ) Symbol *s;
! 1710: {
! 1711: char symb_str[ONE_TWO_EIGHT];
! 1712: char warn_msg[WARN_MSG_LENGTH];
! 1713:
! 1714: switch( s->s_type ) {
! 1715: case IDENTIFIER:
! 1716: sprintf(warn_msg,"UNIT = var, \"%s\" not defined before use.\n", s->s_name);
! 1717: capa_msg(MESSAGE_ERROR,warn_msg);
! 1718: break;
! 1719: case I_VAR: case I_CONSTANT:
! 1720: sprintf(warn_msg,"UNIT = %ld, unit cannot be a number.\n", s->s_int);
! 1721: capa_msg(MESSAGE_ERROR,warn_msg);
! 1722: break;
! 1723: case R_VAR: case R_CONSTANT:
! 1724: sprintf(warn_msg,"UNIT = %g, unit cannot be a number.\n", s->s_real);
! 1725: capa_msg(MESSAGE_ERROR,warn_msg);
! 1726: break;
! 1727: case S_VAR: case S_CONSTANT:
! 1728: strcpy(symb_str,s->s_str);
! 1729: strcpy(CurrAnsInfo.ans_unit_str,symb_str);
! 1730: /*CurrAnsInfo.ans_unit = u_parse_unit(symb_str);*/
! 1731: /*if (gUnitError) {
! 1732: sprintf(warn_msg,"Error in unit specified: %s\n",symb_str);
! 1733: capa_msg(MESSAGE_ERROR,warn_msg);
! 1734: }*/
! 1735: break;
! 1736: }
! 1737: }
! 1738: void
! 1739: assign_sigs( lb, ub ) int lb; int ub;
! 1740: {
! 1741: CurrAnsInfo.ans_sig_lb = lb;
! 1742: CurrAnsInfo.ans_sig_ub = ub;
! 1743: }
! 1744:
! 1745: void
! 1746: assign_id_list( s ) Symbol *s;
! 1747: {
! 1748: char warn_msg[WARN_MSG_LENGTH];
! 1749:
! 1750: switch( s->s_type ) {
! 1751: case IDENTIFIER:
! 1752: sprintf(warn_msg,"Eval = < ID @ Pts >, \"%s\" not defined before use.\n", s->s_name);
! 1753: capa_msg(MESSAGE_ERROR,warn_msg);
! 1754: break;
! 1755: case I_VAR: case I_CONSTANT:
! 1756: sprintf(warn_msg,"Eval = < %ld @ Pts >, ID cannot be a number.\n", s->s_int);
! 1757: capa_msg(MESSAGE_ERROR,warn_msg);
! 1758: break;
! 1759: case R_VAR: case R_CONSTANT:
! 1760: sprintf(warn_msg,"Eval = < %.16g @ Pts >, ID cannot be a number.\n", s->s_real);
! 1761: capa_msg(MESSAGE_ERROR,warn_msg);
! 1762: break;
! 1763: case S_VAR: case S_CONSTANT:
! 1764: CurrAnsInfo.ans_id_list = strsave(s->s_str);
! 1765: break;
! 1766: }
! 1767: }
! 1768:
! 1769: /* void assign_pts ( Symbol* coord1, Symbol* coord2, Symbol* num) { */
! 1770: void assign_pts (coord1, coord2, num)Symbol *coord1;Symbol *coord2;Symbol *num;
! 1771: {
! 1772: PointsList_t *pt;
! 1773: if( LastPtsList != NULL ) {
! 1774: /*LastPtsList->pts_next = gen_ptslist( coord1, coord2, num );*/
! 1775: pt = LastPtsList->pts_next;
! 1776: while( pt->pts_next != NULL ) {
! 1777: pt = pt->pts_next;
! 1778: }
! 1779: LastPtsList = pt;
! 1780: } else {
! 1781: /*CurrPtsList = gen_ptslist( coord1, coord2, num );*/
! 1782: LastPtsList = CurrPtsList;
! 1783: }
! 1784: if(coord1->s_type == S_CONSTANT) {
! 1785: capa_mfree(coord1->s_str); capa_mfree((char *)coord1);
! 1786: }
! 1787: if(coord2->s_type == S_CONSTANT) {
! 1788: capa_mfree(coord2->s_str); capa_mfree((char *)coord2);
! 1789: }
! 1790: if(num->s_type == I_CONSTANT || num->s_type == R_CONSTANT) {
! 1791: capa_mfree((char *)num);
! 1792: }
! 1793: }
! 1794:
! 1795: /* =========================================================================== */
! 1796:
! 1797:
! 1798:
! 1799:
! 1800:
! 1801:
! 1802: /* =========================================================================== */
! 1803:
! 1804: void start_question_over()
! 1805: {
! 1806: /*free_problems(LexiProblem_p);*/
! 1807: LexiProblem_p = (Problem_t *) capa_malloc(sizeof(Problem_t),1);
! 1808: /*problem_default(LexiProblem_p);*/
! 1809: begin_question();
! 1810: }
! 1811:
! 1812: void
! 1813: init_new_prob()
! 1814: {
! 1815: if (LastProblem_p) {
! 1816: LastProblem_p->next = LexiProblem_p;
! 1817: } else {
! 1818: FirstProblem_p = LexiProblem_p;
! 1819: }
! 1820: LastProblem_p = LexiProblem_p;
! 1821: Lexi_qnum++;
! 1822: LexiProblem_p = (Problem_t *) capa_malloc(sizeof(Problem_t),1); /* *** */
! 1823: /*problem_default(LexiProblem_p);*/
! 1824: }
! 1825: void
! 1826: add_answer_cnt(op)int op;
! 1827: {
! 1828: LexiProblem_p->ans_cnt++;
! 1829: if(LexiProblem_p->ans_op == 0) { /* the very first /AND or /OR */
! 1830: LexiProblem_p->ans_op = op;
! 1831: } else {
! 1832: if( LexiProblem_p->ans_op != op ) { char warn_msg[WARN_MSG_LENGTH];
! 1833: sprintf(warn_msg,"When specifying multiple answers, either /AND or /OR can be used, but not both.\n");
! 1834: capa_msg(MESSAGE_ERROR,warn_msg);
! 1835: }
! 1836: }
! 1837: }
! 1838:
! 1839: /* -- called when forming answer_expr */
! 1840: void
! 1841: finish_answer_info()
! 1842: {
! 1843: AnswerInfo_t *ai;
! 1844:
! 1845: if( LexiProblem_p->ans_cnt == 1 ) { /* Only one answer is defined */
! 1846: LexiProblem_p->answer = CurrAnsInfo.ans_str;
! 1847: LexiProblem_p->ans_type = CurrAnsInfo.ans_type;
! 1848: LexiProblem_p->calc = CurrAnsInfo.ans_calc;
! 1849: LexiProblem_p->tol_type = CurrAnsInfo.ans_tol_type;
! 1850: LexiProblem_p->tolerance = CurrAnsInfo.ans_tol;
! 1851: LexiProblem_p->sig_ubound= CurrAnsInfo.ans_sig_ub;
! 1852: LexiProblem_p->sig_lbound= CurrAnsInfo.ans_sig_lb;
! 1853: LexiProblem_p->id_list = CurrAnsInfo.ans_id_list;
! 1854: LexiProblem_p->pts_list = CurrAnsInfo.ans_pts_list;
! 1855: strcpy(LexiProblem_p->ans_fmt,CurrAnsInfo.ans_fmt);
! 1856: strcpy(LexiProblem_p->unit_str,CurrAnsInfo.ans_unit_str);
! 1857: LexiProblem_p->ans_unit = CurrAnsInfo.ans_unit;
! 1858: } else {
! 1859: ai = (AnswerInfo_t *)capa_malloc(sizeof(AnswerInfo_t),1);
! 1860: ai->ans_str = CurrAnsInfo.ans_str;
! 1861: ai->ans_type = CurrAnsInfo.ans_type;
! 1862: ai->ans_calc = CurrAnsInfo.ans_calc;
! 1863: ai->ans_tol_type = CurrAnsInfo.ans_tol_type;
! 1864: ai->ans_tol = CurrAnsInfo.ans_tol;
! 1865: ai->ans_sig_ub = CurrAnsInfo.ans_sig_ub;
! 1866: ai->ans_sig_lb = CurrAnsInfo.ans_sig_lb;
! 1867: ai->ans_id_list = CurrAnsInfo.ans_id_list;
! 1868: ai->ans_pts_list = CurrAnsInfo.ans_pts_list;
! 1869: strcpy(ai->ans_fmt,CurrAnsInfo.ans_fmt);
! 1870: strcpy(ai->ans_unit_str,CurrAnsInfo.ans_unit_str);
! 1871: ai->ans_unit = CurrAnsInfo.ans_unit;
! 1872: ai->ans_next = NULL;
! 1873: if(LexiProblem_p->ans_cnt == 2) {
! 1874: LexiProblem_p->ans_list = ai;
! 1875: } else {
! 1876: (LexiProblem_p->ans_list_last)->ans_next = ai;
! 1877: }
! 1878: LexiProblem_p->ans_list_last = ai;
! 1879: }
! 1880:
! 1881: }
! 1882:
! 1883: /* === End of capaGrammarDef.y ============================================= */
! 1884:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/back.gif){kind=icon}
Return to capaGrammarDef.y CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [LON-CAPA] / loncom / homework / CAPA-converter