--- loncom/homework/CAPA-converter/capaLexerDef.flex	2000/05/03 15:35:11	1.2
+++ loncom/homework/CAPA-converter/capaLexerDef.flex	2002/09/12 15:54:06	1.21
@@ -1,3 +1,30 @@
+/* The LearningOnline Network with CAPA
+ * CAPA lexer dfinition, heavily modified to become a LON-CAPA convertor 
+ * $Id: capaLexerDef.flex,v 1.21 2002/09/12 15:54:06 albertel Exp $
+ *
+ * Copyright Michigan State University Board of Trustees
+ *
+ * This file is part of the LearningOnline Network with CAPA (LON-CAPA).
+ *
+ * LON-CAPA is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * LON-CAPA is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with LON-CAPA; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ * /home/httpd/html/adm/gpl.txt
+ *
+ * http://www.lon-capa.org/
+ */
+
 /*------------------------------------------------------------------------*/
 /*         capaLexerDef.flex   created by Isaac Tsai Jul 15 1996          */
 /*                             added /END(variable)                       */
@@ -119,11 +146,15 @@ Symbol       *FmlSymbLast_p;
 int           FmlSymb_cnt;
 int           Symb_count;
 
-int           IFstatus[MAX_FUNC_NEST];     /* <-- perhaps we can use linked list */
-int           IFcurrent[MAX_FUNC_NEST];    /* <-- perhaps we can use linked list */
 int           IFcount;
 WhileLoop_t   WhileStack[MAX_FUNC_NEST];   /* <-- perhaps we can use linked list */
 int           While_idx, Wcount;
+int           sccount;		           /* Semi-colon count for MAP and RMAP  */
+int           HINTflag=0;
+int           EXPflag=0;
+int           EVALflag=0;
+int           compound_answer=0;
+int           essay_answer=0;
 
 #ifdef  USE_DYNAMIC_SYMBOLS
 Symbol       *SymbList_p;
@@ -140,7 +171,8 @@ extern        Problem_t         *LexiPro
 extern        Problem_t         *LastProblem_p;
 int           first_run=1;
 int           Stop_Parser;
-int           scriptopen=0;
+static        int dosend=1;
+static        int firstparam=1;
 #define  FLEX
 
 #define  YY_STACK_USED   1  /* for yy_push_state(), yy_pop_state() */
@@ -215,7 +247,7 @@ void newyy_input (char *buf,int *result,
        } \
        Input_idx = 0; \
        first_run=0; \
