int main ( int argc, char ** argv ) { ifstream mf_file("mutual_funds.txt"); ofstream results("results.txt"); string mf; std::vector<double> rets(8); int num = 30; std::vector<mystruct0> rets; mf = "SPY"; for (unsigned q = 0; q < 8; ++q) { rets[q] = get_return( mf, MARKET_DATA_WEEKLY, NUM_WEEKS_IN_A_QUARTER, q*NUM_WEEKS_IN_A_QUARTER); } mystruct a(mf, rets); rets.push_back(a); print_rets(mf, rets); try { while (mf_file.good()) { getline(mf_file, mf); if (mf.empty()) break; for (unsigned q = 0; q < 8; ++q) { rets[q] = get_return( mf, MARKET_DATA_WEEKLY, NUM_WEEKS_IN_A_QUARTER, q*NUM_WEEKS_IN_A_QUARTER); } print_rets(mf, rets); if (num-- == 0) break; } } catch (exception e) { } mf_file.close(); system("pause"); return 0; }
void count_cds() { FILE *titles_fp = NULL; FILE *tracks_fp = NULL; char entry[MAX_ENTRY]; int titles = 0; int tracks = 0; titles_fp = fopen(title_file, "r"); if (titles_fp) { while (fgets(entry, MAX_ENTRY, titles_fp)) titles++; fclose(titles_fp); } tracks_fp = fopen(tracks_file, "r"); if (tracks_fp) { while (fgets(entry, MAX_ENTRY, tracks_fp)) tracks++; fclose(tracks_fp); } mvprintw(ERROR_LINE, 0, "Database contains %d titles, witch a total of %d tracks.", titles, tracks); get_return(); }
void count_cds() { FILE *titles_fp, *tracks_fp; char entry[MAX_ENTRY]; int titles = 0; int tracks = 0; titles_fp = fopen(TITLE_FILE, "r"); if (titles_fp) { while (fgets(entry, MAX_ENTRY, titles_fp)){ titles++; } fclose(titles_fp); } tracks_fp = fopen(TRACKS_FILE, "r"); if (tracks_fp) { while (fgets(entry, MAX_ENTRY, tracks_fp)){ tracks++; } fclose(tracks_fp); } mvprintw(ERROR_LINE, 0, "Database contains %d titles, with a total of %d tracks.", titles, tracks); get_return(); }
/* Compute a count of the total number of records and tracks in the db */ void count_cds() { FILE *titles_fp, *tracks_fp; char entry[MAX_ENTRY]; int ntitles = 0; int ntracks = 0; // count titles titles_fp = fopen(TITLE_FILE, "r"); if (titles_fp) { // note that this is expected to fail if no writes yet while (fgets(entry, MAX_ENTRY, titles_fp)) { ntitles++; } fclose(titles_fp); } // count tracks tracks_fp = fopen(TRACKS_FILE, "r"); if (tracks_fp) { while (fgets(entry, MAX_ENTRY, tracks_fp)) { ntracks++; } fclose(tracks_fp); } // print message, and wait for user to press return so they have a chance // to read it. mvprintw(ERROR_LINE, 0, "Database containes %d titles, and a total of %d tracks", ntitles, ntracks); get_return(); }
/* Find a cd. If it's found, we store it's info in the globals * `current_cd` and `current_cat`. If we find 0 or more than 1 matches, * we inform the user and null-out `current_cd` * * NOTE: the authors hae typos here, everywhere where they have `found == ...` * they intended to have `found = ...` */ void find_cd() { char match[MAX_STRING], entry[MAX_ENTRY]; FILE *titles_fp; int count = 0; char *found, *title, *catalog; mvprintw(Q_LINE, 0, "Enter a string to search for in CD titles: "); get_string(match); titles_fp = fopen(TITLE_FILE, "r"); if (titles_fp) { while (fgets(entry, MAX_ENTRY, titles_fp)) { // skip over the catalog... the strstr function returns // a pointer to the first match against s2 found in s1, or NULL // if not found. catalog = entry; if ((found = strstr(catalog, ","))) { *found = '\0'; // make `catalog` be '\0'-terminated title = found + 1; // do another search for a ',', so that we can isolate the // title portion of the entry before doing our actual search. if ((found = strstr(title, ","))) { *found = '\0'; // make `title` be '\0'-terminated // now that we've isolated the title, we can do our // actual search // (NOTE: the above code should really be factored out // since (a) it's general, and (b) it obscures what's // going on with low-level implementation details) if ((found = strstr(title, match))) { count++; strcpy(current_cd, title); strcpy(current_cat, catalog); } } } } fclose(titles_fp); } // if we did not find exactly one match, print a message and wait for user // to press enter. if (count != 1) { if (count == 0) { mvprintw(ERROR_LINE, 0, "Sorry, no matching CD found"); } if (count > 1) { mvprintw(ERROR_LINE, 0, "Sorry, match is ambiguous; %d CDs found", count); } current_cd[0] = '\0'; get_return(); } }
void find_cd() { char match[MAX_STRING], entry[MAX_ENTRY]; FILE *titles_fp; int count = 0; char *found, *title, *catalog; mvprintw(Q_LINE, 0, "Enter a string to search for in CD titles: "); get_string(match); titles_fp = fopen(TITLE_FILE, "r"); if (titles_fp) { while (fgets(entry, MAX_ENTRY, titles_fp)) { /* Skip past catalog number */ catalog = entry; if (found = strstr(catalog, ",")) { *found = '\0'; title = found + 1; /* Zap the next comma in the entry to reduce it to title only */ if (found = strstr(title, ",")) { *found = '\0'; /* Now see if the match substring is present */ if (found = strstr(title, match)) { count++; strcpy(current_cd, title); strcpy(current_cat, catalog); } } } } fclose(titles_fp); } if (count != 1) { if (count == 0) { mvprintw(ERROR_LINE, 0, "Sorry, no matching CD found."); } if (count > 1) { mvprintw(ERROR_LINE, 0, "Sorry, match is ambiguous: %d CDs found.", count); } current_cd[0] = '\0'; get_return(); } }
void find_cd() { char match[MAX_STRING], entry[MAX_ENTRY]; FILE *titles_fp; int count = 0; char *found, *title, *catalog; mvprintw(Q_LINE, 0, "Enter a string to search for in CD titles: "); get_string(match); titles_fp = fopen(title_file, "r"); if (titles_fp) { while (fgets(entry, MAX_ENTRY, titles_fp)) { catalog = entry; if ((found = strstr(catalog, ","))) { *found = 0; title = found + 1; if ((found = strstr(title, ","))) { *found = '\0'; if ((found = strstr(title, match))) { count++; strcpy(current_cd, title); strcpy(current_cat, catalog); } } } } fclose(titles_fp); } if (count != 1) { if (count == 0) mvprintw(ERROR_LINE, 0, "Sorry, no matching CD found."); if (count > 1) mvprintw(ERROR_LINE, 0, "Sorry, match is ambiguous: %d CDs found. ", count); current_cd[0] = '\0'; get_return(); } }
static int add_current_alias(void) { /* * Alias the current message to the specified name and * add it to the alias text file, for processing as * the user leaves the program. * * Returns non-zero iff alias actually added to file. */ char aliasname[SLEN], firstname[SLEN], lastname[SLEN]; char comment[SLEN], address1[LONG_STRING], buffer[SLEN]; char comment_buff[LONG_STRING]; char *chspace, *bufptr; struct header_rec *current_header; static char bad_punc[] = ",.:;"; char *punc_ptr; int i, match; int replace, to_replace; if (curr_folder.curr_mssg == 0) { dprint(4, (debugfile, "Add current alias called without any current message!\n")); show_error(catgets(elm_msg_cat, AliasesSet, AliasesNoMessage, "No message to alias to!")); return(0); } current_header = curr_folder.headers[curr_folder.curr_mssg-1]; strcpy(buffer, catgets(elm_msg_cat, AliasesSet, AliasesCurrentMessage, "Current message address aliased to: ")); PutLine(LINES-2,0, buffer); CleartoEOLN(); *aliasname = '\0'; if ((replace = get_aliasname(aliasname, buffer, &to_replace)) < 0) { dprint(3, (debugfile, "Aliasname [%s] was rejected in add_current_alias\n", aliasname)); ClearLine(LINES-2); return(0); } /* use full name in current message for default comment */ tail_of(current_header->from, comment_buff, current_header->to); if(strchr(comment_buff, (int)'!') || strchr(comment_buff, (int)'@')) /* never mind - it's an address not a full name */ *comment_buff = '\0'; /* * Try to break up the From: comment into firstname, lastname, and * any other text. This is based on the fact that many address * comments are pretty straightforward. This will break on many * situations. Should handle: * (Robert Howard) * (Robert L. Howard) * (Robert Howard, Georgia Tech) * pretty well. Will break on: * (The Voice of Reason) * and others.... */ *firstname = '\0'; *lastname = '\0'; *comment = '\0'; if (strlen(comment_buff) != 0) { /* There is something. */ bufptr = comment_buff; while (*bufptr == ' ') bufptr++; /* Always strip leading WS */ if ((chspace = strchr(bufptr, ' ')) != NULL) { /* * A space means that there is at least (firstname lastname) * Get firstname and move bufptr. */ *chspace = '\0'; strcpy(firstname, bufptr); bufptr = chspace + 1; /* Move the pointer */ while (*bufptr == ' ') bufptr++; } above: if ((chspace = strchr(bufptr, ' ')) != NULL) { /* * Another space means a third+ word. We either have: * 1. Word 3+ is a comment, or * 2. Word 2 is a middle initial (word 3 is lastname). * Check and see. */ *chspace = '\0'; if ((strlen(bufptr) == 1) || (strlen(bufptr) == 2 && *(bufptr+1) == '.')) { /* * If the second word is either a single * character or a character followed by '.' it was * probably a middle initial. Add it to firstname * and shift. */ strcat(firstname, " "); strcat(firstname, bufptr); bufptr = chspace + 1; /* Move the pointer */ while (*bufptr == ' ') bufptr++; goto above; } strcpy(lastname, bufptr); bufptr = chspace + 1; /* Move the pointer */ while (*bufptr == ' ') bufptr++; strcpy(comment, bufptr); } else { /* * Only a lastname left. */ strcpy(lastname, bufptr); } /* * Finally, get any puctuation characters off the end of * lastname. */ match = TRUE; for (i = strlen(lastname) - 1; match && i>0; i--) { match = FALSE; for (punc_ptr = bad_punc; *punc_ptr != '\0'; punc_ptr++) { if (lastname[i] == *punc_ptr) { lastname[i] = '\0'; match = TRUE; break; } } } } get_realnames(aliasname, firstname, lastname, comment, buffer); /* grab the return address of this message */ get_return(address1, curr_folder.curr_mssg-1); strcpy(address1, strip_parens(address1)); /* remove parens! */ return(ask_accept(aliasname, firstname, lastname, comment, address1, buffer, replace, to_replace)); }
void list_tracks() { FILE *tracks_fp; char entry[MAX_ENTRY]; int cat_length; int lines_op = 0; WINDOW *track_pad_ptr; int tracks; int key; int first_line = 0; if (current_cd[0] == '\0') { mvprintw(ERROR_LINE, 0, "You must select a CD first. ", stdout); get_return(); return; } clear_all_screen(); cat_length = strlen(current_cat); tracks_fp = fopen(tracks_file, "r"); if (!tracks_fp) return; while (fgets(entry, MAX_ENTRY, tracks_fp)) { if (strncmp(current_cat, entry, cat_length) == 0) tracks++; } fclose(tracks_fp); track_pad_ptr = newpad(tracks + 1 + BOXED_LINES, BOXED_ROWS + 1); if (!track_pad_ptr) return; tracks_fp = fopen(tracks_file, "r"); if (!tracks_fp) return; mvprintw(4, 0, "CD Track Listing\n"); while (fgets(entry, MAX_ENTRY, tracks_fp)) { if (strncmp(current_cat, entry, cat_length) == 0) { mvwprintw(track_pad_ptr, lines_op++, 0, "%s", entry + cat_length + 1); } } fclose(tracks_fp); if (lines_op > BOXED_LINES) { mvprintw(MESSAGE_LINE, 0, "Cursor keys to scroll, RETURN or q to exit"); } else { mvprintw(MESSAGE_LINE, 0, "RETURN or q to exit"); } wrefresh(stdscr); keypad(stdscr, TRUE); cbreak(); noecho(); key = 0; while (key != 'q' && key != KEY_ENTER && key != '\n') { if (key == KEY_UP) { if (first_line > 0) first_line--; } if (key == KEY_DOWN) { if (first_line + BOXED_LINES + 1 < tracks) first_line++; } prefresh(track_pad_ptr, first_line, 0, BOX_LINE_POS, BOX_ROW_POS, BOX_LINE_POS + BOXED_LINES, BOX_ROW_POS + BOXED_ROWS); key = getch(); } delwin(track_pad_ptr); keypad(stdscr, FALSE); nocbreak(); echo(); }
/* list_tracks - list the tracks for the current CD */ void list_tracks() { FILE *tracks_fp; char entry[MAX_ENTRY]; int cat_length; int lines_op = 0; WINDOW *track_pad_ptr; int tracks = 0; int key; int first_line = 0; if (current_cd[0] == '\0') { mvprintw(ERROR_LINE, 0, "You must select a CD first. ", stdout); get_return(); return; } clear_all_screen(); cat_length = strlen(current_cat); /* First count the number of tracks for the current CD */ tracks_fp = fopen(tracks_file, "r"); if (!tracks_fp) return; while (fgets(entry, MAX_ENTRY, tracks_fp)) { if (strncmp(current_cat, entry, cat_length) == 0) tracks++; } fclose(tracks_fp); /* Make a new pad, ensure that even if there is only a single track the PAD is large enough so the later prefresh() is always valid. */ track_pad_ptr = newpad(tracks + 1 + BOXED_LINES, BOXED_ROWS + 1); if (!track_pad_ptr) return; tracks_fp = fopen(tracks_file, "r"); if (!tracks_fp) return; mvprintw(4, 0, "CD Track Listing\n"); /* write the track information into the pad */ while (fgets(entry, MAX_ENTRY, tracks_fp)) { /* Compare catalog number and output rest of entry */ if (strncmp(current_cat, entry, cat_length) == 0) { mvwprintw(track_pad_ptr, lines_op++, 0, "%s", entry + cat_length + 1); } } fclose(tracks_fp); if (lines_op > BOXED_LINES) { mvprintw(MESSAGE_LINE, 0, "Cursor keys to scroll, RETURN or q to exit"); } else { mvprintw(MESSAGE_LINE, 0, "RETURN or q to exit"); } wrefresh(stdscr); keypad(stdscr, TRUE); cbreak(); noecho(); key = 0; while (key != 'q' && key != KEY_ENTER && key != '\n') { if (key == KEY_UP) { if (first_line > 0) first_line--; } if (key == KEY_DOWN) { if (first_line + BOXED_LINES + 1 < tracks) first_line++; } /* now draw the appropriate part of the pad on the screen */ prefresh(track_pad_ptr, first_line, 0, BOX_LINE_POS, BOX_ROW_POS, BOX_LINE_POS + BOXED_LINES, BOX_ROW_POS + BOXED_ROWS); /* wrefresh(stdscr); */ key = getch(); } delwin(track_pad_ptr); keypad(stdscr, FALSE); nocbreak(); echo(); }
//execute context l_thread::type_return l_thread::execute(l_call_context& context) { //lock context context.lock(); //save context register3(R_CONTEXT) = l_variable( &context ); //pc... unsigned int pc = 0; l_function& function = m_vm->function(context.get_fun_id()); l_list_command& commands = function.m_commands; //macro #define raise(str)\ {\ push_error(str, pc, (unsigned int)commands[pc].m_line);\ return T_RETURN_ERROR;\ } #define vconst(c) function.m_costants[c] #define top_size (m_top+1) //for all commands for (pc = 0; pc < commands.size(); ++pc) { //current command l_command& cmp = commands[pc]; //opcodes switch (cmp.m_op_code) { case L_JMP: pc = cmp.m_arg - 1; break; case L_RETURN: //push return if(cmp.m_arg) { //get value register3(2) = pop(); //return... return T_RETURN_VALUE; } else { //came back return T_RETURN_VOID; } //.. break; case L_IF: if(top().is_true()) { pc = cmp.m_arg - 1; } pop(); break; case L_IF0: if(top().is_false()) { pc = cmp.m_arg - 1; } pop(); break; case L_IF_OR_POP: if(top().is_true()) { pc = cmp.m_arg - 1; } else { pop(); } break; case L_IF0_OR_POP: if(top().is_false()) { pc = cmp.m_arg - 1; } else { pop(); } break; case L_PUSH: push( stack(cmp.m_arg) ); break; case L_PUSH_NULL: push( l_variable() ); break; case L_PUSH_TRUE: push( l_variable(true) ); break; case L_PUSH_FALSE: push( l_variable(false) ); break; case L_PUSHK: push( vconst(cmp.m_arg) ); break; case L_CLOSER: { //get value l_variable& call_fun = vconst(cmp.m_arg); //... if(call_fun.is_function()) { //new context register3(0) = l_closer::gc_new(get_gc()); //init context register3(0).to<l_closer>()->init(call_fun.m_value.m_fid, this, l_variable(&context)); //push context push(register3(0)); } } break; //////////////////////////////////////////////////////////// case L_ADD: if(!stack(1).add(stack(0),stack(1))) raise("not valid operation"); pop(); break; case L_MUL: if(!stack(1).mul(stack(0),stack(1))) raise("not valid operation"); pop(); break; case L_SUB: if(!stack(1).sub(stack(0),stack(1))) raise("not valid operation"); pop(); break; case L_DIV: if(!stack(1).div(stack(0),stack(1))) raise("not valid operation"); pop(); break; case L_MOD: if(!stack(1).mod(stack(0),stack(1))) raise("not valid operation"); pop(); break; case L_UNM: if(!stack(0).unm(stack(0))) raise("not valid operation"); break; //////////////////////////////////////////////////////////// case L_EQ: if(!stack(1).equal(stack(0),stack(1))) raise("not valid operation"); pop(); break; case L_NEQ: if(!stack(1).not_equal(stack(0),stack(1))) raise("not valid operation"); pop(); break; case L_RT: if(!stack(1).rt(stack(0),stack(1))) raise("not valid operation"); pop(); break; case L_RE: if(!stack(1).re(stack(0),stack(1))) raise("not valid operation"); pop(); break; case L_LT: if(!stack(1).lt(stack(0),stack(1))) raise("not valid operation"); pop(); break; case L_LE: if(!stack(1).le(stack(0),stack(1))) raise("not valid operation"); pop(); break; //////////////////////////////////////////////////////////// case L_NOT: if(!stack(0).not_value(stack(0))) raise("not valid operation"); break; case L_OR: if(!stack(1).or_value(stack(0),stack(1))) raise("not valid operation"); pop(); break; case L_AND: if(!stack(1).and_value(stack(0),stack(1))) raise("not valid operation"); pop(); break; //////////////////////////////////////////////////////////// case L_GET_GLOBAL: push( global(context,cmp.m_arg) ); break; case L_SET_GLOBAL: global(context,cmp.m_arg) = pop(); break; //////////////////////////////////////////////////////////// case L_GET_LOCAL: push( strick_local(context,cmp.m_arg) ); break; case L_SET_LOCAL: strick_local(context,cmp.m_arg) = pop(); break; //////////////////////////////////////////////////////////// case L_SET_UP_VALUE: local(context,cmp.m_arg) = pop(); break; case L_GET_UP_VALUE: push( local(context,cmp.m_arg) ); break; //////////////////////////////////////////////////////////// case L_GET_THIS: push(context.this_field()); break; case L_SET_THIS: context.this_field() = pop(); break; case L_SET_THIS_NPOP: context.this_field() = stack(cmp.m_arg); break; //////////////////////////////////////////////////////////// case L_NEW_ARRAY: { register3(0) = l_array::gc_new(get_gc()); //init ? if( cmp.m_arg > 0 ) { //types l_array* vector = register3(0).array(); //put stack into vector for(int i = cmp.m_arg-1; i >= 0; --i) { vector->operator[](i) = pop(); } } //push array (n.b. gc run...) push( register3(0) ); } break; //alloc tablet case L_NEW_TABLE: { register3(0) = l_table::gc_new(get_gc()); //init ? if( cmp.m_arg > 0 ) { //types l_table* table = register3(0).table(); //assert assert(!(cmp.m_arg % 2)); //put stack into vector for(int i = (cmp.m_arg)-1; i >= 0; i-=2) { //push key and value table->operator[](stack(1)) = stack(0); //pop value pop(); //pop key pop(); } } //push table (n.b. gc run...) push( register3(0) ); } break; case L_GET_AT_VAL: { l_variable& r_b = stack(1); const l_variable& r_c = stack(0); //try if ( r_b.is_object() ) { //is a vector if(r_b.is_array()) { //types l_array* vector = r_b.array(); //to size int size_t index = 0; //cast if( r_c.is_int() ) index= (size_t)r_c.m_value.m_i; else if( r_c.is_float() )index= (size_t)r_c.m_value.m_f; else raise( "value isn't a valid key" ); //save last get_this() = stack(1); //get stack(1) = vector->operator[](index) ; } else if(r_b.is_table()) { //types l_table* table = r_b.table(); //is a string? if(!r_c.is_string()) raise( "value isn't a valid key" ); //save last get_this() = stack(1); //get and pop value stack(1) = table->operator[](r_c); } else { raise( "value isn't a vector/table, field not available" ); } } else { raise( "value isn't a vector/table/object, field not avaliable" ); } //pop index pop(); } break; case L_SET_AT_VAL: { //get table/array l_variable& r_a = stack(2); //get index const l_variable& r_b = stack(1); //try if ( r_a.is_object() ) { //is a vector if(r_a.is_array()) { //types l_array* vector = r_a.array(); //to size int size_t index = 0; //cast if( r_b.is_int() ) index= (size_t)r_b.m_value.m_i; else if( r_b.is_float() ) index= (size_t)r_b.m_value.m_f; else raise( "value isn't a valid key" ); //get and pop value vector->operator[](index) = pop(); } else if(r_a.is_table()) { //types l_table* table = r_a.table(); //is a string? if(!r_b.is_string()) raise( "value isn't a valid key" ); //get and pop value table->operator[](r_b) = pop(); } else { raise( "value isn't a vector/table, field not available" ); } } else { //pop value pop(); } //pop index pop(); //pop array/tablet pop(); } break; //for in case L_IT: { //get index l_variable& r_a = top(); //.. //try if ( r_a.is_object() ) { //get object l_obj* this_obj = (l_obj*)r_a.m_value.m_pobj; //is a vector if(r_a.is_array()) { //types l_array* vector = r_a.array(); //pop value pop(); //push it push( vector->get_it() ); } else if (r_a.is_table()) { //types l_table* table = r_a.table(); //pop value pop(); //push it push( table->get_it() ); } else if (r_a.to<l_xrange>()) { //types l_xrange* xrange = static_cast< l_xrange* > ( this_obj ); //pop value pop(); //push it push( xrange->get_it() ); } else { raise( "this value not have a iterator" ); } } else { //pop value pop(); //.. raise( "value isn't a table/array/object, iterator not supported" ); } } break; //for of case L_FOR_IN: case L_FOR_OF: { //get index l_variable& r_it = top(); //try if ( r_it.is_iterator() ) { //types l_iterator* l_it = r_it.iterator(); //is array it if(l_it) { //else assert assert(l_it); //push it if(l_it->valid()) { if(cmp.m_op_code == L_FOR_OF) { //get next push( l_it->get() ); } else //L_FOR_IN { //get next push( l_it->get_id() ); } //next l_it->self_next(); } else { //pop iterator pop(); //and jump pc = cmp.m_arg - 1; } } else { raise( "value isn't a valid iterator" ); } } else { //pop it pop(); //and jump pc = cmp.m_arg - 1; //... raise( "value isn't an iterator" ); } } break; case L_THIS_CALL: case L_CALL: { //get index register3(0) = pop(); //get args if( register3(0).is_cfunction() ) { //return size int n_return = register3(0).m_value.m_pcfun(this,cmp.m_arg); //assert (1 return) assert(n_return <= 1); //error if(n_return<0) { raise( "native call exception" ); } else if(n_return>1) { raise( "native call can't return more than a value" ); } //pop args for(int i=0; i < cmp.m_arg; ++i) { pop(); } //if return if(n_return) push(get_return()); } else if( register3(0).is_closer() ) { //get context l_closer* closer = register3(0).to<l_closer>(); //else assert if(!closer){ assert(0); }; //new function l_function& call_fun = m_vm->function(closer->get_fun_id()); //save last context l_variable last_ctx = register3(R_CONTEXT); //new context register3(1) = l_call_context::gc_new(get_gc()); l_call_context* new_ctx = register3(1).to<l_call_context>(); //this? if(cmp.m_op_code == L_THIS_CALL) { new_ctx->this_field() = get_this(); } //init new_ctx->init(*closer); //lock context new_ctx->lock(); //n args unsigned int n_fun_args = call_fun.m_args_size; //alloc array args..? if (call_fun.m_have_args_list) { //alloc array register3(3) = l_array::gc_new(get_gc()); } //put arguments for(unsigned int arg = 0; arg != cmp.m_arg; ++arg) { if (arg < n_fun_args) { new_ctx->variable( call_fun.constant(arg) ) = pop(); } else if (call_fun.m_have_args_list) { register3(3).array()->push(pop()); } else { pop(); } } //add var list if (call_fun.m_have_args_list) { //push array new_ctx->variable( call_fun.constant(n_fun_args) ) = register3(3); //to null register3(3) = l_variable(); } //save stack long stack_top_bf_call = m_top; //execute call type_return n_return = execute(*new_ctx); //error? if(n_return==T_RETURN_ERROR) { raise( "call exception" ); } //unlock context new_ctx->unlock(); //reset last context register3(R_CONTEXT) = last_ctx; //restore stack m_top = stack_top_bf_call; //return? if(n_return == T_RETURN_VALUE) { push(register3(2)); } } else { raise( "value isn't an function" ); } //dealloc if(cmp.m_op_code == L_THIS_CALL) { get_this() = l_variable(); } } break; default: break; } } return T_RETURN_VOID; }
/* This function can only be called if a cd has already been selected and * stored in the globals `current_cd` and `current_cat`. */ void list_tracks() { FILE *tracks_fp; char entry[MAX_ENTRY]; int cat_length; int lines_op = 0; WINDOW *track_pad; int ntracks = 0; int key; int first_line = 0; // handle the case of no current cd if (current_cd[0] == '\0') { mvprintw(ERROR_LINE, 0, "You must select a CD before listing tracks"); get_return(); return; } clear_all_screen(); // First, count the number of tracks for the current CD. close the // file when done so we can reopen before listing them. cat_length = strlen(current_cat); tracks_fp = fopen(TRACKS_FILE, "r"); if (!tracks_fp) return; while (fgets(entry, MAX_ENTRY, tracks_fp)) { if (strncmp(current_cat, entry, cat_length) == 0) { ntracks++; } } fclose(tracks_fp); // make a new pad. Make sure it is big enough to fill up the boxed region // even if there are no listings. // NOTE: we don't actually make a box for this operation... the box is // only used in update_cd. But we are reusing the same region. track_pad = newpad(ntracks + 1 + BOXED_LINES, BOXED_COLS + 1); if (!track_pad) return; // reopen the tracks file tracks_fp = fopen(TRACKS_FILE, "r"); if (!tracks_fp) return; // print out all the tracks onto the pad. mvprintw(4, 0, "CD Track Listing\n"); while (fgets(entry, MAX_ENTRY, tracks_fp)) { if (strncmp(current_cat, entry, cat_length) == 0) { // print the track info. Use `cat_length+1` bc of the comma // this actually is kind of strange because we are still // printing a kind of ugly comma-separated track number and // name, but it works. You could make it better as an exercise. mvwprintw(track_pad, lines_op++, 0, "%s", entry + cat_length + 1); } } fclose(tracks_fp); // tell the user what to do if (lines_op > BOXED_LINES) { mvprintw(MESSAGE_LINE, 0, "Arrows to scroll, RETURN or q to exit."); } else { mvprintw(MESSAGE_LINE, 0, "RETURN or q to exit."); } // set up the control keys and such, refresh the main screen wrefresh(stdscr); keypad(stdscr, TRUE); cbreak(); noecho(); // start up a loop over control keys; inside the loop refresh the pad key = 0; while (key != '\n' && key != KEY_ENTER && key != 'q') { if (key == KEY_UP) { if (first_line > 0) { first_line--; } } else if (key == KEY_DOWN) { if (first_line + BOXED_LINES < ntracks - 1) { first_line++; } } prefresh(track_pad, first_line, 0, BOX_LINE_POS, BOX_COL_POS, BOX_LINE_POS + BOXED_LINES, BOX_COL_POS + BOXED_COLS); key = getch(); } }
void main_loop(void) { int c; int in_defun=0; char *p; lineno = 1; reset(); put_lineno(); LOOP: c = jump_to_at(); if (c == ')') { if (!in_defun) error("unmatched @) found"); in_defun = 0; putc('}',out); reset(); goto LOOP; } else if (c == '\'') { char *p; poolp = pool; p = read_symbol(0); pushc('\0'); fprintf(out,"%s",p); goto LOOP; } else if (c == '[') { char *p; poolp = pool; p = read_symbol(1); pushc('\0'); fprintf(out,"%s",p); goto LOOP; } else if (c != '(') { char *p; unreadc(c); poolp = pool; poolp = p = read_function(); fprintf(out,"%s",translate_function(poolp)); goto LOOP; } p = read_token(); if (strcmp(p, "defun") == 0) { if (in_defun) error("@) expected before new function definition"); in_defun = 1; get_function(); get_lambda_list(); put_fhead(); put_lineno(); c = jump_to_at(); put_declaration(); put_lineno(); } else if (strcmp(p, "return") == 0) { tab_save = tab; get_return(); put_return(); } else error_symbol(p); goto LOOP; }