diff options
Diffstat (limited to 'tecexec.c')
| -rw-r--r-- | tecexec.c | 2801 |
1 files changed, 2801 insertions, 0 deletions
diff --git a/tecexec.c b/tecexec.c new file mode 100644 index 0000000..6d94fd5 --- /dev/null +++ b/tecexec.c @@ -0,0 +1,2801 @@ +char *tecexec_c_version = "tecexec.c: $Revision: 1.1 $"; + +/* + * $Date: 2007/12/10 21:59:20 $ + * $Source: /cvsroot/videoteco/videoteco/tecexec.c,v $ + * $Revision: 1.1 $ + * $Locker: $ + */ + +/* tecexec.c + * The SWITCH/CASE statements which implement execution stage of the parser + * + * COPYRIGHT (c) 1985-2003 BY + * PAUL CANTRELL & J. M. NISHINAGA + * SUDBURY, MA 01776 + * ALL RIGHTS RESERVED + * + * This software is furnished in it's current state free of charge. + * The authors reserve all rights to the software. Further + * distribution of the software is not authorized. Modifications to + * the software may be made locally, but shall not be distributed + * without the consent of the authors. This software or any other + * copies thereof, may not be provided or otherwise made available + * to anyone without express permission of the authors. Title to and + * ownership of this software remains with the authors. + * + */ + +#include "teco.h" +#include "tecparse.h" + + extern struct cmd_token *jump_to_token; + extern struct cmd_token *last_token_executed; + extern struct cmd_token *last_cmd_list; + extern struct search_buff search_string; + extern char user_message[PARSER_STRING_MAX]; + + extern char exit_flag; + extern struct window *window_list; + extern struct buff_header *curbuf,*buffer_headers; + extern struct buff_header *qregister_push_down_list; + extern int last_search_pos1,last_search_pos2; + extern int last_search_status; + extern int remembered_dot; + extern char intr_flag; + extern char immediate_execute_flag; + extern struct window *curwin; + + int find_conditional_else(struct cmd_token *); + int find_conditional_end(struct cmd_token *); + int compare_label(struct cmd_token *,struct cmd_token *); + void extract_label(struct cmd_token *,char *); + + + +/* EXECUTE_A_STATE - Do the runtime execution part of a command + * + * Function: + * + * This routine is called to execute the runtime part of a command token. + * This could be during immediate execution mode, directly after a token + * gets parsed, or it could be during final stages when we are either + * running commands which cannot be undone (like ex), or simply complex + * things like an iteration. The execute_state which we dispatch on was + * set by the parse state during syntax analysis. + */ +int +execute_a_state(ct,uct) +register struct cmd_token *ct; +struct cmd_token *uct; +{ +register struct undo_token *ut; +char tmp_buffer[LINE_BUFFER_SIZE],tmp_message[LINE_BUFFER_SIZE]; + + PREAMBLE(); + + last_token_executed = ct; + + switch(ct->execute_state){ +/* + * Here to return the numeric value of a q-register. This has to be done + * at run time because the value of the q-register might be modified during + * the course of the command. Note that we return an error if the q-register + * has never been loaded. Otherwise, we return the value in tmpval so that + * it can be the input to further arithmetic expressions. + */ + case EXEC_C_QVALUE: + {/* Local Block */ + register struct buff_header *hbp; + + if(ct->q_register == '*'){ + ct->ctx.tmpval = curbuf->buffer_number; + return(SUCCESS); + }/* End IF */ + + hbp = buff_qfind(ct->q_register,0); + if(hbp == NULL){ + sprintf(tmp_message,"?Q-register %c empty",ct->q_register); + error_message(tmp_message); + return(FAIL); + }/* End IF */ + ct->ctx.tmpval = hbp->ivalue; + return(SUCCESS); + }/* End Local Block */ +/* + * Here to return the numeric value of a q-register and also increment it's + * value. Other than the incrementing, this is exactly like the QVALUE state. + */ + case EXEC_C_PERCENT_VALUE: + {/* Local Block */ + register struct buff_header *hbp; + + hbp = buff_qfind(ct->q_register,0); + if(hbp == NULL){ + sprintf(tmp_message,"?Q-register %c empty",ct->q_register); + error_message(tmp_message); + return(FAIL); + }/* End IF */ +/* + * Set up an undo block so that we can put the previous value back into + * the q-register if this command gets undone. + */ + ut = allocate_undo_token(uct); + if(ut == NULL) return(FAIL); + + ut->opcode = UNDO_C_UQREGISTER; + ut->iarg1 = ct->q_register; + ut->iarg2 = hbp->ivalue; + + hbp->ivalue += ct->ctx.tmpval; + ct->ctx.tmpval = hbp->ivalue; + return(SUCCESS); + }/* End Local Block */ +/* + * Here to read a file into a q-register. We also set up undo tokens to + * restore the previous contents of the q-register if he undoes this. + */ + case EXEC_C_EQQREGISTER: + {/* Local Block */ + register struct buff_header *qbp; + struct wildcard_expansion *name_list,*np; + struct wildcard_expansion *expand_filename(); + + ut = allocate_undo_token(uct); + if(ut == NULL) return(FAIL); + ut->opcode = UNDO_C_CHANGEBUFF; + ut->iarg1 = curbuf->buffer_number; + + qbp = buff_qfind(ct->ctx.tmpval,1); + + if(ct->ctx.tmpval == '*'){ + if(ct->ctx.carg){ + rename_edit_buffer(curbuf,ct->ctx.carg,uct); + }/* End IF */ + else { + load_qname_register(); + buff_switch(qbp,1); + }/* End Else */ + + if(ct->ctx.flags & CTOK_M_COLON_SEEN){ + ct->ctx.tmpval = SUCCESS; + }/* End IF */ + return(SUCCESS); + }/* End IF */ + + if(ct->ctx.carg == NULL || ct->ctx.carg[0] == '\0'){ + buff_switch(qbp,1); + if(ct->ctx.flags & CTOK_M_COLON_SEEN){ + ct->ctx.tmpval = SUCCESS; + }/* End IF */ + return(SUCCESS); + }/* End IF */ +/* + * Delete the previous contents of the q-register, but allow it to be + * reconstructed if this gets undone. Note that we don't have to do + * this if there was nothing there. Also, if the colon modifier was + * specified, then we append to the buffer instead of replacing it. + */ + if((ct->ctx.flags & CTOK_M_COLON_SEEN) == 0 && qbp->zee){ + buff_delete_with_undo(uct,qbp,0,qbp->zee); + }/* End IF */ + +/* + * Set up an undo argument to delete any characters which get inserted as + * part of the buff_read we do to load the q-register. + */ + ut = allocate_undo_token(uct); + if(ut == NULL) return(FAIL); + ut->opcode = UNDO_C_DELETE; + ut->carg1 = (char *)qbp; + ut->iarg1 = qbp->dot; + ut->iarg2 = qbp->zee; + + np = expand_filename(ct->ctx.carg); + if(np == NULL){ + sprintf(tmp_message,"EQ No such file <%s>",ct->ctx.carg); + error_message(tmp_message); + if(ct->ctx.flags & CTOK_M_COLON_SEEN){ + ct->ctx.tmpval = FAIL; + return(SUCCESS); + }/* End IF */ + return(FAIL); + }/* End IF */ + + while(np){ + buff_read(qbp,np->we_name); + name_list = np; + np = np->we_next; + tec_release(TYPE_C_WILD,(char *)name_list); + }/* End While */ + + ut->iarg2 = qbp->zee - ut->iarg2; + + if(ct->ctx.flags & CTOK_M_COLON_SEEN){ + ct->ctx.tmpval = SUCCESS; + }/* End IF */ + return(SUCCESS); + }/* End Local Block */ + +/* + * Here to load a q-register with a numeric value. Note that not only do we + * have to put the new number into it, we also have to set up the undo token + * so that if this command is backed out of we can restore the previous value + * to the q-register. + */ + case EXEC_C_UQREGISTER: + {/* Local Block */ + register struct buff_header *hbp; +/* + * Find the q-register. If it does not exist yet, create it. + */ + hbp = buff_qfind(ct->q_register,1); + if(hbp == NULL){ + return(FAIL); + }/* End IF */ +/* + * Insure that we have an argument to store + */ + if(ct->ctx.iarg1_flag == NO){ + error_message("?Argument required for U command"); + return(FAIL); + }/* End IF */ +/* + * Set up an undo block so that we can put the previous value back into + * the q-register if this command gets undone. + */ + ut = allocate_undo_token(uct); + if(ut == NULL) return(FAIL); + ut->opcode = UNDO_C_UQREGISTER; + ut->iarg1 = ct->q_register; + ut->iarg2 = hbp->ivalue; + + hbp->ivalue = ct->ctx.iarg1; + return(SUCCESS); + }/* End Local Block */ + +/* + * Here to load the text contents of the specified q-register into the + * edit buffer at the current location. + */ + case EXEC_C_GQREGISTER: + {/* Local Block */ + register struct buff_header *hbp; + register struct buff_header *qbp; + + hbp = curbuf; +/* + * If this is the buffer name q-register, we have to do some special + * stuff. + */ + if(ct->q_register == '*') load_qname_register(); +/* + * Get a pointer to the q-register buffer structure. If it doesn't + * exist, declare an error. + */ + qbp = buff_qfind(ct->q_register,0); + if(qbp == NULL){ + sprintf(tmp_message,"?Q-register <%c> does not exist", + ct->q_register); + error_message(tmp_message); + return(FAIL); + }/* End IF */ +/* + * Test if the q-register is empty, and declare an error if it is + */ + if(qbp->zee == 0){ + sprintf(tmp_message,"?Q-register <%c> is empty", + ct->q_register); + error_message(tmp_message); + return(FAIL); + }/* End IF */ +/* + * Make sure the Q register and the edit buffer are not the same buffer + */ + if(qbp == hbp){ + strcpy(tmp_message, + "?Cannot use G to copy from a Q-register to itself"); + error_message(tmp_message); + return(FAIL); + }/* End IF */ +/* + * Now copy the text out of the q-register and insert it into the edit buffer + */ + buff_insert_from_buffer_with_undo(uct,hbp,hbp->dot,qbp,0,qbp->zee); + + return(SUCCESS); + }/* End Local Block */ + +/* + * Here to execute the macro in the specified Q register + */ + case EXEC_C_MQREGISTER: + {/* Local Block */ + register struct buff_header *qbp; +/* + * Get a pointer to the q-register buffer structure. If it doesn't + * exist, declare an error. + */ + qbp = buff_qfind(ct->q_register,0); + if(qbp == NULL){ + sprintf(tmp_message,"?Q-register <%c> does not exist", + ct->q_register); + error_message(tmp_message); + return(FAIL); + }/* End IF */ +/* + * It's an error if the q-register is empty + */ + if(qbp->zee == 0){ + sprintf(tmp_message,"?Q-register <%c> is empty", + ct->q_register); + error_message(tmp_message); + return(FAIL); + }/* End IF */ +/* + * Set up the undo block, and pass its address to the tecmacro routine so + * that the tecmacro can chain the command list off of it. + */ + ut = allocate_undo_token(uct); + if(ut == NULL) return(FAIL); + ut->opcode = UNDO_C_MACRO; + ut->carg1 = NULL; + + return(tecmacro(qbp,ct,(struct cmd_token **)&ut->carg1)); + + }/* End Local Block */ + +/* + * Here to load text into a q-register in response to the X command. + * This clears any existing text from the q-register, and then copies + * the specified text into it. + */ + case EXEC_C_XQREGISTER: + {/* Local Block */ + register struct buff_header *hbp; + register struct buff_header *qbp; + register struct buff_line *lbp; + register int i,j; + int pos1,pos2; + + hbp = curbuf; +/* + * Get a pointer to the q-register buffer structure. If it doesn't + * exist, create it. + */ + qbp = buff_qfind(ct->q_register,1); + if(qbp == NULL){ + return(FAIL); + }/* End IF */ +/* + * Make sure the Q register and the edit buffer are not the same buffer + */ + if(qbp == hbp){ + strcpy(tmp_message, + "?Cannot use X to copy from a Q-register to itself"); + error_message(tmp_message); + return(FAIL); + }/* End IF */ +/* + * If two arguments were specified, then he has specified an a,b range to + * be copied. + */ + if(ct->ctx.iarg1_flag == YES && ct->ctx.iarg2_flag == YES){ + pos1 = ct->ctx.iarg1; + pos2 = ct->ctx.iarg2; + if(parse_illegal_buffer_position(pos1,pos2,"X")){ + return(FAIL); + }/* End IF */ + if(pos2 < pos1){ + pos2 = ct->ctx.iarg1; + pos1 = ct->ctx.iarg2; + }/* End IF */ + }/* End IF */ +/* + * Else, if it was a single command, it is a relative copy which affects a + * portion of the buffer in a similar way as if it was an L command. Our job + * now is to turn it into a a,b range. + */ + else { + lbp = buff_find_line(hbp,hbp->dot); + if(lbp == NULL) return(FAIL); +/* + * Start by pretending it was a 0L command, and get to the begining of + * the line. That allows us to not worry about offset onto current line. + */ + j = 0 - buff_find_offset(hbp,lbp,hbp->dot); + i = ct->ctx.iarg1; + if(ct->ctx.iarg1_flag == NO) i = 1; +/* + * If argument is positive, movement is forward + */ + if(i > 0){ + while(i-- && lbp){ + j += lbp->byte_count; + lbp = lbp->next_line; + }/* End WHILE */ + if(lbp == NULL){ + error_message("?Attempt to Move Pointer Off Page with X"); + return(FAIL); + }/* End IF */ + pos1 = hbp->dot; + pos2 = hbp->dot + j; + }/* End IF */ +/* + * Else, it is backwards + */ + else { + + while(i++ && lbp){ + lbp = lbp->prev_line; + if(lbp == NULL){ + error_message("?Attempt to Move Pointer Off Page with X"); + return(FAIL); + }/* End IF */ + j -= lbp->byte_count; + }/* End WHILE */ + pos1 = hbp->dot + j; + pos2 = hbp->dot; + }/* End Else */ + }/* End Else */ +/* + * Now that we have calculated the buffer positions to be used by the command, + * we can actually do the work. + */ + j = pos2 - pos1; +/* + * Delete the previous contents of the q-register, but allow it to be + * reconstructed if this gets undone. Note that we don't have to do + * this if there was nothing there. Also, if the colon modifier was + * specified, then we append to the buffer instead of replacing it. + */ + if((ct->ctx.flags & CTOK_M_COLON_SEEN) == 0 && qbp->zee){ + buff_delete_with_undo(uct,qbp,0,qbp->zee); + }/* End IF */ +/* + * Now copy the new text from the edit buffer into the q-register + */ + buff_insert_from_buffer_with_undo(uct,qbp,qbp->zee,hbp,pos1,j); +/* + * If the q-register specified is '*', then the actual result is to rename + * the current buffer. + */ + if(ct->q_register == '*'){ + rename_edit_buffer(hbp,qbp->name,uct); + }/* End IF */ + + return(SUCCESS); + }/* End Local Block */ + +/* + * Here to load text into a q-register in response to the * command. + * This clears any existing text from the q-register, and then copies + * the previous command string into it. + */ + case EXEC_C_SAVECOMMAND: + {/* Local Block */ + register struct buff_header *qbp; + register struct cmd_token *oct; + register int i; + +/* + * Get a pointer to the q-register buffer structure. If it doesn't + * exist, create it. + */ + qbp = buff_qfind(ct->q_register,1); + if(qbp == NULL){ + return(FAIL); + }/* End IF */ +/* + * Delete the previous contents of the q-register, but allow it to be + * reconstructed if this gets undone. Note that we don't have to do + * this if there was nothing there. + */ + if(qbp->zee) buff_delete_with_undo(uct,qbp,0,qbp->zee); +/* + * Set up an undo token to delete the contents of the q-register that we + * are about to load. + */ + ut = allocate_undo_token(uct); + if(ut == NULL) return(FAIL); + ut->opcode = UNDO_C_DELETE; + ut->carg1 = (char *)qbp; + ut->iarg1 = 0; + ut->iarg2 = 0; + +/* + * Now we go through the last command list and anytime we see an input + * byte, we copy it into the q-register. + */ + oct = last_cmd_list; + i = 0; + while(oct){ + if(oct->flags & TOK_M_EAT_TOKEN){ + buff_insert_char(qbp,i++,oct->input_byte); + ut->iarg2 += 1; + }/* End IF */ + oct = oct->next_token; + }/* End While */ + + return(SUCCESS); + }/* End Local Block */ +/* + * Here to push the specified q-register onto the q-register stack + */ + case EXEC_C_PUSH_QREGISTER: + if(ct->q_register == '*') load_qname_register(); + ut = allocate_undo_token(uct); + if(ut == NULL) return(FAIL); + if(push_qregister(ct->q_register) != SUCCESS) return(FAIL); + ut->opcode = UNDO_C_POP; + return(SUCCESS); +/* + * Here to pop a Q register off of the stack and replace a Q register + * with it. Since this destroys the Q register we pop onto, we first + * must save the entire Q register. + */ + case EXEC_C_POP_QREGISTER: + {/* Local Block */ + register struct buff_header *pbp; + register struct buff_header *qbp; +/* + * Get a pointer to the pushed buffer structure. If there are none on + * the stack, then he has tried to pop too many, and this is an error. + */ + pbp = qregister_push_down_list; + + if(pbp == NULL){ + error_message("?Q-register push down list is empty"); + return(FAIL); + }/* End IF */ +/* + * Get a pointer to the q-register buffer structure. If it doesn't + * exist, create it. + */ + qbp = buff_qfind(ct->q_register,1); + if(qbp == NULL){ + return(FAIL); + }/* End IF */ +/* + * Arrange to restore the numeric contents of the Q register if this + * should be undone. + */ + ut = allocate_undo_token(uct); + if(ut == NULL) return(FAIL); + ut->opcode = UNDO_C_UQREGISTER; + ut->iarg1 = ct->q_register; + ut->iarg2 = qbp->ivalue; + + qbp->ivalue = pbp->ivalue; +/* + * Delete the previous contents of the q-register, but allow it to be + * reconstructed if this gets undone. Note that we don't have to do + * this if there was nothing there. + */ + if(qbp->zee){ + if(buff_delete_with_undo(uct,qbp,0,qbp->zee) == FAIL){ + return(FAIL); + }/* End IF */ + }/* End IF */ +/* + * Arrange for it to be deleted if this gets undone. + */ + ut = allocate_undo_token(uct); + if(ut == NULL) return(FAIL); + ut->opcode = UNDO_C_DELETE; + ut->carg1 = (char *)qbp; + ut->iarg1 = 0; + ut->iarg2 = pbp->zee; +/* + * Transfer the contents of the pushed register into the actual Q register + */ + buff_bulk_insert(qbp,0,pbp->zee,pbp->first_line); + pbp->first_line = NULL; + qbp->pos_cache.lbp = NULL; + qbp->pos_cache.base = 0; + +/* + * Arrange that the push be re-done if the pop is undone. + */ + ut = allocate_undo_token(uct); + if(ut == NULL) return(FAIL); + ut->opcode = UNDO_C_PUSH; + ut->iarg1 = ct->q_register; +/* + * Place it on the main buffer list so that buff_destroy can find it + */ + qregister_push_down_list = pbp->next_header; + pbp->next_header = buffer_headers; + buffer_headers = pbp; + buff_destroy(pbp); +/* + * If the q-register specified is '*', then the actual result is to rename + * the current buffer. + */ + if(ct->q_register == '*'){ + rename_edit_buffer(curbuf,qbp->name,uct); + }/* End IF */ + + return(SUCCESS); + }/* End Local Block */ + +/* + * Here to return the current position of 'dot' + */ + case EXEC_C_DOTVALUE: + ct->ctx.tmpval = curbuf->dot; + return(SUCCESS); +/* + * Here to return the number of bytes in the edit buffer + */ + case EXEC_C_ZEEVALUE: + ct->ctx.tmpval = curbuf->zee; + return(SUCCESS); +/* + * Here to return the value 0,Z which H is shorthand for + */ + case EXEC_C_HVALUE: + ct->ctx.iarg1 = 0; + ct->ctx.iarg2 = curbuf->zee; + return(SUCCESS); +/* + * Print out the numeric value of an expression + */ + case EXEC_C_EQUALS: + if(ct->ctx.iarg1_flag == NO){ + error_message("?Argument required for = command"); + return(FAIL); + }/* End IF */ + + sprintf(tmp_buffer,"value = %d",ct->ctx.iarg1); + screen_message(tmp_buffer); + return(SUCCESS); + + case EXEC_C_TWO_EQUALS: + sprintf(tmp_buffer,"value = 0%o",ct->ctx.iarg1); + screen_message(tmp_buffer); + return(SUCCESS); + + case EXEC_C_THREE_EQUALS: + sprintf(tmp_buffer,"value = 0x%X",ct->ctx.iarg1); + screen_message(tmp_buffer); + return(SUCCESS); +/* + * Here to insert the value of the expression into the edit buffer as a + * decimal representation. + */ + case EXEC_C_BACKSLASH: + {/* Local Block */ + register int i,j; + char *cp; + int length = 0; + + if(ct->ctx.iarg2 < 2 || ct->ctx.iarg2 > 36) ct->ctx.iarg2 = 10; + j = ct->ctx.iarg1; + cp = tmp_buffer + sizeof(tmp_buffer); + do { + i = j % ct->ctx.iarg2; + j = (j - i) / ct->ctx.iarg2; + if(i > 9) i += ('A' - 10); + else i += '0'; + *(--cp) = i; + length += 1; + } while(j); + + buff_insert_with_undo(uct,curbuf,curbuf->dot,cp,length); + return(SUCCESS); + + }/* End Local Block */ +/* + * Here to interpret the ascii digits following 'dot' in the edit buffer + * as a decimal number, and return this number as the value of this expression, + * leaving 'dot' positioned after the digits. + */ + case EXEC_C_BACKSLASHARG: + {/* Local Block */ + register int i; + register int radix; + + ut = allocate_undo_token(uct); + if(ut == NULL) return(FAIL); + ut->opcode = UNDO_C_CHANGEDOT; + ut->iarg1 = curbuf->dot; + + radix = ct->ctx.tmpval; + ct->ctx.tmpval = 0; + + for(;;){ + i = buff_contents(curbuf,curbuf->dot); + + if(i >= '0' && i <= '9') i -= '0'; + else if(i >= 'a' && i <= 'z') i -= ('a' - 10); + else if(i >= 'A' && i <= 'Z') i -= ('A' - 10); + else break; + + if(i < 0 || i >= radix) break; + + ct->ctx.tmpval = ct->ctx.tmpval * radix + i; + if(curbuf->dot == curbuf->zee) break; + curbuf->dot++; + }/* End FOR */ + + return(SUCCESS); + + }/* End Local Block */ +/* + * The poor bastard wants to leave... + */ + case EXEC_C_EXITCOMMAND: + {/* Local Block */ + register struct buff_header *hbp; + + if(ct->ctx.iarg1_flag == NO || ct->ctx.iarg1 != -1){ + for(hbp = buffer_headers; hbp != NULL; hbp = hbp->next_header){ + if(hbp->buffer_number <= 0) continue; + if(hbp->ismodified != 0 && hbp->isreadonly == 0){ + error_message("?Modified buffers exist"); + return(FAIL); + }/* End IF */ + }/* End FOR */ + }/* End IF */ + + ut = allocate_undo_token(uct); + if(ut == NULL) return(FAIL); + ut->opcode = UNDO_C_SET_EXIT_FLAG; + + exit_flag = YES; + return(SUCCESS); + }/* End Local Block */ +/* + * Here to jump to an absolute position in the buffer + */ + case EXEC_C_JUMP: + if(ct->ctx.iarg1_flag == YES && ct->ctx.iarg1 < 0){ + error_message("?Negative Argument to J"); + return(FAIL); + }/* End IF */ + + if(ct->ctx.iarg1_flag == NO) ct->ctx.iarg1 = 0; + + if(parse_illegal_buffer_position(ct->ctx.iarg1,0,"J")){ + return(FAIL); + }/* End IF */ + + ut = allocate_undo_token(uct); + if(ut == NULL) return(FAIL); + ut->opcode = UNDO_C_CHANGEDOT; + ut->iarg1 = curbuf->dot; + + if(ct->ctx.iarg1_flag == NO) curbuf->dot = 0; + else curbuf->dot = ct->ctx.iarg1; + return(SUCCESS); +/* + * Here to move dot by a relative number of buffer positions + */ + case EXEC_C_CHAR: + {/* Local Block */ + register int i; + + i = curbuf->dot + 1; + + if(ct->ctx.iarg1_flag == YES){ + i = curbuf->dot + ct->ctx.iarg1; + }/* End IF */ + + if(parse_illegal_buffer_position(i,0,"C")) return(FAIL); + + ut = allocate_undo_token(uct); + if(ut == NULL) return(FAIL); + ut->opcode = UNDO_C_CHANGEDOT; + ut->iarg1 = curbuf->dot; + + curbuf->dot = i; + return(SUCCESS); + }/* End Local Block */ +/* + * Here to move dot by a relative number of buffer positions, just like + * the "C" command, except that the direction is by default backwards. + */ + case EXEC_C_RCHAR: + {/* Local Block */ + register int i; + + i = curbuf->dot - 1; + if(ct->ctx.iarg1_flag == YES){ + i = curbuf->dot - ct->ctx.iarg1; + }/* End IF */ + + if(parse_illegal_buffer_position(i,0,"R")) return(FAIL); + + ut = allocate_undo_token(uct); + if(ut == NULL) return(FAIL); + ut->opcode = UNDO_C_CHANGEDOT; + ut->iarg1 = curbuf->dot; + + curbuf->dot = i; + return(SUCCESS); + }/* End Local Block */ +/* + * Here to delete the specified number of characters following 'dot'. + * A negative value indicates we should delete characters BEFORE 'dot'. + */ + case EXEC_C_DELETE: + {/* Local Block */ + register int i; + + i = 1; + if(ct->ctx.iarg1_flag == YES) i = ct->ctx.iarg1; + + if(parse_illegal_buffer_position(curbuf->dot+i,0,"D")){ + return(FAIL); + }/* End IF */ + + ut = allocate_undo_token(uct); + if(ut == NULL) return(FAIL); + ut->opcode = UNDO_C_CHANGEDOT; + ut->iarg1 = curbuf->dot; + + if(i < 0){ + i = 0 - i; + curbuf->dot -= i; + }/* End IF */ + +/* + * Call the standard routine which deletes the specified buffer positions + * and constructs the undo list so that it can be rebuilt if necessary. + */ + if(i) buff_delete_with_undo(uct,curbuf,curbuf->dot,i); + + return(SUCCESS); + + }/* End Local Block */ +/* + * Here to move 'dot' by the specified number of words. Note that words + * can have a pretty nebulous definition, depending on what you are doing. + * This should probably have a q-register which contains all of the delimeters. + */ + case EXEC_C_WORD: + {/* Local Block */ + register int count; + + ut = allocate_undo_token(uct); + if(ut == NULL) return(FAIL); + ut->opcode = UNDO_C_CHANGEDOT; + ut->iarg1 = curbuf->dot; + + count = ct->ctx.iarg1; + if(ct->ctx.iarg1_flag == NO) count = 1; + + cmd_wordmove(count); + + return(SUCCESS); + + }/* End Local Block */ +/* + * Here to delete the specified number of words. Note that words + * can have a pretty nebulous definition, depending on what you are doing. + * This should probably have a q-register which contains all of the delimeters. + */ + case EXEC_C_DELWORD: + {/* Local Block */ + register int count; + int original_position; + int pos; + + ut = allocate_undo_token(uct); + if(ut == NULL) return(FAIL); + ut->opcode = UNDO_C_CHANGEDOT; + ut->iarg1 = original_position = curbuf->dot; + + count = ct->ctx.iarg1; + if(ct->ctx.iarg1_flag == NO) count = 1; + + cmd_wordmove(count); + + pos = original_position; + count = curbuf->dot - original_position; + if(count < 0){ + count = 0 - count; + pos = curbuf->dot; + }/* End IF */ + + if(count) buff_delete_with_undo(uct,curbuf,pos,count); + + return(SUCCESS); + + }/* End Local Block */ +/* + * Here to delete backward the specified number of words. Note that + * words can have a pretty nebulous definition, depending on what you are + * doing. This should probably have a q-register which contains all of the + * delimeters. + */ + case EXEC_C_RDELWORD: + {/* Local Block */ + register int count; + int original_position; + int pos; + + ut = allocate_undo_token(uct); + if(ut == NULL) return(FAIL); + ut->opcode = UNDO_C_CHANGEDOT; + ut->iarg1 = original_position = curbuf->dot; + + count = 0 - ct->ctx.iarg1; + if(ct->ctx.iarg1_flag == NO) count = -1; + + cmd_wordmove(count); + + pos = original_position; + count = curbuf->dot - original_position; + if(count < 0){ + count = 0 - count; + pos = curbuf->dot; + }/* End IF */ + + if(count) buff_delete_with_undo(uct,curbuf,pos,count); + + return(SUCCESS); + + }/* End Local Block */ +/* + * Here to move the 'dot' by the specified number of lines. + */ + case EXEC_C_LINE: + {/* Local Block */ + register struct buff_header *hbp; + register struct buff_line *lbp; + register int i,j; + + hbp = curbuf; + lbp = buff_find_line(hbp,hbp->dot); +/* + * Start by pretending it was a 0L command, and get to the begining of + * the line. That allows us to not worry about offset onto current line. + */ + j = 0 - buff_find_offset(hbp,lbp,hbp->dot); + i = ct->ctx.iarg1; + if(ct->ctx.iarg1_flag == NO) i = 1; +/* + * If argument is positive, movement is forward + */ + if(i > 0){ + while(i-- && lbp){ + j += lbp->byte_count; + lbp = lbp->next_line; + }/* End WHILE */ + if(lbp == NULL){ + error_message("?Attempt to Move Pointer Off Page with L"); + return(FAIL); + }/* End IF */ + }/* End IF */ + + else { + while(i++ && lbp){ + lbp = lbp->prev_line; + if(lbp == NULL){ + error_message("?Attempt to Move Pointer Off Page with L"); + return(FAIL); + }/* End IF */ + j -= lbp->byte_count; + }/* End WHILE */ + }/* End Else */ + + ut = allocate_undo_token(uct); + if(ut == NULL) return(FAIL); + ut->opcode = UNDO_C_CHANGEDOT; + ut->iarg1 = hbp->dot; + + hbp->dot += j; + return(SUCCESS); + }/* End Local Block */ +/* + * Here to move the 'dot' backward by the specified number of lines. + */ + case EXEC_C_RLINE: + {/* Local Block */ + register struct buff_header *hbp; + register struct buff_line *lbp; + register int i,j; + + hbp = curbuf; + lbp = buff_find_line(hbp,hbp->dot); +/* + * Start by pretending it was a 0L command, and get to the begining of + * the line. That allows us to not worry about offset onto current line. + */ + j = 0 - buff_find_offset(hbp,lbp,hbp->dot); + i = 0 - ct->ctx.iarg1; + if(ct->ctx.iarg1_flag == NO) i = -1; +/* + * If argument is positive, movement is forward + */ + if(i > 0){ + while(i-- && lbp){ + j += lbp->byte_count; + lbp = lbp->next_line; + }/* End WHILE */ + if(lbp == NULL){ + error_message("?Attempt to Move Pointer Off Page with B"); + return(FAIL); + }/* End IF */ + }/* End IF */ + + else { + while(i++ && lbp){ + lbp = lbp->prev_line; + if(lbp == NULL){ + error_message("?Attempt to Move Pointer Off Page with B"); + return(FAIL); + }/* End IF */ + j -= lbp->byte_count; + }/* End WHILE */ + }/* End Else */ + + ut = allocate_undo_token(uct); + if(ut == NULL) return(FAIL); + ut->opcode = UNDO_C_CHANGEDOT; + ut->iarg1 = hbp->dot; + + hbp->dot += j; + return(SUCCESS); + }/* End Local Block */ +/* + * Here to kill the specified number of lines. + */ + case EXEC_C_KILL: + {/* Local Block */ + register struct buff_header *hbp; + register struct buff_line *lbp; + register int i,j; + int pos1,pos2; + + hbp = curbuf; +/* + * If two arguments were specified, then he has specified an a,b range to + * be killed. + */ + if(ct->ctx.iarg1_flag == YES && ct->ctx.iarg2_flag == YES){ + pos1 = ct->ctx.iarg1; + pos2 = ct->ctx.iarg2; + if(parse_illegal_buffer_position(pos1,pos2,"K")){ + return(FAIL); + }/* End IF */ + if(pos2 < pos1){ + pos2 = ct->ctx.iarg1; + pos1 = ct->ctx.iarg2; + }/* End IF */ + }/* End IF */ +/* + * Else, if it was a single command, it is a relative kill which affects a + * portion of the buffer in a similar way as if it was an L command. Our job + * now is to turn it into a a,b range. + */ + else { + lbp = buff_find_line(hbp,hbp->dot); +/* + * Start by pretending it was a 0L command, and get to the begining of + * the line. That allows us to not worry about offset onto current line. + */ + j = 0 - buff_find_offset(hbp,lbp,hbp->dot); + i = ct->ctx.iarg1; + if(ct->ctx.iarg1_flag == NO) i = 1; +/* + * If argument is positive, movement is forward + */ + if(i > 0){ + while(i-- && lbp){ + j += lbp->byte_count; + lbp = lbp->next_line; + }/* End WHILE */ + if(lbp == NULL){ + error_message("?Attempt to Move Pointer Off Page with K"); + return(FAIL); + }/* End IF */ + pos1 = hbp->dot; + pos2 = hbp->dot + j; + }/* End IF */ + + else { + + while(i++ && lbp){ + lbp = lbp->prev_line; + if(lbp == NULL){ + error_message("?Attempt to Move Pointer Off Page with K"); + return(FAIL); + }/* End IF */ + j -= lbp->byte_count; + }/* End WHILE */ + pos1 = hbp->dot + j; + pos2 = hbp->dot; + }/* End Else */ + }/* End Else */ + + j = pos2 - pos1; + ut = allocate_undo_token(uct); + if(ut == NULL) return(FAIL); + ut->opcode = UNDO_C_CHANGEDOT; + ut->iarg1 = hbp->dot; + +/* + * Call the standard routine which deletes the specified buffer positions + * and constructs the undo list so that it can be rebuilt if necessary. + */ + if(j) buff_delete_with_undo(uct,hbp,pos1,j); + + return(SUCCESS); + + }/* End Local Block */ +/* + * Here to insert a character as part of an insert command + */ + case EXEC_C_INSERT: + buff_insert_char_with_undo( + uct, + curbuf, + curbuf->dot, + ct->ctx.iarg1_flag ? ct->ctx.iarg1 : ct->input_byte + ); + return(SUCCESS); +/* + * This state is used when a subroutine state is trying to return a + * value to the calling state. It gets specially noticed by the parser, + * so it really doesn't do much except act as a flag. + */ + case EXEC_C_STOREVAL: + return(SUCCESS); +/* + * Store the current expression value as the first argument to a command + */ + case EXEC_C_STORE1: + ct->ctx.iarg1 = ct->ctx.tmpval; + return(SUCCESS); +/* + * Store the current expression value as the second argument to a command + */ + case EXEC_C_STORE2: + ct->ctx.iarg2 = ct->ctx.tmpval; + return(SUCCESS); +/* + * Here when we have a leading minus sign in an expression such as -3+4 + */ + case EXEC_C_UMINUS: + ct->ctx.tmpval = 0 - ct->ctx.tmpval; + return(SUCCESS); +/* + * Here to add the two parts of the expression to produce a new temporary + * value. + */ + case EXEC_C_PLUS: + ct->ctx.tmpval = ct->ctx.iarg2 + ct->ctx.tmpval; + return(SUCCESS); +/* + * Here to subtract the two parts of the expression to produce a new temporary + * value. + */ + case EXEC_C_MINUS: + ct->ctx.tmpval = ct->ctx.iarg2 - ct->ctx.tmpval; + return(SUCCESS); +/* + * Here to multiply the two parts of the expression to produce a new temporary + * value. + */ + case EXEC_C_TIMES: + ct->ctx.tmpval = ct->ctx.iarg1 * ct->ctx.tmpval; + return(SUCCESS); +/* + * Here to divide the two parts of the expression to produce a new temporary + * value. + */ + case EXEC_C_DIVIDE: + if(ct->ctx.tmpval == 0){ + error_message("?Attempt to Divide by Zero"); + return(FAIL); + }/* End IF */ + ct->ctx.tmpval = ct->ctx.iarg1 / ct->ctx.tmpval; + return(SUCCESS); +/* + * Here in response to the "A" command which returns as a value the ASCII + * value of the character at 'dot' + offset. + */ + case EXEC_C_ACOMMAND: + {/* Local Block */ + register int i; + + i = curbuf->dot + ct->ctx.tmpval; + + if(parse_illegal_buffer_position(i,i+1,"A")){ + return(FAIL); + }/* End IF */ + + ct->ctx.tmpval = buff_contents(curbuf,i); + + return(SUCCESS); + + }/* End Local Block */ +/* + * Here to cause a repaint of the screen incase it got messed up by + * something + */ + case EXEC_C_REDRAW_SCREEN: + screen_redraw(); + return(SUCCESS); +/* + * Here to search for a given string. This gets used not only in the + * "S" command, but as a substate in any command which requires searching + * for a string (such as FD, FK, FS, FR, etc.) + */ + case EXEC_C_SEARCH: + {/* Local Block */ + int arg1,arg2; +#if 0 + struct buff_header *qbp; +#endif + + if(set_search_string_with_undo(ct->ctx.carg,uct) == FAIL){ + return(FAIL); + }/* End IF */ + + ut = allocate_undo_token(uct); + if(ut == NULL) return(FAIL); + ut->opcode = UNDO_C_CHANGEDOT; + ut->iarg1 = curbuf->dot; + + arg1 = 1; + arg2 = -1; + if(ct->ctx.iarg1_flag) arg1 = ct->ctx.iarg1; + if(ct->ctx.iarg2_flag) arg2 = ct->ctx.iarg2; + +/* + * If there are two arguments, then it is a constrained search and we must + * insure that the two positions specified are valid buffer positions. + */ + if(ct->ctx.iarg1_flag && ct->ctx.iarg2_flag){ + if(arg1 < 0 || arg1 > curbuf->zee){ + sprintf(tmp_message, + "?Illegal buffer position %d in search command",arg1); + error_message(tmp_message); + return(FAIL); + }/* End IF */ + if(arg2 < 0 || arg2 > curbuf->zee){ + sprintf(tmp_message, + "?Illegal buffer position %d in search command",arg2); + error_message(tmp_message); + return(FAIL); + }/* End IF */ + }/* End IF */ + +/* + * That done, we call the search command to perform the search + */ + if(cmd_search(arg1,arg2,&search_string) == FAIL){ + if(ct->ctx.flags & CTOK_M_COLON_SEEN){ + ct->ctx.tmpval = FAIL; + return(SUCCESS); + }/* End IF */ + + if(!ct->ctx.inest && search_string.error_message_given == NO){ + sprintf(tmp_message, + "?Cannot find '%.40s'",search_string.input); + error_message(tmp_message); + }/* End IF */ + + return(SUCCESS); + }/* End IF */ + + if(ct->ctx.flags & CTOK_M_COLON_SEEN){ + ct->ctx.tmpval = -1; + }/* End IF */ + + return(SUCCESS); + + }/* End Local Block */ +/* + * Here to implement the FR command. The FR command is similar to the FS + * command (Find-Substitute), except that if the second string argument is + * null, rather than simply deleting the first string argument, it is replaced + * by the default replace string. + */ + case EXEC_C_FRREPLACE: + {/* Local Block */ + register struct buff_header *qbp; + register int j; + + if(last_search_status == 0){ + if(ct->ctx.flags & CTOK_M_COLON_SEEN){ + ct->ctx.tmpval = FAIL; + return(SUCCESS); + }/* End IF */ + if(ct->ctx.inest != 0) return(SUCCESS); + return(FAIL); + }/* End IF */ + + j = last_search_pos2 - last_search_pos1; + ut = allocate_undo_token(uct); + if(ut == NULL) return(FAIL); + ut->opcode = UNDO_C_CHANGEDOT; + ut->iarg1 = curbuf->dot; + +/* + * Call the standard routine which deletes the specified buffer positions + * and constructs the undo list so that it can be rebuilt if necessary. + */ + if(j) buff_delete_with_undo(uct,curbuf,last_search_pos1,j); + + qbp = buff_qfind('-',1); + if(qbp == NULL){ + return(FAIL); + }/* End IF */ + + buff_insert_from_buffer_with_undo( + uct, + curbuf, /* destination is current edit buf */ + last_search_pos1, /* at the search position */ + qbp, /* source is replacement q-register*/ + 0, /* from position 0 to the end */ + qbp->zee + ); + + if(ct->ctx.iarg1_flag == YES){ + if( ct->ctx.iarg1 < 0){ + curbuf->dot = last_search_pos1; + }/* End IF */ + else if(ct->ctx.iarg2_flag == YES){ + if(ct->ctx.iarg2 < ct->ctx.iarg1){ + curbuf->dot = last_search_pos1; + }/* End IF */ + }/* End Else */ + }/* End IF */ + + if(ct->ctx.flags & CTOK_M_COLON_SEEN){ + ct->ctx.tmpval = -1; + }/* End IF */ + + return(SUCCESS); + }/* End Local Block */ +/* + * Here to implement the FS (Find-Substitute) command which searches for + * the first string argument and replaces it with the second. + */ + case EXEC_C_FSREPLACE1: + {/* Local Block */ + register int j; + register struct buff_header *qbp; + + ct->ctx.tmpval = 0; + + if(last_search_status == 0){ + if(ct->ctx.flags & CTOK_M_COLON_SEEN){ + ct->ctx.tmpval = FAIL; + return(SUCCESS); + }/* End IF */ + if(ct->ctx.inest != 0) return(SUCCESS); + return(FAIL); + }/* End IF */ + +#ifdef INTERACTIVE_FS + j = last_search_pos2 - last_search_pos1; + ut = allocate_undo_token(uct); + if(ut == NULL) return(FAIL); + ut->opcode = UNDO_C_CHANGEDOT; + ut->iarg1 = curbuf->dot; + if(j) buff_delete_with_undo(uct,curbuf,last_search_pos1,j); +#endif /* INTERACTIVE_FS */ + + return(SUCCESS); + + case EXEC_C_FSREPLACE2: + + if(last_search_status == 0){ + if(ct->ctx.flags & CTOK_M_COLON_SEEN){ + ct->ctx.tmpval = FAIL; + return(SUCCESS); + }/* End IF */ + if(ct->ctx.inest != 0) return(SUCCESS); + return(FAIL); + }/* End IF */ + + qbp = buff_qfind('-',1); + if(qbp == NULL){ + return(FAIL); + }/* End IF */ + +#ifdef INTERACTIVE_FS + + buff_insert_char_with_undo(uct,curbuf,curbuf->dot,ct->input_byte); + +#endif /* INTERACTIVE_FS */ + +/* + * What this does is hope that the replacement string is the same as the + * previous one. Only if we get a miscompare do we delete the contents of + * the replacement q-register, and insert the new string. + */ + if(qbp->zee > ct->ctx.tmpval){ + if(ct->input_byte == buff_contents(qbp,ct->ctx.tmpval)){ + ct->ctx.tmpval += 1; + return(SUCCESS); + } + + buff_delete_with_undo(uct,qbp,ct->ctx.tmpval, + qbp->zee-ct->ctx.tmpval); + + } + + buff_insert_char_with_undo(uct,qbp,ct->ctx.tmpval,ct->input_byte); + + ct->ctx.tmpval += 1; + return(SUCCESS); + + case EXEC_C_FSREPLACE3: + + qbp = buff_qfind('-',1); + if(qbp == NULL){ + return(FAIL); + }/* End IF */ + + if(qbp->zee > ct->ctx.tmpval){ + buff_delete_with_undo(uct,qbp,ct->ctx.tmpval, + qbp->zee-ct->ctx.tmpval); + } + +#ifndef INTERACTIVE_FS + j = last_search_pos2 - last_search_pos1; + ut = allocate_undo_token(uct); + if(ut == NULL) return(FAIL); + ut->opcode = UNDO_C_CHANGEDOT; + ut->iarg1 = curbuf->dot; + if(j) buff_delete_with_undo(uct,curbuf,last_search_pos1,j); + + buff_insert_from_buffer_with_undo(uct, + curbuf, + curbuf->dot, + qbp, + 0, + qbp->zee + ); + +#endif /* !INTERACTIVE_FS */ + + if(ct->ctx.iarg1_flag == YES){ + if( ct->ctx.iarg1 < 0){ + ut = allocate_undo_token(uct); + if(ut == NULL) return(FAIL); + ut->opcode = UNDO_C_CHANGEDOT; + ut->iarg1 = curbuf->dot; + curbuf->dot = last_search_pos1; + }/* End IF */ + else if(ct->ctx.iarg2_flag == YES){ + if(ct->ctx.iarg2 < ct->ctx.iarg1){ + ut = allocate_undo_token(uct); + if(ut == NULL) return(FAIL); + ut->opcode = UNDO_C_CHANGEDOT; + ut->iarg1 = curbuf->dot; + curbuf->dot = last_search_pos1; + }/* End IF */ + }/* End Else */ + }/* End IF */ + + if(ct->ctx.flags & CTOK_M_COLON_SEEN){ + ct->ctx.tmpval = last_search_status; + }/* End IF */ + + return(SUCCESS); + + }/* End Local Block */ +/* + * Here to execute the FT (tags) command. Since this is a fairly complicated + * command, we call a subroutine to perform the actions. + */ + case EXEC_C_FTAGS: + {/* Local Block */ + register int arg_count = 0; + register int status; + + if(ct->ctx.iarg1_flag == YES) arg_count = 1; + if(ct->ctx.iarg2_flag == YES) arg_count = 2; + + status = cmd_tags( + uct, + arg_count, + ct->ctx.iarg1, + ct->ctx.iarg2, + ct->ctx.carg + ); + + if(ct->ctx.flags & CTOK_M_COLON_SEEN){ + ct->ctx.tmpval = status; + return(SUCCESS); + }/* End IF */ + + return(status); + + }/* End Local Block */ + +/* + * Here to execute the FD command which searches for a string and deletes + * it. It is like FS but saves you from typing the second escape. + */ + case EXEC_C_FDCOMMAND: + {/* Local Block */ + register int j; + + if(last_search_status == 0){ + if(ct->ctx.flags & CTOK_M_COLON_SEEN){ + ct->ctx.tmpval = FAIL; + return(SUCCESS); + }/* End IF */ + if(ct->ctx.inest != 0) return(SUCCESS); + return(FAIL); + }/* End IF */ + + j = last_search_pos2 - last_search_pos1; + + ut = allocate_undo_token(uct); + if(ut == NULL) return(FAIL); + ut->opcode = UNDO_C_CHANGEDOT; + ut->iarg1 = curbuf->dot; + +/* + * Call the standard routine which deletes the specified buffer positions + * and constructs the undo list so that it can be rebuilt if necessary. + */ + if(j) buff_delete_with_undo(uct,curbuf,last_search_pos1,j); + + curbuf->dot = last_search_pos1; + + if(ct->ctx.flags & CTOK_M_COLON_SEEN){ + ct->ctx.tmpval = -1; + }/* End IF */ + + return(SUCCESS); + }/* End Local Block */ +/* + * Here to implement the FK command. The FK command remembers the current + * position in the buffer and searches for the specified string. It then + * deletes the characters from the old current position up to but not + * including the search string. + */ + case EXEC_C_FKCOMMAND: + {/* Local Block */ + register int j; + + if(last_search_status == 0){ + if(ct->ctx.flags & CTOK_M_COLON_SEEN){ + ct->ctx.tmpval = FAIL; + return(SUCCESS); + }/* End IF */ + if(ct->ctx.inest != 0) return(SUCCESS); + return(FAIL); + }/* End IF */ + + if(remembered_dot <= last_search_pos1){ + last_search_pos2 = last_search_pos1; + last_search_pos1 = remembered_dot; + }/* End IF */ + + else { + last_search_pos1 = last_search_pos2; + last_search_pos2 = remembered_dot; + curbuf->dot = last_search_pos1; + }/* End IF */ + + j = last_search_pos2 - last_search_pos1; + + ut = allocate_undo_token(uct); + if(ut == NULL) return(FAIL); + ut->opcode = UNDO_C_CHANGEDOT; + ut->iarg1 = curbuf->dot; + +/* + * Call the standard routine which deletes the specified buffer positions + * and constructs the undo list so that it can be rebuilt if necessary. + */ + if(j) buff_delete_with_undo(uct,curbuf,last_search_pos1,j); + + curbuf->dot = last_search_pos1; + + if(ct->ctx.flags & CTOK_M_COLON_SEEN){ + ct->ctx.tmpval = -1; + }/* End IF */ + + return(SUCCESS); + }/* End Local Block */ +/* + * This state is used by the FK command to remember the current dot + * position before it is changed by the search command. + */ + case EXEC_C_REMEMBER_DOT: + remembered_dot = curbuf->dot; + return(SUCCESS); +/* + * Here to implement the N search which searches across edit buffers for + * the given string. + */ + case EXEC_C_NSEARCH: + {/* Local Block */ + int count; + struct buff_header *original_buffer; + int original_dot; + int saved_dot,saved_top,saved_bottom; + int first_buffer; + int last_buffer = 0; + char back_in_original_buffer; +/* + * We set the search string, just like all the other search commands + */ + if(set_search_string_with_undo(ct->ctx.carg,uct) == FAIL){ + return(FAIL); + }/* End IF */ +/* + * Remember the buffer that we started in, and be ready to change back to + * it if we undo. + */ + original_buffer = curbuf; + original_dot = curbuf->dot; + + count = 1; + if(ct->ctx.iarg1_flag) count = ct->ctx.iarg1; + +/* + * If he says 1,5n<string>$ then we search for the string in buffers 1 + * through 5. We check that both buffers exist before we begin the search. + */ + if(ct->ctx.iarg2_flag){ + count = 1; + first_buffer = ct->ctx.iarg1; + last_buffer = ct->ctx.iarg2; + + if(first_buffer != curbuf->buffer_number){ + if(buff_openbuffer(NULL,last_buffer,0) != SUCCESS){ + return(FAIL); + }/* End IF */ + if(buff_openbuffer(NULL,first_buffer,0) != SUCCESS){ + return(FAIL); + }/* End IF */ + curbuf->dot = 0; + }/* End IF */ + }/* End IF */ + +/* + * In the starting buffer, we want to search from 'dot' to the end. Then + * we would search all the other buffers, and then the original one again, + * but from the top to 'dot'. The saved_dot stuff is necessary because + * the cmd_search routine has the side effect of changing 'dot' in the + * buffer being searched. However, we only want to affect 'dot' in the + * final buffer that the final occurance of the search string is found in. + */ + saved_dot = curbuf->dot; + saved_top = curbuf->dot; + saved_bottom = curbuf->zee; + back_in_original_buffer = 0; + + while(count > 0){ + + if(cmd_search(saved_top,saved_bottom,&search_string) != FAIL){ + saved_top = curbuf->dot; + count -= 1; + continue; + }/* End IF */ +/* + * Here if the search failed. We want to switch over to the next buffer and + * try again, until we exhaust all the buffers. If we reach the final buffer + * without finding the string, we return an error to the user, leaving him + * back in his original buffer. + */ + if(ct->ctx.iarg2_flag && curbuf->buffer_number == last_buffer){ + if(buff_openbuffer(NULL,original_buffer->buffer_number,0) != SUCCESS){ + error_message("Boom! lost original buffer"); + return(FAIL); + }/* End IF */ + back_in_original_buffer = 1; + }/* End IF */ + + if(back_in_original_buffer){ + curbuf->dot = saved_dot; + if(ct->ctx.flags & CTOK_M_COLON_SEEN){ + ct->ctx.tmpval = FAIL; + return(SUCCESS); + }/* End IF */ + sprintf(tmp_message, + "?Cannot find '%.40s'",search_string.input); + if(!ct->ctx.inest && !intr_flag && + search_string.error_message_given == NO){ + error_message(tmp_message); + }/* End IF */ + return(SUCCESS); + }/* End IF */ +/* + * We havn't tried all the buffers yet, switch to the next one. + */ + curbuf->dot = saved_dot; + + while(1){ + curbuf = curbuf->next_header; + if(curbuf == NULL) curbuf = buffer_headers; + if(curbuf->buffer_number == -1) break; + if(curbuf->buffer_number > 0) break; + if(ct->ctx.iarg2_flag) continue; + if(curbuf == original_buffer) break; + }/* End While */ + + saved_dot = curbuf->dot; + saved_top = 0; + saved_bottom = curbuf->zee; + + if(ct->ctx.iarg2_flag == NO){ + if(curbuf->buffer_number == original_buffer->buffer_number){ + back_in_original_buffer = 1; + saved_bottom = original_dot; + }/* End IF */ + }/* End IF */ + + }/* End While */ + + ut = allocate_undo_token(uct); + if(ut == NULL) return(FAIL); + ut->opcode = UNDO_C_CHANGEBUFF; + ut->iarg1 = original_buffer->buffer_number; + + buff_switch(curbuf,1); + + ut = allocate_undo_token(uct); + if(ut == NULL) return(FAIL); + ut->opcode = UNDO_C_CHANGEDOT; + ut->iarg1 = saved_dot; + + if(ct->ctx.flags & CTOK_M_COLON_SEEN){ + ct->ctx.tmpval = -1; + }/* End IF */ + + return(SUCCESS); + + }/* End Local Block */ +/* + * Here to begin an iteration < ... > + */ + case EXEC_C_ITERATION_BEGIN: + {/* Local Block */ + register struct cmd_token *oct; + if(ct->ctx.iarg1_flag == YES){ + if(ct->ctx.iarg1 <= 0){ + oct = ct; + while((oct = oct->next_token)){ + if(oct->opcode != TOK_C_ITERATION_END) continue; + if(oct->ctx.inest != (ct->ctx.inest-1)) continue; + jump_to_token = oct; + return(SUCCESS); + }/* End While */ + ct->ctx.go_flag = NO; + return(SUCCESS); + }/* End IF */ + ct->ctx.iarg1 -= 1; + }/* End IF */ + return(SUCCESS); + }/* End Local Block */ +/* + * Here to provide the execution code for the end of an iteration. + * This must search backwards in the parse tokens to find the begining + * of the iteration, and set up to jump to that token + */ + case EXEC_C_ITERATION_END: + {/* Local Block */ + register struct cmd_token *oct; +/* + * The parser left us a pointer to the begining of the iteration so we can + * find it without having to search. + */ + oct = ct->ctx.caller_token; + + if(oct->ctx.iarg1_flag == YES){ + if(oct->ctx.iarg1 <= 0){ + return(SUCCESS); + }/* End IF */ + }/* End IF */ +/* + * The following line grabs the old iteration value so that when the + * begining of iteration code grabs the "previous" iarg1, this will + * be it. Think of it this way: the code has to do something different + * the first time into the iteration (it has to load the results of the + * STORE1, then the subsequent times it has to decrement what's already + * there. That's why this seems a little kludgy. + */ + ct->ctx.iarg1 = oct->ctx.iarg1; + jump_to_token = oct; + return(SUCCESS); + }/* End Local Block */ +/* + * Here to implement the semicolon command which is used to jump out + * of an iteration if the argument is >= 0. + */ + case EXEC_C_SEMICOLON: + {/* Local Block */ + register struct cmd_token *oct; + int value; + + value = last_search_status; + if(ct->ctx.iarg1_flag == YES) value = ct->ctx.iarg1; + + if(value < 0) return(SUCCESS); + + oct = ct; + while((oct = oct->next_token)){ + if(oct->opcode != TOK_C_ITERATION_END) continue; + if(oct->ctx.inest != (ct->ctx.inest-1)) continue; + if(oct->next_token){ + jump_to_token = oct->next_token; + return(SUCCESS); + }/* End IF */ + }/* End While */ + + ct->ctx.go_flag = NO; + return(BLOCKED); + + }/* End Local Block */ +/* + * Here to implement the various conditional operators + */ + case EXEC_C_COND_GT: + if(ct->ctx.iarg1 <= 0){ + return(find_conditional_else(ct)); + }/* End IF */ + return(SUCCESS); + + case EXEC_C_COND_LT: + if(ct->ctx.iarg1 >= 0){ + return(find_conditional_else(ct)); + }/* End IF */ + return(SUCCESS); + + case EXEC_C_COND_EQ: + if(ct->ctx.iarg1 != 0){ + return(find_conditional_else(ct)); + }/* End IF */ + return(SUCCESS); + + case EXEC_C_COND_NE: + if(ct->ctx.iarg1 == 0){ + return(find_conditional_else(ct)); + }/* End IF */ + return(SUCCESS); + + case EXEC_C_COND_DIGIT: + if(!isdigit(ct->ctx.iarg1)){ + return(find_conditional_else(ct)); + }/* End IF */ + return(SUCCESS); + + case EXEC_C_COND_ALPHA: + if(!isalpha(ct->ctx.iarg1)){ + return(find_conditional_else(ct)); + }/* End IF */ + return(SUCCESS); + + case EXEC_C_COND_LOWER: + if(!islower(ct->ctx.iarg1)){ + return(find_conditional_else(ct)); + }/* End IF */ + return(SUCCESS); + + case EXEC_C_COND_UPPER: + if(!isupper(ct->ctx.iarg1)){ + return(find_conditional_else(ct)); + }/* End IF */ + return(SUCCESS); + + case EXEC_C_COND_SYMBOL: + if(!isalnum(ct->ctx.iarg1) && ct->ctx.iarg1 != '_'){ + return(find_conditional_else(ct)); + }/* End IF */ + return(SUCCESS); + + case EXEC_C_SKIP_ELSE: + return(find_conditional_end(ct)); +/* + * Here to implement the GOTO command OLABEL$ + */ + case EXEC_C_GOTO: + {/* Local Block */ + struct cmd_token *goto_ptr; + struct cmd_token *test_ptr; +/* + * First step is to find the begining of this goto string + */ + goto_ptr = ct; + while((goto_ptr = goto_ptr->prev_token)){ + if(goto_ptr->opcode != TOK_C_GOTO_BEGIN) continue; + break; + }/* End While */ +/* + * Now try to find the label. First search backwards for it + */ + test_ptr = goto_ptr; + while((test_ptr = test_ptr->prev_token)){ + if(test_ptr->opcode != TOK_C_LABEL_BEGIN) continue; + if(compare_label(goto_ptr,test_ptr) == YES){ + ct->ctx.go_flag = NO; + jump_to_token = test_ptr; + return(SUCCESS); + }/* End IF */ + }/* End While */ +/* + * The label is not in front of us, look for it afterwards + */ + test_ptr = goto_ptr; + while((test_ptr = test_ptr->next_token)){ + if(test_ptr->opcode == TOK_C_FINALTOKEN){ + char string1[PARSER_STRING_MAX]; + + extract_label(goto_ptr,string1); + (void) sprintf(tmp_message,"?Can't find label <%s>", + string1); + error_message(tmp_message); + return(FAIL); + }/* End IF */ + + if(test_ptr->opcode != TOK_C_LABEL_BEGIN) continue; + + if(compare_label(goto_ptr,test_ptr) == YES){ + jump_to_token = test_ptr; + return(SUCCESS); + }/* End IF */ + }/* End While */ + + ct->ctx.go_flag = NO; + return(BLOCKED); + + }/* End Local Block */ +/* + * Here to write out the buffer. If the filename is specified, write it + * to that name, otherwise write it to the default name of the buffer. + */ + case EXEC_C_WRITEFILE: + {/* Local Block */ + int status; + struct wildcard_expansion *name_list,*np; + struct wildcard_expansion *expand_filename(); + char *filename; + + if(curbuf->isreadonly){ + error_message("?File is Readonly"); + if(ct->ctx.flags & CTOK_M_COLON_SEEN){ + ct->ctx.tmpval = FAIL; + return(SUCCESS); + }/* End IF */ + return(FAIL); + }/* End IF */ + + if(ct->ctx.carg) filename = ct->ctx.carg; + else filename = curbuf->name; + + np = expand_filename(filename); + if(np == NULL){ + sprintf(tmp_message,"EW No such file <%s>",filename); + error_message(tmp_message); + if(ct->ctx.flags & CTOK_M_COLON_SEEN){ + ct->ctx.tmpval = FAIL; + return(SUCCESS); + }/* End IF */ + return(FAIL); + }/* End IF */ + + if(np->we_next){ + sprintf(tmp_message,"EW: Non-unique filename <%s>",filename); + error_message(tmp_message); + while(np){ + name_list = np; + np = np->we_next; + tec_release(TYPE_C_WILD,(char *)name_list); + }/* End While */ + if(ct->ctx.flags & CTOK_M_COLON_SEEN){ + ct->ctx.tmpval = FAIL; + return(SUCCESS); + }/* End IF */ + return(FAIL); + }/* End IF */ + + status = cmd_write(curbuf,np->we_name); + tec_release(TYPE_C_WILD,(char *)np); + if(ct->ctx.flags & CTOK_M_COLON_SEEN){ + ct->ctx.tmpval = status; + return(SUCCESS); + }/* End IF */ + return(status); + + }/* End Local Block */ +/* + * Read in the named file to the current position in the edit buffer + */ + case EXEC_C_READFILE: + {/* Local Block */ + struct wildcard_expansion *name_list,*np; + struct wildcard_expansion *expand_filename(); + + if(ct->ctx.carg == NULL || ct->ctx.carg[0] == '\0'){ + error_message("?ER Requires a filename"); + if(ct->ctx.flags & CTOK_M_COLON_SEEN){ + ct->ctx.tmpval = FAIL; + return(SUCCESS); + }/* End IF */ + return(FAIL); + }/* End IF */ + + ut = allocate_undo_token(uct); + if(ut == NULL) return(FAIL); + ut->opcode = UNDO_C_DELETE; + ut->carg1 = (char *)curbuf; + ut->iarg1 = curbuf->dot; + ut->iarg2 = curbuf->zee; + + np = expand_filename(ct->ctx.carg); + if(np == NULL){ + sprintf(tmp_message,"ER No such file <%s>",ct->ctx.carg); + error_message(tmp_message); + if(ct->ctx.flags & CTOK_M_COLON_SEEN){ + ct->ctx.tmpval = FAIL; + return(SUCCESS); + }/* End IF */ + return(FAIL); + }/* End IF */ + + while(np){ + buff_read(curbuf,np->we_name); + name_list = np; + np = np->we_next; + tec_release(TYPE_C_WILD,(char *)name_list); + }/* End While */ + + + ut->iarg2 = curbuf->zee - ut->iarg2; + + if(ct->ctx.flags & CTOK_M_COLON_SEEN){ + ct->ctx.tmpval = SUCCESS; + return(SUCCESS); + }/* End IF */ + return(SUCCESS); + + }/* End Local Block */ +/* + * Here to change the current edit buffer. If a numeric argument is + * supplied, change to that buffer, otherwise a string should have been + * specified, and this is the name of the file/buffer to be loaded. + */ + case EXEC_C_EDITBUF: + {/* Local Block */ + struct buff_header *hbp,*old_buffer,*first_buffer; + struct wildcard_expansion *name_list,*np; + struct wildcard_expansion *expand_filename(); + +/* + * Here if there is no string argument. It better be a numeric buffer + * number argument. If so, switch to that buffer, and set the undo to + * switch back to the old one if this gets undone. + */ + if(ct->ctx.carg == NULL || ct->ctx.carg[0] == '\0'){ + if(ct->ctx.iarg1_flag == NO){ + error_message("?EB Requires a filename or argument"); + return(FAIL); + }/* End IF */ + + old_buffer = curbuf; + if(buff_openbuffer(0,ct->ctx.iarg1,0) == FAIL){ + return(FAIL); + }/* End IF */ + + if(curbuf->buffer_number != ct->ctx.iarg1){ + if(ct->ctx.flags & CTOK_M_COLON_SEEN){ + ct->ctx.tmpval = FAIL; + return(SUCCESS); + } + return(FAIL); + }/* End IF */ + + ut = allocate_undo_token(uct); + if(ut == NULL) return(FAIL); + ut->opcode = UNDO_C_CHANGEBUFF; + ut->iarg1 = old_buffer->buffer_number; + + if(ct->ctx.flags & CTOK_M_COLON_SEEN){ + ct->ctx.tmpval = SUCCESS; + } + return(SUCCESS); + + }/* End IF */ + + old_buffer = curbuf; + first_buffer = NULL; + + np = expand_filename(ct->ctx.carg); + if(np == NULL){ + if(ct->ctx.flags & CTOK_M_COLON_SEEN){ + ct->ctx.tmpval = FAIL; + return(SUCCESS); + } + sprintf(tmp_message,"EB No such file <%s>",ct->ctx.carg); + error_message(tmp_message); + return(FAIL); + }/* End IF */ + + while(np){ +/* + * The following hack detects whether a new buffer was created so that + * we know whether or not to set up an undo to un-create it. + */ + hbp = buff_find(np->we_name); + if(buff_openbuffer(np->we_name,0,0) == SUCCESS){ + if(hbp == NULL){ + ut = allocate_undo_token(uct); + if(ut == NULL) return(FAIL); + ut->opcode = UNDO_C_CLOSEBUFF; + ut->carg1 = (char *)curbuf; + }/* End IF */ + if(first_buffer == NULL) first_buffer = curbuf; + }/* End IF */ + + name_list = np; + np = np->we_next; + tec_release(TYPE_C_WILD,(char *)name_list); + }/* End While */ + + ut = allocate_undo_token(uct); + if(ut == NULL) return(FAIL); + ut->opcode = UNDO_C_CHANGEBUFF; + ut->iarg1 = old_buffer->buffer_number; + + buff_openbuffer(0,first_buffer->buffer_number,0); + if(ct->ctx.flags & CTOK_M_COLON_SEEN){ + ct->ctx.tmpval = SUCCESS; + return(SUCCESS); + } + return(SUCCESS); + + }/* End Local Block */ +/* + * Here to implement the EF command which removes an edit buffer. + */ + case EXEC_C_CLOSEBUF: + {/* Local Block */ + register struct buff_header *hbp,*bp; + register int i; + + hbp = curbuf; + if(curbuf->buffer_number == 0){ + if(ct->ctx.flags & CTOK_M_COLON_SEEN){ + ct->ctx.tmpval = FAIL; + return(SUCCESS); + }/* End IF */ + error_message("?EF Not allowed on special buffers"); + return(FAIL); + }/* End IF */ + + if(hbp->ismodified && !hbp->isreadonly){ + if(ct->ctx.iarg1_flag == NO || + ct->ctx.iarg1 != -1){ + if(ct->ctx.flags & CTOK_M_COLON_SEEN){ + ct->ctx.tmpval = FAIL; + return(SUCCESS); + }/* End IF */ + sprintf(tmp_message,"?EF Buffer %s is modified", + curbuf->name); + error_message(tmp_message); + return(FAIL); + }/* End IF */ + }/* End IF */ + + ut = allocate_undo_token(uct); + if(ut == NULL) return(FAIL); + ut->opcode = UNDO_C_CHANGEBUFF; + ut->iarg1 = hbp->buffer_number; + + ut = allocate_undo_token(uct); + if(ut == NULL) return(FAIL); + ut->opcode = UNDO_C_REOPENBUFF; + ut->iarg1 = hbp->buffer_number; + ut->carg1 = (char *)hbp; + +/* + * Unlink this buffer header from the header list. Check to see if it is + * at the head of the list. If not at the head of the list, we have to + * search the list till we find it's father. Then we make it's father's + * child be it's child. + */ + i = 0; + bp = buffer_headers; + if(bp == hbp) buffer_headers = bp->next_header; + else { + while(bp){ + if(bp->next_header == hbp) break; + bp = bp->next_header; + }/* End While */ + bp->next_header = hbp->next_header; + curbuf = NULL; + if(bp->buffer_number > 0 && hbp->buffer_number > 0){ + i = bp->buffer_number; + }/* End IF */ + else if(bp->buffer_number < 0 && hbp->buffer_number < 0){ + i = bp->buffer_number; + }/* End Else */ + else if(hbp->buffer_number > 0 && hbp->next_header){ + i = hbp->next_header->buffer_number; + }/* End Else */ + else i = -1; + }/* End Else */ +/* + * Pick a different buffer to be the current buffer + */ + if(i){ + if(buff_openbuffer(NULL,i,0) == FAIL) i = 0; + }/* End IF */ + if(!i){ + if(buff_openbuffer(NULL,-1,0) == FAIL){ + buff_openbuffer(NULL,0,0); + }/* End IF */ + }/* End IF */ + + if(ct->ctx.flags & CTOK_M_COLON_SEEN){ + ct->ctx.tmpval = SUCCESS; + }/* End IF */ + return(SUCCESS); + + }/* End Local Block */ +/* + * Here to implement the EV command which is identical to the EB command + * except that if the buffer does not exist, when it is created it is created + * as a read only buffer. + */ + case EXEC_C_VIEWBUF: + {/* Local Block */ + struct buff_header *hbp,*old_buffer,*first_buffer; + struct wildcard_expansion *name_list,*np; + struct wildcard_expansion *expand_filename(); + +/* + * Here if there is no string argument. It better be a numeric buffer + * number argument. If so, switch to that buffer, and set the undo to + * switch back to the old one if this gets undone. + */ + if(ct->ctx.carg == NULL || ct->ctx.carg[0] == '\0'){ + if(ct->ctx.iarg1_flag == NO){ + error_message("?EV Requires a filename or argument"); + return(FAIL); + }/* End IF */ + + old_buffer = curbuf; + buff_openbuffer(0,ct->ctx.iarg1,1); + + ut = allocate_undo_token(uct); + if(ut == NULL) return(FAIL); + ut->opcode = UNDO_C_CHANGEBUFF; + ut->iarg1 = old_buffer->buffer_number; + + if(ct->ctx.flags & CTOK_M_COLON_SEEN){ + ct->ctx.tmpval = SUCCESS; + } + return(SUCCESS); + + }/* End IF */ + + old_buffer = curbuf; + first_buffer = NULL; + + np = expand_filename(ct->ctx.carg); + if(np == NULL){ + if(ct->ctx.flags & CTOK_M_COLON_SEEN){ + ct->ctx.tmpval = FAIL; + return(SUCCESS); + } + sprintf(tmp_message,"EV No such file <%s>",ct->ctx.carg); + error_message(tmp_message); + return(FAIL); + }/* End IF */ + + while(np){ +/* + * The following hack detects whether a new buffer was created so that + * we know whether or not to set up an undo to un-create it. + */ + hbp = buff_find(np->we_name); + if(buff_openbuffer(np->we_name,0,1) == SUCCESS){ + if(hbp == NULL){ + ut = allocate_undo_token(uct); + if(ut == NULL) return(FAIL); + ut->opcode = UNDO_C_CLOSEBUFF; + ut->carg1 = (char *)curbuf; + }/* End IF */ + if(first_buffer == NULL) first_buffer = curbuf; + }/* End IF */ + + name_list = np; + np = np->we_next; + tec_release(TYPE_C_WILD,(char *)name_list); + }/* End While */ + + ut = allocate_undo_token(uct); + if(ut == NULL) return(FAIL); + ut->opcode = UNDO_C_CHANGEBUFF; + ut->iarg1 = old_buffer->buffer_number; + + buff_openbuffer(0,first_buffer->buffer_number,1); + if(ct->ctx.flags & CTOK_M_COLON_SEEN){ + ct->ctx.tmpval = SUCCESS; + return(SUCCESS); + } + return(SUCCESS); + + }/* End Local Block */ +/* + * Here to scroll the screen the specified number of lines + */ + case EXEC_C_SCROLL: + if(ct->ctx.iarg1_flag == NO) ct->ctx.iarg1 = 1; + screen_scroll(ct->ctx.iarg1); + return(SUCCESS); +/* + * Here to cause the screen to update + */ + case EXEC_C_UPDATE_SCREEN: + screen_format_windows(); + screen_refresh(); + return(SUCCESS); +/* + * Here to either split or combine windows + */ + case EXEC_C_WINDOW_CONTROL: + {/* Local Block */ + struct window *old_wptr; + struct window *new_wptr; + + if(ct->ctx.iarg1_flag == NO) screen_delete_window(curwin); + + if(ct->ctx.iarg1_flag == YES && ct->ctx.iarg2_flag == YES){ + old_wptr = curwin; + ut = allocate_undo_token(uct); + if(ut == NULL) return(FAIL); + + new_wptr = + screen_split_window( + curwin, + ct->ctx.iarg1, + ct->ctx.iarg2 + ); + + if(new_wptr == NULL) return(FAIL); + + ut->opcode = UNDO_C_WINDOW_SPLIT; + ut->iarg1 = old_wptr->win_window_number; + ut->carg1 = (char *)new_wptr; + }/* End Else */ + + return(SUCCESS); + }/* End Local Block */ +/* + * Here to select the next window as active + */ + case EXEC_C_NEXT_WINDOW: + {/* Local Block */ + int status; + int new_window; + + new_window = ct->ctx.iarg1_flag == YES ? ct->ctx.iarg1 : 0; + + ut = allocate_undo_token(uct); + if(ut == NULL) return(FAIL); + ut->opcode = UNDO_C_WINDOW_SWITCH; + ut->iarg1 = curwin->win_window_number; + + status = window_switch(new_window); + + return(status); + + }/* End Local Block */ +/* + * Here to reset a ^A message to NULL + */ + case EXEC_C_RESET_MESSAGE: + user_message[0] = '\0'; + return(SUCCESS); +/* + * Here to add a byte to the length of the current user message string + */ + case EXEC_C_MESSAGE: + {/* Local Block */ + register int i; + + if(strlen(user_message) > (sizeof(user_message) - 1)){ + error_message("?^A message length exceeded"); + return(FAIL); + }/* End IF */ + + i = strlen(user_message); + user_message[i] = ct->input_byte; + user_message[i+1] = '\0'; + + ut = allocate_undo_token(uct); + if(ut == NULL) return(FAIL); + ut->opcode = UNDO_C_SHORTEN_MESSAGE; + + return(SUCCESS); + + }/* End Local Block */ +/* + * Here to print the current user message to the status line of the screen + */ + case EXEC_C_OUTPUT_MESSAGE: + screen_message(user_message); + screen_refresh(); + return(SUCCESS); +/* + * Here to execute the specified operating system command, and insert the + * generated output into the edit buffer. + */ + case EXEC_C_ECCOMMAND: + {/* Local Block */ + int status; + + ut = allocate_undo_token(uct); + if(ut == NULL) return(FAIL); + ut->opcode = UNDO_C_DELETE; + ut->carg1 = (char *)curbuf; + ut->iarg1 = curbuf->dot; + ut->iarg2 = 0; + + status = cmd_oscmd(ct); + ut->iarg2 = curbuf->dot - ut->iarg1; + return(status); + + }/* End Local Block */ + + case EXEC_C_SET_IMMEDIATE_MODE: + ut = allocate_undo_token(uct); + if(ut == NULL) return(FAIL); + ut->opcode = UNDO_C_SET_IMMEDIATE_MODE; + ut->iarg1 = immediate_execute_flag; + + immediate_execute_flag = YES; + if(ct->ctx.iarg1 == 0){ + ct->ctx.go_flag = NO; + immediate_execute_flag = NO; + }/* End IF */ + return(SUCCESS); + + case EXEC_C_OPENBRACE: + {/* Local Block */ + register struct buff_header *qbp; + +/* + * Get a pointer to the q-register buffer structure. If it doesn't + * exist, create it. + */ + qbp = buff_qfind('$',1); + if(qbp == NULL){ + return(FAIL); + }/* End IF */ +/* + * Set up the undo token to remember the current edit buffer, and then switch + * to the Q-register. + */ + ut = allocate_undo_token(uct); + if(ut == NULL) return(FAIL); + ut->opcode = UNDO_C_CHANGEBUFF; + ut->iarg1 = curbuf->buffer_number; + + buff_switch(qbp,1); +/* + * Delete the previous contents of the q-register, but allow it to be + * reconstructed if this gets undone. Note that we don't have to do + * this if there was nothing there. + */ + if(qbp->zee) buff_delete_with_undo(uct,qbp,0,qbp->zee); +/* + * Arrange for it to be deleted if this gets undone. + */ + ut = allocate_undo_token(uct); + if(ut == NULL) return(FAIL); +/* + * Copy the parser command line into the Q-register + */ + parser_dump_command_line(qbp); + + ut->opcode = UNDO_C_DELETE; + ut->carg1 = (char *)qbp; + ut->iarg1 = 0; + ut->iarg2 = qbp->zee; + + return(SUCCESS); + }/* End Local Block */ + + case EXEC_C_CLOSEBRACE: + {/* Local Block */ + register struct buff_header *qbp; + +/* + * Get a pointer to the q-register buffer structure. If it doesn't + * exist, that is an error + */ + qbp = buff_qfind('$',0); + if(qbp == NULL){ + return(FAIL); + }/* End IF */ +/* + * Replace the command line with the contents of the Q-register + */ + parser_replace_command_line(qbp); + + return(INVALIDATE); + + }/* End Local Block */ + +/* + * Here to skip a label (this occurs when we run into a label) + */ + case EXEC_C_SKIPLABEL: + while(ct){ + if(ct->opcode == TOK_C_LABEL_END){ + jump_to_token = ct; + return(SUCCESS); + }/* End IF */ + ct = ct->next_token; + }/* End While */ + return(SUCCESS); + +/* + * Here if he wants to set some options up + */ + case EXEC_C_SETOPTIONS: + ut = allocate_undo_token(uct); + if(ut == NULL) return(FAIL); + ut->opcode = UNDO_C_SETOPTIONS; + + return(cmd_setoptions(ct->ctx.iarg1,ct->ctx.iarg2,ut)); + + default: + sprintf(tmp_message,"?TECEXEC: unknown state %d dispatched", + ct->execute_state); + error_message(tmp_message); + return(FAIL); + + }/* End Switch */ + +}/* End Routine */ + + + +/* PUSH_QREGISTER - Push a Q register onto the stack + * + * Function: + * + * This routine is called to make a copy of a Q register and place it + * on the Q register stack. + */ +int +push_qregister(letter) +char letter; +{ +register struct buff_header *hbp; +register struct buff_header *qbp; + + PREAMBLE(); + +/* + * Get a pointer to the q-register buffer structure. If it doesn't + * exist, create it. + */ + qbp = buff_qfind(letter,1); + if(qbp == NULL){ + return(FAIL); + }/* End IF */ + + hbp = buff_duplicate(qbp); + + hbp->next_header = qregister_push_down_list; + qregister_push_down_list = hbp; + + return(SUCCESS); + +}/* End Routine */ + + +/* EXTRACT_LABEL - Build a string with the contents of the label in it + * + * Function: + * + * This routine is called to build a string with the label name + * in it. The current use is for error messages. + */ +void +extract_label(label_ptr,string1) +register struct cmd_token *label_ptr; +char *string1; +{ +register char *cp1; + + cp1 = string1; + *cp1 = '\0'; + while(label_ptr){ + if(cp1 >= &string1[PARSER_STRING_MAX-1]) break; + if(label_ptr->opcode == TOK_C_INPUTCHAR){ + if(label_ptr->input_byte == '!') break; + *cp1++ = label_ptr->input_byte; + *cp1 = '\0'; + }/* End IF */ + if(label_ptr->opcode == TOK_C_LABEL_END) break; + label_ptr = label_ptr->next_token; + }/* End While */ + +}/* End Routine */ + +/* COMPARE_LABEL - Test if this is our label + * + * Function: + * + * This routine is called by the GOTO function to compare labels + * to see if they match. + */ +int +compare_label(goto_ptr,label_ptr) +register struct cmd_token *goto_ptr; +register struct cmd_token *label_ptr; +{ +char string1[PARSER_STRING_MAX],string2[PARSER_STRING_MAX]; +char *cp1; + + PREAMBLE(); + + cp1 = string1; + + *cp1 = '\0'; + while(goto_ptr){ + if(cp1 >= &string1[PARSER_STRING_MAX-1]) break; + if(goto_ptr->opcode == TOK_C_INPUTCHAR){ + if(goto_ptr->input_byte == ESCAPE) break; + *cp1++ = goto_ptr->input_byte; + *cp1 = '\0'; + }/* End IF */ + if(goto_ptr->opcode == TOK_C_GOTO_END) break; + goto_ptr = goto_ptr->next_token; + }/* End While */ + + cp1 = string2; + + *cp1 = '\0'; + while(label_ptr){ + if(cp1 >= &string2[PARSER_STRING_MAX-1]) break; + if(label_ptr->opcode == TOK_C_INPUTCHAR){ + if(label_ptr->input_byte == '!') break; + *cp1++ = label_ptr->input_byte; + *cp1 = '\0'; + }/* End IF */ + if(label_ptr->opcode == TOK_C_LABEL_END) break; + label_ptr = label_ptr->next_token; + }/* End While */ + + if(strcmp(string1,string2) == 0) return(YES); + + return(NO); + +}/* End Routine */ + + + +/* FIND_CONDITIONAL_ELSE - Routine to find the else of a conditional + * + * Function: + * + * This routine is called by the conditional expressions when the + * specified condition has not been met and we want to execute the + * else clause of the conditional. The routine searches until it + * finds either the else, or the end of the conditional. + */ +int +find_conditional_else(ct) +register struct cmd_token *ct; +{ + register struct cmd_token *oct; + + PREAMBLE(); + + oct = ct; + while((oct = oct->next_token)){ + if(oct->opcode == TOK_C_CONDITIONAL_ELSE){ + if(oct->ctx.cnest == ct->ctx.cnest){ + jump_to_token = oct; + return(SUCCESS); + }/* End IF */ + }/* End IF */ + + if(oct->opcode == TOK_C_CONDITIONAL_END){ + if(oct->ctx.cnest == (ct->ctx.cnest-1)){ + jump_to_token = oct; + return(SUCCESS); + }/* End IF */ + }/* End IF */ + + }/* End While */ + ct->ctx.go_flag = NO; + return(BLOCKED); + +}/* End Routine */ + +/* FIND_CONDITIONAL_END - Routine to find the close of a conditional + * + * Function: + * + * This routine is called to skip over the else clause and find the + * end of the conditional. + */ +int +find_conditional_end(ct) +register struct cmd_token *ct; +{ + register struct cmd_token *oct; + + PREAMBLE(); + + oct = ct; + while((oct = oct->next_token)){ + if(oct->opcode != TOK_C_CONDITIONAL_END) continue; + if(oct->ctx.cnest != (ct->ctx.cnest-1)) continue; + jump_to_token = oct; + return(SUCCESS); + }/* End While */ + ct->ctx.go_flag = NO; + return(BLOCKED); + +}/* End Routine */ + + + +/* EXEC_DOQ0 - Execute Q register zero as a macro + * + * Function: + * + * This routine is called to execute Q register zero as a macro on + * startup. This allows the user to initialize things from his teco.ini + * before teco reaches command level. + */ +int +exec_doq0() +{ + register struct buff_header *qbp; + register struct undo_token *ut; + struct cmd_token *ct; + + PREAMBLE(); + +/* + * Get a pointer to the q-register buffer structure. If it doesn't + * exist, declare an error. + */ + qbp = buff_qfind('0',0); + if(qbp == NULL){ + error_message("?Internal Error! Q register 0 disappeared during init"); + return(FAIL); + }/* End IF */ +/* + * If the Q register is empty, just return with no error. + */ + if(qbp->zee == 0){ + return(SUCCESS); + }/* End IF */ +/* + * Set up a fake command token and undo token structure for the parser to + * chain undo blocks off of. We don't ever undo this stuff, but the routine + * expects it to be there. + */ + ct = allocate_cmd_token((struct cmd_token *)NULL); + if(ct == NULL) return(FAIL); + + ut = allocate_undo_token(ct); + if(ut == NULL){ + free_cmd_token(ct); + return(FAIL); + }/* End IF */ + + ut->opcode = UNDO_C_MACRO; + ut->carg1 = NULL; + + tecmacro(qbp,ct,(struct cmd_token **)&ut->carg1); + parser_cleanup_ctlist(ct); + return(SUCCESS); + +}/* End Routine */ |