-       yyin = Input_stream[Input_idx]; LIDBUG_PR1("<<yy_input() startup>>\n"); \
+yyin = Input_stream[Input_idx]; LIDBUG_PR1("<<yy_input() startup>>\n"); \
     } \
     out_of_char = 0; \
     if ( Lexi_buf[Input_idx] == NULL ) { \
@@ -337,6 +369,7 @@ void newyy_input (char *buf,int *result,
 #endif
 
 int capa_eof();
+
 %}
 
 Alpha      [a-zA-Z_]
@@ -359,8 +392,8 @@ EndLine    ([\r][\n]|[\n])
 %n 1000
 %x  S_COMMENT   S_HINT S_HINTEXLAINX  S_IMPORT S_EXPLAIN S_ENDX    S_UNIT   S_IGNORE  
 %x  S_SKIP      S_VARIABLE S_LET  S_DEFINE     S_TEXT    S_MAP     S_FIGURE S_ANSWER 
-%x  S_STRING    S_ANSCONTINUE     S_TRUE_FALSE_STMT      S_IF_SKIP S_WHILE_SKIP
-%x  S_NEXT_LINE S_VERB
+%x  S_STRING    S_ANSCONTINUE     S_TRUE_FALSE_STMT      S_WHILE_SKIP
+%x  S_NEXT_LINE S_VERB   S_ECHO S_STRINGINANS
 %array
 
 
@@ -379,33 +412,44 @@ EndLine    ([\r][\n]|[\n])
 }
 
 <S_COMMENT>{
-{EndLine}{Spaces}"//"[^\n]*$ {LLDBUG_PRL2("[COMMENT<%s>]\n",yytext);
-                              remove_delayed(); 
-			      send("%s",yytext);
-			      send_delayed("\n</comment>\n");
+{EndLine}{Spaces}"//"[^\n]*$ {LLDBUG_PRL2("[COMMENT<%s>]\n",yytext); 
+			      send("# %s\n",&yytext[2]);
                              }
-[^\n]*{EndLine}      BEGIN S_TEXT;
+[^\n]*{EndLine}      {
+                       send("\n"); BEGIN S_TEXT;
+                     }
 }
 
 
 <S_TEXT>{
 ^{Spaces}"/LET" |
-	   ^{Spaces}"/BEG"                  { LLDBUG_PRL1("[LET]"); Pcount = 0; BEGIN S_LET; if (!scriptopen){send("<script>\n");scriptopen=1;}
+	   ^{Spaces}"/BEG"                  { LLDBUG_PRL1("[LET]"); Pcount = 0; BEGIN S_LET; start_mode(MODE_SCRIPT,NULL);
 }
 ^{Spaces}"/VERB"                 { 
                                    LLDBUG_PRL1("[VERBATIM]");
-				   Dynamic_buf = (char *)capa_malloc(sizeof(char),10);
-				   Dynamic_buf_max = 10;
-				   Dynamic_buf_cur = 0;
-				   Dynamic_buf[0] = '\0';
                                    BEGIN S_VERB; 
+				   start_mode(MODE_OUTTEXT,NULL);
+				   send("<PRE>\n");
                                  }
 ^{Spaces}"/HIN"{Alpha}*{Spaces}  { LLDBUG_PRL1("[HIN]"); 
-                                   send("<block condition=\"&hinton\">\n");
+                               /*    start_mode(MODE_HINT, "");*/
+                                   if (!HINTflag) {
+                                     start_streams(HINT_DEST,1);
+                                     HINTflag=-1;
+                                   }
+                                   change_destination(HINT_DEST);
+                                   send("\t",NULL);
 				   BEGIN S_HINT; 
                                  }
-^{Spaces}"/EXP"{Alpha}*{Spaces}  { LLDBUG_PRL1("[EXP]"); Current_char_p = String_buf;  BEGIN S_EXPLAIN; }
-^{Spaces}"/IMP"{Alpha}*{Space}+  { LLDBUG_PRL1("[IMP]"); BEGIN S_IMPORT; }
+^{Spaces}"/EXP"{Alpha}*{Spaces}  { 
+                                   if (!EXPflag) {
+                                     start_streams(EXP_DEST,1);
+                                     EXPflag=-1;
+                                   }
+                                   change_destination(EXP_DEST);
+                                   send("\t",NULL);
+                                   LLDBUG_PRL1("[EXP]"); Current_char_p = String_buf;  BEGIN S_EXPLAIN; }
+^{Spaces}"/IMP"{Alpha}*{Space}+  { LLDBUG_PRL1("[IMP]"); BEGIN S_IMPORT; end_mode(); }
 ^{Spaces}"/END"                  { LLDBUG_PRL1("[END]");  
                                     if ( (LexiProblem_p !=NULL) && 
 					 (LexiProblem_p->question != NULL) && 
@@ -415,7 +459,7 @@ EndLine    ([\r][\n]|[\n])
 				    } else {
 				      EndText_p=NULL;
 				    }
-				    End_of_input = 1; BEGIN S_IGNORE;RETURN(CAPA_END); 
+				    End_of_input = 1; BEGIN S_IGNORE; 
                                   }
 ^{Spaces}"/START"[^\n]*          { LLDBUG_PRL1("[START]");  
                                     if (LexiProblem_p !=NULL && 
@@ -425,89 +469,142 @@ EndLine    ([\r][\n]|[\n])
 				      StartText_p=NULL;
 				    }
 				    BEGIN S_TEXT;
-				    RETURN(CAPA_START); 
                                   }
                                   
 ^{Spaces}"/END"{Spaces}[\(]{Spaces}      { LLDBUG_PRL1("[END()]"); BEGIN S_ENDX; }
 ^"/DEF"                       { Bcount = 0; BEGIN S_DEFINE; RETURN(CAPA_DEF); }
-^{Spaces}"/ANS"               { LLDBUG_PRL2("[ANS(%s)]",yytext); Pcount = 0; BEGIN S_ANSWER; RETURN(CAPA_ANS); }
-^{Spaces}"/SUBJECTIVE"        { LLDBUG_PRL1("[SUBJECTIVE ANSWER]"); Pcount = 0; BEGIN S_ANSWER; RETURN(CAPA_SUBJ); }
-^{Spaces}"/MAP"               { LLDBUG_PRL1("[MAP]");  Pcount = 0; BEGIN S_MAP;   RETURN(CAPA_MAP); }
-^{Spaces}"/RMAP"              { LLDBUG_PRL1("[RMAP]"); Pcount = 0; BEGIN S_MAP;   RETURN(CAPA_RMAP); }
-^{Spaces}"/ENDWHILE"([^\n])*          { long int  file_pos;       
-                                int   top_item, input_idx;
-                                LLDBUG_PRL2("[ENDWHILE While_idx=<%d>]\n",While_idx);
-                                
-                                top_item = While_idx - 1;
-                                if( top_item < 0 ) { /* strange things must have happened here! */
-                                  
-                                } else {
-                                  input_idx = WhileStack[top_item].input_idx;
-                                  file_pos = WhileStack[top_item].pos_idx;
-                                  Current_line[input_idx] = WhileStack[top_item].line_idx;
-                                  Lexi_pos[input_idx] = 0;
-                                  fseek(Input_stream[input_idx],file_pos,SEEK_SET);
-                                  fgets(Lexi_buf[input_idx],LEX_BUFLEN-1,Input_stream[input_idx]);
-                                  While_idx--;
-                                }
+^{Spaces}"/ANS"               { LLDBUG_PRL2("[ANS(%s)]",yytext); 
+                                Pcount = 0; 
+                                BEGIN S_ANSWER; 
+                                end_mode();
+				start_mode(MODE_ANSWER,NULL);
+                                send("<numericalresponse answer=\""); 
+				dosend=1;
+				firstparam=1;
+                                compound_answer=0;
+                                essay_answer=0;
+                              }
+^{Spaces}"/SUBJECTIVE"        { LLDBUG_PRL1("[SUBJECTIVE ANSWER]"); 
+                                Pcount = 0; 
+                                BEGIN S_ANSWER;
+                                end_mode();
+				start_mode(MODE_ANSWER,NULL);
+                                send("<essayresponse");
+				dosend=1; 
+				firstparam=1;                            
+                                compound_answer=0;
+                                essay_answer=-1;
+                              }
+^{Spaces}"/MAP"               { LLDBUG_PRL1("[MAP]");  Pcount = 0; sccount = 0; BEGIN S_MAP; start_mode(MODE_SCRIPT,NULL);send("&map("); }
+^{Spaces}"/RMAP"              { LLDBUG_PRL1("[RMAP]"); Pcount = 0; sccount = 0; BEGIN S_MAP; start_mode(MODE_SCRIPT,NULL);send("&rmap("); }
+^{Spaces}"/ENDWHILE"([^\n])*          { 
+                                int i;
+                                LLDBUG_PRL2("[ENDWHILE While_idx=<%d>]\n",IFcount);
+                                IFcount--;
+				end_mode_stream(DEFAULT_DEST,0);
+				for(i=0;i<IFcount;i++) {send("\t",NULL);}
+				send_stream(0,"</while>");
+				send_stream(1,"}");
+				if (IFcount == 0) {
+				  if (watch_mode[current_dest][1]) {
+				    end_streams(DEFAULT_DEST,1);
+ 				  } else {
+				    end_streams(DEFAULT_DEST,0);
+				  }
+                                  change_destination(DEFAULT_DEST);
+				}
+				delete_cache();
                                 BEGIN S_TEXT;
                               }
 "/WHILE"                      |
-^{Spaces}"/WHILE"             { long int file_pos;
-                                int      leng;
-                                LLDBUG_PRL2("[WHILE While_idx=<%d>]\n",While_idx);
-                                leng = strlen(Lexi_buf[Input_idx]);  /* length of current line */
-                                /* <-- because we use fgets() to read input, 
-                                       thus ftell() will give the starting position of next line */
-                                WhileStack[While_idx].input_idx = Input_idx;
-                                file_pos = ftell(Input_stream[Input_idx]);
-                                file_pos -= leng;  /* calibrate the current line length */
-                                WhileStack[While_idx].pos_idx = file_pos;  /* begin of current line */
-                                WhileStack[While_idx].line_idx = Current_line[Input_idx];
-                                While_idx++;  /* advance the stack pointer */
-                                
-                                BEGIN S_TRUE_FALSE_STMT; RETURN(CAPA_WHILE); 
-                                
+^{Spaces}"/WHILE"             { 
+                                int      i;
+                                LLDBUG_PRL2("[WHILE While_idx=<%d>]\n",IFcount);
+                                IFcount++;  /* advance the stack pointer */
+                                BEGIN S_TRUE_FALSE_STMT;
+				if ( IFcount == 1) {
+ 				  start_streams(DEFAULT_DEST, 2);
+                                  change_destination(DEFAULT_DEST);
+				  watch_mode[current_dest][1]=1;
+				}
+				end_mode_stream(DEFAULT_DEST, 0);
+				start_mode_stream(DEFAULT_DEST,1,MODE_SCRIPT,NULL);
+				for(i=1;i<IFcount;i++) {send("\t",NULL);}
+				send_stream(0,"<while condition=\"",NULL);
+				send_stream(1,"while (",NULL);
+				new_cache();
+				start_cache();
                               }
-^{Spaces}"/IF"                { IFcount++; IFcurrent[IFcount] = RUN_IF_PORTION;
-                                LLDBUG_PRL2("[IF <IFcount=%d>]",IFcount);  BEGIN S_TRUE_FALSE_STMT; RETURN(CAPA_IF); }
-^{Spaces}"/ELSE"([^\n])*        { LLDBUG_PRL2("[ELSE <IFcount=%d>]\n",IFcount); 
-                                IFcurrent[IFcount] = RUN_ELSE_PORTION;
-                                if( IFstatus[IFcount] == IF_TRUE ) {
-                                  LLDBUG_PRL1("[ELSE begin Skip]\n");
-                                  BEGIN S_IF_SKIP;
-                                }
+^{Spaces}"/IF"                { int i;
+				IFcount++;
+                                LLDBUG_PRL2("[IF <IFcount=%d>]",IFcount);
+				BEGIN S_TRUE_FALSE_STMT;
+				if ( IFcount == 1) {
+ 				  start_streams(DEFAULT_DEST, 2);
+                                  change_destination(DEFAULT_DEST);
+				  watch_mode[current_dest][1]=1;
+				}
+				end_mode_stream(DEFAULT_DEST, 0);
+				start_mode_stream(DEFAULT_DEST,1,MODE_SCRIPT,NULL);
+				for(i=1;i<IFcount;i++) {send("\t",NULL);}
+				send_stream(0,"<block condition=\"",NULL);
+				send_stream(1,"if (",NULL);
+				new_cache();
+				start_cache();
+			       }
+^{Spaces}"/ELSE"([^\n])*      { int i;
+				LLDBUG_PRL2("[ELSE <IFcount=%d>]\n",IFcount);
+				end_mode_stream(DEFAULT_DEST,0);
+				for(i=1;i<IFcount;i++) {send("\t",NULL);}
+ 				send_stream(0,
+                                      "</block>\n<block condition=\"!(%s)\">",
+				      cached_data[current_cache].str);
+				send_stream(1,"} else {");
                               }
-^{Spaces}"/ENDIF"([^\n])*    { IFcount--; LLDBUG_PRL2("[ENDIF <IFcount=%d>]\n",IFcount); 
+^{Spaces}"/ENDIF"([^\n])*     { int i;
+				IFcount--;
+				end_mode_stream(DEFAULT_DEST,0);
+				for(i=0;i<IFcount;i++) {send("\t",NULL);}
+				send_stream(0,"</block>");
+				send_stream(1,"}");
+				if (IFcount == 0) {
+				  if (watch_mode[current_dest][1]) {
+				    end_streams(DEFAULT_DEST,1);
+ 				  } else {
+				    end_streams(DEFAULT_DEST,0);
+				  }
+                                  change_destination(DEFAULT_DEST);
+				}
+				delete_cache();
+				LLDBUG_PRL2("[ENDIF <IFcount=%d>]\n",IFcount); 
                               }
-"/AND"                        { LLDBUG_PRL1("[AND]"); BEGIN S_ANSCONTINUE; RETURN(ANS_AND); }
 "/DIS"                        { /* since S_VARIABLE treat {Space} as null, so here we do not match ( */
                                 /* so that between /DIS and ( can have as many {Space} as we want */
+				start_mode(MODE_OUTTEXT,NULL);
                                 LLDBUG_PR1("[DIS<]");
                                 init_funcstack();
                                 Pcount = 0; BEGIN S_VARIABLE; 
-                                RETURN(CAPA_VAR); 
+				send("<display>");
+				start_delayed();
                               }
-"/OR"                         { LLDBUG_PRL1("[OR]"); BEGIN S_ANSCONTINUE;  RETURN(ANS_OR); }
 {EndLine}                     { LLDBUG_PR1("[EoL within S_TEXT]\n"); /* end of the whole text line */ 
-                                RETURN(EoL); }
+                                send("\n"); }
 [\\]{Space}*{EndLine}         { LLDBUG_PR2("[\\EoL continue](%s)",yytext); /* continuation on next line */ }                       
 ^{Spaces}"//"[^\n]*$		      { LLDBUG_PRL2("[COMMENT<%s>]\n",yytext);
-                                        remove_delayed(); 
-                                        send("<comment>\n%s\n",yytext);
-					send_delayed("</comment>\n");
+                                        start_mode(MODE_SCRIPT,NULL); 
+                                        send("# %s\n",&yytext[2]);
 					BEGIN S_COMMENT;
                                       }
 
 [^/\n\\]+$  |
 [/]         | 
-[\\]                          {  yylval = (Symbol *) capa_malloc(1, sizeof(Symbol));
-                                yylval->s_str = strsave(yytext);
+[\\]                          {  start_mode(MODE_OUTTEXT,NULL);
                                 LLDBUG_PR2("[TEXT_LINE<%s>]",yytext);
-			        //RETURN(TEXT_LINE); 
+				send(yytext);
 			      }
 ([^/\n])+[/] |
 ([^/\n])+[\\]                 { /* matches anything until a '/' or a '\' */
+                                start_mode(MODE_OUTTEXT,NULL);
                                 LLDBUG_PR2("[TEXT_LINE( )<%s>]",yytext);
                                 
                                 yyless(yyleng-1); /* push back the last char */
@@ -531,7 +628,7 @@ EndLine    ([\r][\n]|[\n])
 				    }
 				  } else {
 				    sprintf(warn_msg,
-					    "at End-of-File, a /END is needed.\n");
+					"at End-of-File, a /END is needed.\n");
 				    capa_msg(MESSAGE_ERROR,warn_msg);
 				  }
 				  free_problems(LexiProblem_p);
@@ -614,152 +711,211 @@ EndLine    ([\r][\n]|[\n])
 <S_HINT,S_EXPLAIN>{
 [/][Dd][Ii][Ss]{Space}*[\(]{Space}*  {  yy_push_state(S_HINTEXLAINX); }
 [^/\n]+[/\\]                    { char  *aptr = yytext;
-                                  int    ii;
-                                
                                   yyless(yyleng-1);
 				  send(aptr);
                                 }
 [/]                            { send("/"); }
 [\\]                           { send("\\"); }
-[\\]{Space}*[\n]               { LLDBUG_PR1("[\\CR hint explain continue]"); /* Hint and explain continuation */ }
+[\\]{Space}*[\n]               { LLDBUG_PR1("[\\CR hint explain continue]"); /* Hint and explain continuation */ send("\n\t");}
 [^/\n\\]+$                     {char  *aptr = yytext;
-                                int    ii;
-				send(aptr);
+                                send(aptr);
                                }
 }
 <S_HINT>{
 {EndLine}                     {  LLDBUG_PR1("[CR hint]");
-                                 send("\n</block>\n"); 
+                                 send("\n"); 
+                                 change_destination(DEFAULT_DEST);
                                  BEGIN S_TEXT;
                               }
 }
 <S_EXPLAIN>{
 {EndLine}                     {  LLDBUG_PR1("[CR explain]");
-                                 yylval = (Symbol *) capa_malloc(1, sizeof(Symbol));
-		                *Current_char_p++ = '\n'; *Current_char_p = '\0';
-	                         yylval->s_str = strsave(String_buf);
-                                 BEGIN S_TEXT; RETURN(EXPLAIN_LINE); 
+                                 send("\n"); 
+                                 change_destination(DEFAULT_DEST);
+                                 BEGIN S_TEXT;
                               }
 }
 
 <S_HINTEXLAINX>{
-{Alpha}{AlphaNum}*            { char   *aptr;
-                                char    tmp_str[QUARTER_K],warn_msg[ONE_K];
-                                int     ii, len;
-                                Symbol *tmp_p;
-                                
-                                /*tmp_p = find_identifier(yytext);*/
-                                switch(tmp_p->s_type) {
-                                  case IDENTIFIER:
-                                        sprintf(warn_msg,"var %s not defined.\n", yytext);
-                                        capa_msg(MESSAGE_ERROR,warn_msg);
-                                       break;
-                                  case I_VAR:
-                                  case I_CONSTANT: 
-                                         sprintf(tmp_str,"%ld",tmp_p->s_int);
-                                         len = strlen(tmp_str);
-                                         for(ii=0;ii< len;ii++) {
-                                           *Current_char_p++ = tmp_str[ii];
-                                         }
-                                       break;
-                                  case R_VAR:
-                                  case R_CONSTANT: 
-                                         sprintf(tmp_str,"%g",tmp_p->s_real);
-                                         len = strlen(tmp_str);
-                                         for(ii=0;ii< len;ii++) {
-                                           *Current_char_p++ = tmp_str[ii];
-                                         }
-                                       break;
-                                  case S_VAR:
-                                  case S_CONSTANT: 
-                                         len = strlen(tmp_p->s_str);
-                                         aptr = tmp_p->s_str;
-                                         for(ii=0;ii< len;ii++) {
-                                           *Current_char_p++ = *aptr++;
-                                         }
-                                       break;
-                                }
-				printf("FIXME!Hint: %s\n",yytext);
-                              }
+{Alpha}{AlphaNum}*            {send("${%s}",yytext);}
 {Space}+                      { }
 [)]                           {  yy_pop_state(); }
 }
 
 <S_IMPORT>{
-{FileName}{Space}*             { send("<import>%s</import>\n",yytext); BEGIN S_SKIP; }
-{Identifier}{Space}*           { send("<import>$%s</import>\n",yytext);  BEGIN S_SKIP; }
+{FileName}{Space}*             {
+                                 char *endquote;
+                                 end_mode();
+				 start_mode(MODE_IMPORT,NULL);
+				 /* Get rid of leading and trailing quotes */
+				 endquote = strrchr(yytext,'\"');
+                                 *endquote = '\0';
+                                 if (yytext[1] == '/') {
+                                    send("%s%s",import_prefix,&yytext[1]);
+                                 } else {
+                                    send("%s",&yytext[1]);
+                                 }
+				 end_mode();
+				 BEGIN S_SKIP;
+                               }
+{Identifier}{Space}*           { end_mode();
+				 start_mode(MODE_IMPORT,NULL);
+				 send("${%s}",yytext);
+				 end_mode();
+                                 BEGIN S_SKIP;
+			       }
 }
 
 <S_ANSWER>{
-[Pp][Ll][Uu][Ss]             { LLDBUG_PR1("[PLUS]");  RETURN(ANS_PLUS); }
-[Mm][Ii][Nn][Uu][Ss]         { LLDBUG_PR1("[MINUS]"); RETURN(ANS_MINUS); }
-[Cc][Ss]                     { LLDBUG_PR1("[CS]");    RETURN(ANS_CS); }
-[Cc][Ii]                     { LLDBUG_PR1("[CI]");    RETURN(ANS_CI); }
-[Mm][Cc]                     { LLDBUG_PR1("[MC]");    RETURN(ANS_MC); }
+[Pp][Ll][Uu][Ss]             { LLDBUG_PR1("[PLUS]"); add_delayed("+");}
+[Mm][Ii][Nn][Uu][Ss]         { LLDBUG_PR1("[MINUS]"); add_delayed("-");}
+
+[Cc][Ss]                     { LLDBUG_PR1("[CS]"); send("cs");}
+[Cc][Ii]                     { LLDBUG_PR1("[CI]"); send("ci");}
+[Mm][Cc]                     { LLDBUG_PR1("[MC]"); send("mc");}
+[Ff][Mm][Ll]                 { LLDBUG_PR1("[FORMULA]"); send("fml"); }
+
 [Oo][Nn]                     |
-[Yy][Ee][Ss]                 { LLDBUG_PR1("[ON]");    RETURN(ANS_ON); }
+[Yy][Ee][Ss]                 { LLDBUG_PR1("[ON]"); send("on");}
 [Oo][Ff][Ff]                 |
-[Nn][Oo]                     { LLDBUG_PR1("[OFF]");   RETURN(ANS_OFF); }
-[Ff][Mm][Ll]                 { LLDBUG_PR1("[FORMULA]");   RETURN(ANS_FORMULA); }
-[Ff][Mm][Tt]                 { LLDBUG_PR1("[FMT]");   RETURN(ANS_FMT); }
-[Uu][Nn][Ff][Mm][Tt]         { LLDBUG_PR1("[UNFMT]"); RETURN(ANS_UNFMT); }
-[,:%=@#-]                  { LLDBUG_PR2("[symbol(%s)]",yytext); return(yytext[0]); }
-"<"                          { LLDBUG_PR2("[symbol(%s)]",yytext); return(yytext[0]); }
-">"                          { LLDBUG_PR2("[symbol(%s)]",yytext); return(yytext[0]); }
-[Ss][Ii][Gg]                 { LLDBUG_PR2("[SIG(%s)]",yytext);  RETURN(ANS_SIG); }
-[Tt][Oo][Ll]                 { LLDBUG_PR2("[tol(%s)]",yytext);  RETURN(ANS_TOLERANCE); }
-[Ss][Tt][Rr]                 { LLDBUG_PR1("[STR]");   RETURN(ANS_COMPARE); }
-[Ww][Gg][Tt]                 { LLDBUG_PR1("[WGT]");   RETURN(ANS_WEIGHT); }
+[Nn][Oo]                     { LLDBUG_PR1("[OFF]"); send("off");}
+[Ff][Mm][Tt]                 { LLDBUG_PR1("[FMT]"); }
+[Uu][Nn][Ff][Mm][Tt]         { LLDBUG_PR1("[UNFMT]"); }
+
+[,=]                  { LLDBUG_PR2("[symbol(%s)]",yytext);}
+[%]                  { LLDBUG_PR2("[symbol(%s)]",yytext); 
+                       if (dosend==1) send("%s",yytext);
+                       if (dosend==2) add_delayed("%%%s",yytext);
+                     }
+[:@#-]                  { LLDBUG_PR2("[symbol(%s)]",yytext); 
+                          if (dosend==1) send("%s",yytext);
+                          if (dosend==2) add_delayed("%s",yytext);
+                        }
+"<"                          { LLDBUG_PR2("[symbol(%s)]",yytext);
+			       if (!EVALflag) {
+                               if (dosend==1) send("%s",yytext);
+                               if (dosend==2) add_delayed("%s",yytext);
+                             }
+                             }
+">"                          { LLDBUG_PR2("[symbol(%s)]",yytext);
+			       if (!EVALflag) {
+                               if (dosend==1) send("%s",yytext);
+                               if (dosend==2) add_delayed("%s",yytext);
+                               } else {
+				 EVALflag = 0;
+			       }
+                             }
+
 [Pp][Cc][Rr]                 |
-[Hh][Gg][Rr]                 { RETURN(ANS_PCREDIT); }
-[Pp][Aa][Tt][Hh]             { RETURN(ANS_PATH); }
-[Cc][Aa][Ll][Cc]             { RETURN(ANS_CALC); }
-[Tt][Rr][Yy]                 |
-[Tt][Rr][Ii][Ee][Ss]         { LLDBUG_PR1("[TRY]");     RETURN(ANS_TRY); }
-[Uu][Nn][Ii][Tt]             |
-[Uu][Nn][Ii][Tt][Ss]         { LLDBUG_PR1("[UNIT]");    RETURN(ANS_UNIT); }
-[Bb][Rr]                     { LLDBUG_PR1("[SHOW_BR]"); RETURN(ANS_SHOW_BR);  }
-[Vv][Ee][Rr][Bb][Aa][Tt][Ii][Mm] { LLDBUG_PR1("[VERBATIM]"); RETURN(ANS_VERBATIM); }
-[Aa][Nn][Ss][Bb][Oo][Xx]     { LLDBUG_PR1("[SHOW_ANS_BOX]"); RETURN(ANS_BOX_SHOW);  }
-[Hh][Ii][Nn][Tt]             { LLDBUG_PR1("[HINT]");    RETURN(ANS_HINT); }
-[Ee][Xx][Pp][Ll][Aa][Ii][Nn] { LLDBUG_PR1("[EXPLAIN]"); RETURN(ANS_EXPLAIN); }
-[Ee][Xx][Tt][Ee][Rr][Nn][Aa][Ll]  { LLDBUG_PR1("[EXTERNAL]"); RETURN(ANS_EXTERNAL); }
+[Hh][Gg][Rr]                 { if (firstparam) {
+				firstparam=0; 
+			       } else {
+				add_delayed("\" />\n\t");
+			       }
+                               add_delayed("<responseparam name=\"hgr\" type=\"on|off\" default=\""); 
+                               dosend=2;
+                             }
+[Tt][Oo][Ll]                 { LLDBUG_PR2("[tol(%s)]",yytext);
+                               if (firstparam) {
+				 firstparam=0; 
+			       } else {
+				 add_delayed("\" />\n\t");
+			       }
+			       add_delayed("<responseparam name=\"tol\" type=\"tolerance\" description=\"Numerical Tolerance\" default=\""); 
+                               dosend=2;
+                             }
+[Ss][Ii][Gg]                 { 
+                               LLDBUG_PR2("[SIG(%s)]",yytext); 
+                               if (firstparam) {
+				 firstparam=0; 
+			       } else {
+				 add_delayed("\" />\n\t");
+			       }
+			       add_delayed("<responseparam name=\"sig\" type=\"int_range,0-12\" description=\"Significant Figures\" default=\""); 
+                               dosend=2;
+                             }
+
+[Ss][Tt][Rr]                 { LLDBUG_PR1("[STR]"); send("\" type=\""); dosend=1; }
 [Ee][Vv][Aa][Ll]             |
-[Ee][Vv][Aa][Ll][Uu][Aa][Tt][Ee]             { LLDBUG_PR1("[EVAL]"); RETURN(ANS_EVAL); }
+[Ee][Vv][Aa][Ll][Uu][Aa][Tt][Ee] { LLDBUG_PR1("[EVAL]");send("\" eval=\""); EVALflag=1; dosend=1;}
+[Uu][Nn][Ii][Tt]             |
+[Uu][Nn][Ii][Tt][Ss]         { LLDBUG_PR1("[UNIT]"); send("\" unit=\""); dosend=1;}
+
+[Ee][Xx][Tt][Ee][Rr][Nn][Aa][Ll]  { LLDBUG_PR1("[EXTERNAL]"); dosend=0; }
+[Aa][Nn][Ss][Bb][Oo][Xx]     { LLDBUG_PR1("[SHOW_ANS_BOX]"); dosend=0; }
+[Vv][Ee][Rr][Bb][Aa][Tt][Ii][Mm] { LLDBUG_PR1("[VERBATIM]"); dosend=0; }
+[Bb][Rr]                     { LLDBUG_PR1("[SHOW_BR]"); dosend=0; }
+[Pp][Aa][Tt][Hh]             { send("\" path=\""); dosend=0; }
+[Cc][Aa][Ll][Cc]             { send("\" calc=\""); dosend=0; }
+
+[Ee][Xx][Pp][Ll][Aa][Ii][Nn] { LLDBUG_PR1("[EXPLAIN]"); dosend=0; }
+[Hh][Ii][Nn][Tt]             { LLDBUG_PR1("[HINT]"); dosend=0; }
+[Tt][Rr][Yy]                 |
+[Tt][Rr][Ii][Ee][Ss]         { LLDBUG_PR1("[TRY]"); dosend=0; }
+[Ww][Gg][Tt]                 { LLDBUG_PR1("[WGT]"); dosend=0; }
+
 [\)]                         { LLDBUG_PR1("[)]"); Pcount--; 
                                if(Pcount==0) {
                                    BEGIN S_ANSCONTINUE; 
                                }
-                               return(yytext[0]); 
+                               if (essay_answer) {
+                                 send(">\n\t");
+                               } else {
+                               send("\">\n\t");
+                               }
+			       dosend=1;
+			       flush_delayed();
+			       if (firstparam!=1) send("\" />\n");
+                               if (essay_answer) {
+			         send("  <textfield>Enter your answer here.</textfield>\n");
+                               } else {
+			       send("\t<textline />\n");
+                               }
+                         /* Fill in Hints */ 
+			       if ( !is_dest_empty(HINT_DEST) ) {
+			         send("\t<hintgroup>\n\t<hintpart on=\"default\">\n\t<startouttext />");
+                                 end_streams(HINT_DEST,0);
+                                 HINTflag=0;
+                                 send("\t<endouttext />\n\t</hintpart>\n\t</hintgroup>\n");
+			       }
+                               if (essay_answer) {
+			         send("</essayresponse>\n");
+                               } else {
+			         send("</numericalresponse>\n");
+			       }
+
                              }
 }
 
-<S_VARIABLE,S_TRUE_FALSE_STMT,S_LET,S_ANSWER,S_MAP>{
-{Alpha}{AlphaNum}*             { LLDBUG_PR2("[ID<%s>]",yytext);LLDBUG_PR2("[SYMB CNT=<%d>]", Symb_count); 
-send("$%s",yytext); 
+<S_VARIABLE>{
+{Alpha}{AlphaNum}*             { LLDBUG_PR2("[ID<%s>]",yytext);
+                                 LLDBUG_PR2("[SYMB CNT=<%d>]", Symb_count); 
+                                 if(Pcount <= 1) {
+                                   if (dosend==1) send("${%s}",yytext); 
+                                   if (dosend==2) add_delayed("${%s}",yytext); 
+                                 } else {
+                                   if (dosend==1) send("$%s",yytext); 
+                                   if (dosend==2) add_delayed("$%s",yytext); 
+                               }
+                             }
+}
+
+<S_VARIABLE,S_TRUE_FALSE_STMT,S_LET,S_MAP,S_ANSWER>{
+{Alpha}{AlphaNum}*             { LLDBUG_PR2("[ID<%s>]",yytext);
+                                 LLDBUG_PR2("[SYMB CNT=<%d>]", Symb_count); 
+                                 if (dosend==1) send("$%s",yytext); 
+                                 if (dosend==2) add_delayed("$%s",yytext); 
                                }
 
-{Alpha}{AlphaNum}*{Space}*[(]  { char aline[MAX_FUNC_NAME];
-                                 int  i;          
-				 send("&%s",yytext);
+{Alpha}{AlphaNum}*{Space}*[(]  { if (dosend==1) send("&%s",yytext);
+                                 if (dosend==2) add_delayed("&%s",yytext);
 				 Pcount++;
                                }
-{Alpha}{AlphaNum}*{Space}*[\[]  {  char aline[MAX_FUNC_NAME];
-                                   int  i;   
-                                   for(i=0;i < (yyleng-1); i++) {
-                                     if( yytext[i] == ' ' || yytext[i] == '\t' || 
-                                         yytext[i] == 0   || yytext[i] == '[' )    break;
-                                     aline[i] = yytext[i];
-                                   }
-                                   aline[i] = 0;
-                                   LLDBUG_PR2("[ARRAY<%s>]",aline);
-                                   
-                                   yylval = (Symbol *) capa_malloc(1, sizeof(Symbol)); /* *** */
-                                   yylval->s_name = strsave(aline); /* free it in parser() */
-                                   yylval->s_type = ARRAY_ID;
-                                   
-                                   yyless(yyleng-1); /* <-- push back char '[' */
-                                   RETURN(ARRAY_ID);
+{Alpha}{AlphaNum}*{Space}*[\[]  {
+                                   LLDBUG_PR2("[ARRAY<%s>]",yytext);
+                                   yyless(yyleng-1); /*<-- push back char '[' */
+                                   if (dosend==1) send("$%s",yytext); 
+                                   if (dosend==2) add_delayed("$%s",yytext); 
                                }
 {Number}*"\."{Number}*[Ee]"+"{Number}+ |
 {Number}*"\."{Number}*[Ee]{Number}+    |
@@ -768,67 +924,133 @@ send("$%s",yytext);
 {Number}+[Ee]{Number}+    |
 {Number}+[Ee]"-"{Number}+ |
 {Number}+"\."{Number}*    |
-"\."{Number}+             {  
-                             LLDBUG_PR2("[REAL<%s>]",yytext);
-			     send(yytext);
+"\."{Number}+             {  LLDBUG_PR2("[REAL<%s>]",yytext);
+			     if(dosend==1) send("%s",yytext);
+			     if(dosend==2) add_delayed("%s",yytext);
 			  }
 
-{Number}+                 {  
-                             LLDBUG_PR2("[INT<%s>]",yytext);
-                             send(yytext);
+{Number}+                 {  LLDBUG_PR2("[INT<%s>]",yytext);
+                             if (dosend==1) send("%s",yytext);
+                             if (dosend==2) add_delayed("%s",yytext);
+			  }
+[\[]                      { LLDBUG_PR1("[dis let ans map '[']");
+			    if(dosend==1) send("%s",yytext);
+			    if(dosend==2) add_delayed("%s",yytext);
+			  }
+[\]]                      { LLDBUG_PR1("[dis let ans map ']']");
+			    if(dosend==1) send("%s",yytext);
+			    if(dosend==2) add_delayed("%s",yytext);
 			  }
-[\(]                      { LLDBUG_PR1("[dis let ans map (]"); Pcount++; send(yytext); }
-[\[]                      { LLDBUG_PR1("[dis let ans map '[']");         return(yytext[0]); }
-[\]]                      { LLDBUG_PR1("[dis let ans map ']']");         return(yytext[0]); }
 {Space}+                  { /* LLDBUG_PR1("[SP ignored]");  Ignore Spaces */ }
-[\"]                      { LLDBUG_PR1("[TF,V,LET,ANS,MAP str\" ]"); 
+}
+
+<S_VARIABLE,S_TRUE_FALSE_STMT,S_MAP,S_LET>{
+[\"]                      { LLDBUG_PR1("[TF,V,LET,MAP str\" ]"); 
                             Current_char_p = String_buf; 
-                            yy_push_state(S_STRING); 
+			    send("'");
+                            yy_push_state(S_STRING);
                           }
 }
 
-<S_VARIABLE,S_ANSWER>[:]{Number}+[EeFf]   { char  num[ONE_TWO_EIGHT], fmt[SMALL_LINE_BUFFER];
-                             int   i;
-                             LLDBUG_PR2("[FORMAT<%s>]",yytext);
-                             for(i=0;i<yyleng-2;i++) {
-                               num[i] = yytext[i+1];
-                             }
-                             num[yyleng-2] = 0; /* terminate the numerical string */
-                             yylval = (Symbol *) capa_malloc(1, sizeof(Symbol));
-                             i = strtol(num, (char **) 0, 0);
-                             yylval->s_type=FORMAT;
-                             switch( yytext[yyleng-1] ) {
-                               case 'e': sprintf(fmt,"%%.%de", i);
-                                         yylval->s_distype = E_FORMAT; break;
-                               case 'E': sprintf(fmt,"%%.%dE", i);
-                                         yylval->s_distype = E_FORMAT; break;
-                               case 'f': 
-                               case 'F': sprintf(fmt,"%%.%df", i);
-                                         yylval->s_distype = F_FORMAT; break;
-                             }
-                             yylval->s_str = strsave(fmt);
-                             RETURN(FORMAT);
+<S_ANSWER>{
+[\"]                      { LLDBUG_PR1("[ANS str\" ]"); 
+                            Current_char_p = String_buf; 
+                            yy_push_state(S_STRINGINANS);
+                          }
+}
+
+<S_VARIABLE,S_TRUE_FALSE_STMT,S_MAP,S_ANSWER>{
+[\(]                      { LLDBUG_PR1("[let if ans map (]"); 
+                            Pcount++; 
+			    if (Pcount > 1 ) {
+			      if (dosend==1) send(yytext);
+			      if (dosend==2) add_delayed(yytext);
+			    } 
+                          }
+}
+
+<S_LET>{
+[\(]                      { LLDBUG_PR1("[let (]"); 
+                            Pcount++; 
+			    send(yytext);
+                          }
+}
+
+<S_VARIABLE>[:]{Number}+[EeFf]   { 
+                             end_delayed();
+                             send("&format(");
+                             flush_delayed();
+                             send(",'%s')",yytext+1);
+                           }
+<S_ANSWER>[:]{Number}+[EeFf]   { 
+                             if (dosend) send("\" format=\"%s",yytext+1);
                            }
 
+<S_MAP>{
+[;]   { 
+        if (sccount==0) {
+          send(",[\\");
+          sccount++;
+        } else if (sccount==1) {
+          send("],[");
+          sccount++;
+        }
+       }
+[,]     {
+        if (sccount==1) {
+          send(",\\");
+        } else {
+          send(",");
+        }
+      }
+[\)]  {
+        LLDBUG_PR1("[) in MAP]"); Pcount--; 
+        if(Pcount==0) {
+          BEGIN S_SKIP; 
+        }
+        /* you might need a ; in the string below */
+        send("]%c;\n",yytext[0]);
+        sccount=0;
+      }
+}
+
+<S_VARIABLE>{
+"+"		    { send(".");}
+}
+
 <S_VARIABLE,S_TRUE_FALSE_STMT,S_LET,S_MAP>{
-"=="                { LLDBUG_PR1("[==]"); RETURN(EQ_op);  }
-"!="                { LLDBUG_PR1("[!=]"); RETURN(NE_op);  }
-">"                 { LLDBUG_PR1("[>]");  RETURN(GT_op);  }
-">="                { LLDBUG_PR1("[>=]"); RETURN(GE_op);  }
-"<"                 { LLDBUG_PR1("[<]");  RETURN(LT_op);  }
-"<="                { LLDBUG_PR1("[<=]"); RETURN(LE_op);  }
-"&&"                { LLDBUG_PR1("[&&]"); RETURN(AND_op); }
-"||"                { LLDBUG_PR1("[||]"); RETURN(OR_op);  }
-"//"                { if(Pcount==0) BEGIN S_SKIP;         }
+"=="                { LLDBUG_PR1("[==]"); send(" eq ");  }
+"!="                { LLDBUG_PR1("[!=]"); send(" ne ");  }
+">"                 { LLDBUG_PR1("[>]");  send(yytext);  }
+">="                { LLDBUG_PR1("[>=]"); send(yytext);  }
+"<"                 { LLDBUG_PR1("[<]");  send(yytext);  }
+"<="                { LLDBUG_PR1("[<=]"); send(yytext);  }
+"&&"                { LLDBUG_PR1("[&&]"); send(yytext);  }
+"||"                { LLDBUG_PR1("[||]"); send(yytext);  }
+"//"                { if(Pcount==0) {
+			 send("; #");
+			 BEGIN S_ECHO;
+                      }
+                    }
+[%]                 {send("%%");}
 {Operator}          { LLDBUG_PR2("[Op(%c) in VAR,TF_STMT,LET]",yytext[0]); send(yytext); }
 }
 
 
 
 <S_VARIABLE>{
-[\)]                     { LLDBUG_PR1("[)]"); Pcount--; if(Pcount == 0)  BEGIN S_TEXT; send(yytext); }
+[\)]                     { LLDBUG_PR1("[)]"); 
+                           Pcount--; 
+                           if(Pcount == 0) {
+			      send("</display>");
+                              BEGIN S_TEXT; 
+                              flush_delayed();
+                           } else {
+                              send(yytext); 
+                           }
+                         }
 [\\]{Space}*{EndLine}    { LLDBUG_PR2("[\\EoL continue in S_VARIABLE (DIS?)](%s)",yytext); /* continuation on next line */ }                       
-{EndLine}                { LLDBUG_PR1("[EoL within /dis()]\n"); RETURN(EoL); }
+{EndLine}                { LLDBUG_PR1("[EoL within /dis()]\n"); }
 .                   { char warn_msg[WARN_MSG_LENGTH]; 
                       sprintf(warn_msg,"When use a VARIABLE, an unexpected char [%c] is encountered.\n",yytext[0]);
                       capa_msg(MESSAGE_ERROR,warn_msg);
@@ -836,40 +1058,87 @@ send("$%s",yytext);
 }
 
 <S_TRUE_FALSE_STMT>{
-[\)]                     { LLDBUG_PRL1("[) in TRUE_FALSE]"); Pcount--; if(Pcount == 0)  BEGIN S_NEXT_LINE; return(yytext[0]); }
-[\\]{Space}*{EndLine}    { LLDBUG_PR2("[\\EoL continue in S_TRUE_FALSE_STMT](%s)",yytext); /* continuation on next line */ }                       
-{EndLine}                { LLDBUG_PR1("[EoL within /IF()]\n"); RETURN(EoL); }
-.                   { char warn_msg[WARN_MSG_LENGTH]; 
+[\)]                     { 
+                           LLDBUG_PRL1("[) in TRUE_FALSE]");
+			   Pcount--; 
+			   if(Pcount == 0)  {
+				stop_cache();
+				send_stream(0,"\">\n");
+				send_stream(1,") {\n");
+				BEGIN S_NEXT_LINE;
+			   } else {
+                                send_stream(0,")");
+                                send_stream(1,")");
+			   }
+			 }
+[\\]{Space}*{EndLine}    { 
+			   LLDBUG_PR2("[\\EoL continue in S_TRUE_FALSE_STMT](%s)",yytext); /* continuation on next line */ 
+			 }                       
+{EndLine}                { 
+			   LLDBUG_PR1("[EoL within /IF()]\n"); RETURN(EoL);
+			 }
+.                   { 
+		      char warn_msg[WARN_MSG_LENGTH]; 
                       sprintf(warn_msg,"In /IF(), an unexpected char [%c] is encountered.\n",yytext[0]);
                       capa_msg(MESSAGE_ERROR,warn_msg);
                     }
 }
 
 <S_STRING>{
-[\\][\\]            { char  *aptr = yytext;
-                      while( *aptr )   *Current_char_p++ = *aptr++;
+[\\][\\]            { /*char  *aptr = yytext;
+			while( *aptr )   *Current_char_p++ = *aptr++;*/
+                      send(yytext);
                     }
-[\\][\"]            { *Current_char_p++ = '"';  }
+[\\][\"]            { /**Current_char_p++ = '"';*/ send("\\\"");  }
 [\\]{Space}*[\n]    { LLDBUG_PR2("[\\CR continue in S_STRING](%s)",yytext); /* continuation on next line */ }                       
 [\"]                { /* end of a string constant --   */
-                      yylval = (Symbol *) capa_malloc(1, sizeof(Symbol));
-		      *Current_char_p = '\0';
-	              yylval->s_str = strsave(String_buf);  /* ****   */
-		      yylval->s_type = S_CONSTANT;
-		      /* printf("STRING:%s\n", String_buf); */
-		      LLDBUG_PR2("[%s\"END str]",String_buf);
+                      send("'");
 		      yy_pop_state();
-		      RETURN(S_CONSTANT); }
+		    }
+[%]                 { /*Escape percent signs so that vasprintf doesn't choke */
+                      send("%%");
+                    }
+[\']                { /* Escape single quotes so that perl doesn't choke */
+                      send("\\\'");
+                    }
 {EndLine}           { /* check for termination of string constant */
                       char warn_msg[WARN_MSG_LENGTH];
                       
-                      *Current_char_p = '\0';
                       sprintf(warn_msg,"STRING not terminated properly, an EoL encountered in the middle.\n%s\n",String_buf);
                       capa_msg(MESSAGE_ERROR,warn_msg);
                       yy_pop_state();
                     }
-.                   { char  *aptr = yytext;
-                      while( *aptr )   *Current_char_p++ = *aptr++;
+.                   { /*char  *aptr = yytext;
+			while( *aptr )   *Current_char_p++ = *aptr++;*/
+                      send(yytext);
+                    }
+}
+
+<S_STRINGINANS>{
+[\\][\\]            { /*char  *aptr = yytext;
+			while( *aptr )   *Current_char_p++ = *aptr++;*/
+                      if (dosend==1) send("%s",yytext);
+		      if (dosend==2) add_delayed("%s",yytext);
+                    }
+[\\][\"]            { /**Current_char_p++ = '"';*/ 
+                      if (dosend==1) send("%s",yytext);
+		      if (dosend==2) add_delayed("%s",yytext);
+                    }
+[\\]{Space}*[\n]    { LLDBUG_PR2("[\\CR continue in S_STRING](%s)",yytext); /* continuation on next line */ }                       
+[\"]                { /* end of a string constant --   */
+		      yy_pop_state();
+		    }
+{EndLine}           { /* check for termination of string constant */
+                      char warn_msg[WARN_MSG_LENGTH];
+                      
+                      sprintf(warn_msg,"STRING not terminated properly, an EoL encountered in the middle.\n%s\n",String_buf);
+                      capa_msg(MESSAGE_ERROR,warn_msg);
+                      yy_pop_state();
+                    }
+.                   { /*char  *aptr = yytext;
+			while( *aptr )   *Current_char_p++ = *aptr++;*/
+                      if (dosend==1) send("%s",yytext);
+		      if (dosend==2) add_delayed("%s",yytext);
                     }
 }
 
@@ -880,61 +1149,61 @@ send("$%s",yytext);
 {EndLine}                    { BEGIN S_TEXT; }
 }
 
-<S_LET,S_ANSWER,S_MAP>{
-[\\]{Space}*{EndLine}        { LLDBUG_PR1("[\\EoL let ans map]"); /* continuation */ }
-{EndLine}                    { LLDBUG_PR1("[EoL END let ans map]\n"); if(Pcount == 0) BEGIN S_TEXT; send(yytext); send_delayed("</script>"); }
+<S_ECHO>{
+[^\n]+$                      { send(yytext); }
+{EndLine}                    { send(yytext); BEGIN S_TEXT; }
 }
 
-<S_MAP>{
-[;,]                         { LLDBUG_PR2("[%c]",yytext[0]); return(yytext[0]);  }
-[\)]                         { LLDBUG_PR1("[) in MAP]"); Pcount--; 
-                               if(Pcount==0) {
-                                   BEGIN S_SKIP; 
-                               }
-                               return(yytext[0]); 
+<S_LET,S_ANSWER,S_MAP>{
+[\\]{Space}*{EndLine}        { LLDBUG_PR1("[\\EoL let ans map]"); /* continuation */ }
+{EndLine}                    { LLDBUG_PR1("[EoL END let ans map]\n"); 
+                               if(Pcount == 0) BEGIN S_TEXT; 
+                               send(";%s",yytext); 
                              }
 }
 
 <S_ANSCONTINUE>{
-{Space}+                 { /* ignore white spaces */ }
-[\\]{Space}*{EndLine}    { /* continuation */ }
-{EndLine}                { /* end of answer and/or other answers */ LLDBUG_PR1("[complete an answer<EoL>]"); 
-                           BEGIN S_TEXT; }
-"/AND"                   { LLDBUG_PR1("[AND]"); RETURN(ANS_AND); }
-"/OR"                    { LLDBUG_PR1("[OR]");  RETURN(ANS_OR);  }
-}
-
-<S_IF_SKIP>{
-^{Spaces}"/IF"[^\n]*{EndLine}    { IFcount++; LLDBUG_PRL2("[Skip IF <IFcount=%d>]\n",IFcount); 
-                                   IFstatus[IFcount] = IF_DONT_CARE;
-                                 }
-^{Spaces}"/ELSE"[^\n]*{EndLine}  {  LLDBUG_PRL2("[Skip ELSE <IFcount=%d>]",IFcount);
-                            IFcurrent[IFcount]=RUN_ELSE_PORTION; 
-                            if( IFstatus[IFcount] == IF_FALSE ) {
-                               LLDBUG_PRL1("[ELSE begin TEXT CR]\n");
-                               BEGIN S_TEXT;
-                            } 
-                            if( IFstatus[IFcount] == IF_TRUE ) {
-                               LLDBUG_PRL1("[ELSE THIS SHOULD NEVER HAPPEN.]\n");
-                            }
-                         }
-^{Spaces}"/ENDIF"[^\n]*{EndLine} { IFcount--; LLDBUG_PRL2("[Skip ENDIF <IFcount=%d>]\n",IFcount);
-                            if( IFcount == 0 ) {
-                               LLDBUG_PRL1("[ENDIF begin TEXT CR]\n");
-                               BEGIN S_TEXT;
-                            }
-                            if( (IFcurrent[IFcount] == RUN_IF_PORTION )&&(IFstatus[IFcount] == IF_TRUE)) {
-                               LLDBUG_PRL1("[ENDIF begin TEXT CR]\n");
-                               BEGIN S_TEXT;
-                            }
-                            if( (IFcurrent[IFcount] == RUN_ELSE_PORTION )&&(IFstatus[IFcount] == IF_FALSE)) {
-                               LLDBUG_PRL1("[ENDIF begin TEXT CR]\n");
-                               BEGIN S_TEXT;
-                            }
+{Spaces}{EndLine}{Spaces}"/AND"  { LLDBUG_PR1("[AND]");
+                                   compound_answer=-1;
+                                   /* implicit in LON-CAPA */ }
+{Spaces}{EndLine}{Spaces}"/OR"   { LLDBUG_PR1("[OR]"); 
+                                   compound_answer=-1;
+				   /*RETURN(ANS_OR); */ }
+{Spaces}{EndLine}{Spaces}"/ANS" { LLDBUG_PRL2("[ANS(%s)]",yytext); 
+                                Pcount = 0; 
+                                BEGIN S_ANSWER; 
+                                end_mode();
+                                if (!compound_answer) {
+			          if ( !is_dest_empty(EXP_DEST) ) {
+			            send("<postanswerdate>\n\t<startouttext />\n");
+                                    end_streams(EXP_DEST,0);
+                                    EXPflag=0;
+                                    send("\t<endouttext />\n</postanswerdate>\n");
+                                    }
+                                  send("</part>\n<part>\n"); 
+                                }
+				start_mode(MODE_ANSWER,NULL);
+                                send("<numericalresponse answer=\""); 
+				dosend=1;
+				firstparam=1;
+                                compound_answer=0;
+                                essay_answer=0;
+                                }
+{Spaces}{EndLine}                { 
+/* end of answer and/or other answers */
+                           LLDBUG_PR1("[complete an answer<EoL>]"); 
+			   if ( !is_dest_empty(EXP_DEST) ) {
+			     send("<postanswerdate>\n\t<startouttext />\n");
+                             end_streams(EXP_DEST,0);
+                             EXPflag=0;
+                             send("\t<endouttext />\n</postanswerdate>\n");
+                           }
+                           send("</part>\n<part>\n"); 
+                           BEGIN S_TEXT; 
                          }
-{EndLine}                { LLDBUG_PRL1("[SkipIF a CR]\n");       }
-[^\n]*$                  { LLDBUG_PRL2("[SkipIF anything <IFcount=%d>]",IFcount);   }
+{Spaces}		{ /* Do nothing */ }
 }
+
 <S_NEXT_LINE>{
 ([.]*){EndLine}          { /* this ignores everything until it hits an EoL */
                            LLDBUG_PRL2("[<S_NEXT_LINE> skip \'%s\' until EoL]\n",yytext); 
@@ -961,22 +1230,16 @@ send("$%s",yytext);
 
 <S_VERB>{
 ^{Spaces}"/ENDVERB" { LLDBUG_PRL1("[END VERB]\n"); 
-                      yylval = (Symbol *) capa_malloc(1, sizeof(Symbol));
-		      yylval->s_str = strsave(Dynamic_buf);  /* ****   */
-		      yylval->s_type = S_CONSTANT;  
-		      capa_mfree(Dynamic_buf);
-		      Dynamic_buf_cur=-1;
-		      Dynamic_buf_max=0;
-		      BEGIN S_TEXT;   RETURN(VERBATIM);   
+		      BEGIN S_TEXT;
+		      puts("\n</PRE>\n");
+		      end_mode();
 		    }
-.*|{EndLine}         { append_dynamic_buf(yytext); }
+.*|{EndLine}         { send(yytext); }
 }
 
 %%
 
 /* ========================================================================================== */
-extern void
-begin_if_skip() { BEGIN S_IF_SKIP; }
 
 extern void
 begin_while_skip() { Wcount=0; While_idx--; /* while is FALSE, pop it out from stack */ BEGIN S_WHILE_SKIP; }
@@ -1581,6 +1844,7 @@ int capa_eof()
     LexiProblem_p=NULL;
     /* printf("\nCAPA EOF\n"); fflush(stdout); */
   }
+  end_mode();
   return (0);
 #endif /*AVOIDYYINPUT*/
 }