int main() { /* ** Push several values on each stack. */ push_int( 5 ); push_int( 22 ); push_int( 15 ); push_float( 25.3 ); push_float( -40.5 ); /* ** Empty the integer stack and print the values. */ while( !is_empty_int() ) { printf( "Popping %d\n", top_int() ); pop_int(); } /* ** Empty the float stack and print the values. */ while( !is_empty_float() ) { printf( "Popping %f\n", top_float() ); pop_float(); } return EXIT_SUCCESS; }
/*! @decl string _sprintf() */ static void f_path_element_sprintf(INT32 args) { INT_TYPE mode; struct mapping *opts; cairo_path_data_t* data = THIS->element; get_all_args("_sprintf", args, "%i%m", &mode, &opts); pop_n_elems (args); if (mode == 'O') { switch (data->header.type) { case CAIRO_PATH_MOVE_TO: push_constant_text ("%O(CAIRO_PATH_MOVE_TO(%f,%f))"); ref_push_object(Pike_fp->current_object); f_object_program (1); push_float(data[1].point.x); push_float(data[1].point.y); f_sprintf(4); break; case CAIRO_PATH_LINE_TO: push_constant_text ("%O(CAIRO_PATH_LINE_TO(%f,%f))"); ref_push_object(Pike_fp->current_object); f_object_program (1); push_float(data[1].point.x); push_float(data[1].point.y); f_sprintf(4); break; case CAIRO_PATH_CURVE_TO: push_constant_text ("%O(CAIRO_PATH_CURVE_TO(%f,%f,%f,%f,%f))"); ref_push_object(Pike_fp->current_object); f_object_program (1); push_float(data[1].point.x); push_float(data[1].point.y); push_float(data[2].point.x); push_float(data[2].point.y); push_float(data[3].point.x); push_float(data[3].point.y); f_sprintf(8); break; case CAIRO_PATH_CLOSE_PATH: push_constant_text ("%O(CAIRO_PATH_CLOSE_PATH()"); ref_push_object(Pike_fp->current_object); f_object_program (1); f_sprintf(2); break; default: push_undefined(); return; } } else push_undefined(); }
/*! @decl mapping(string:float) get_point(int point) */ static void f_path_element_get_point(INT32 args) { int i; get_all_args("get_point", args, "%d", &i); i++; // index includes header if (i > 0 && i < THIS->element->header.length) { push_text( "x" ); push_float(THIS->element[i].point.x); push_text( "y" ); push_float(THIS->element[i].point.y); f_aggregate_mapping(4); } else push_undefined(); }
static int add_vertex_imp(float v[8]) { int i; for (i = vertex.len - 8; i >= 0; i -= 8) if (!memcmp(vertex.data + i, v, sizeof(float) * 8)) return i / 8; for (i = 0; i < 8; i++) push_float(&vertex, v[i]); return vertex.len / 8 - 1; }
/* float get_relevance() */ static void f_get_relevance(INT32 args) { float relevance; GET_PIKE_SEARCH(); if (args) Pike_error("Too many arguments to Search->get_relevance()\n"); THREADS_ALLOW(); relevance = avs_search_getrelevance(search->handle); THREADS_DISALLOW(); push_float(relevance); }
void LuaCreature::OnHit(Unit* mTarget, float fAmount) { NULL_BINDING_CHECK lua_engine::BeginLuaFunctionCall(m_binding->refs[CREATURE_EVENT_ON_HIT]); push_creature(_unit); push_int(CREATURE_EVENT_ON_HIT); push_unit(mTarget); push_float(fAmount); lua_engine::ExecuteLuaFunction(4); RELEASE_LOCK }
/*----------------------------------------------------------------------------*/ PmReturn_t tres_pm_save_state(pPmFrame_t *ppframe) { PmReturn_t retv = PM_RET_OK; pPmObj_t pobj; pPmInstance_t pcli; pPmDict_t pdict; uint16_t index; if(NATIVE_GET_NUM_ARGS() != 1) { PM_RAISE(retv, PM_RET_EX_TYPE); return retv; } pobj = NATIVE_GET_LOCAL(0); if(OBJ_GET_TYPE(pobj) != OBJ_TYPE_CLI) { PM_RAISE(retv, PM_RET_EX_TYPE); return retv; } pcli = (pPmInstance_t)pobj; pdict = pcli->cli_attrs; // store each attribute of the object for(index = 0; index < pdict->length; index++) { seglist_getItem(pdict->d_keys, index, &pobj); retv = seglist_getItem(pdict->d_vals, index, &pobj); PM_RETURN_IF_ERROR(retv); switch (OBJ_GET_TYPE(pobj)) { case OBJ_TYPE_INT: push_int(((pPmInt_t) pobj)->val); break; case OBJ_TYPE_FLT: push_float(((pPmFloat_t) pobj)->val); break; } } NATIVE_SET_TOS(PM_NONE); return retv; }
/*----------------------------------------------------------------------------*/ PmReturn_t tres_pm_state_push(pPmFrame_t *ppframe) { //const char *ptr; int32_t ival; float fval; PmReturn_t retv = PM_RET_OK; pPmObj_t pa; /* Raise TypeError if wrong number of args */ pa = NATIVE_GET_LOCAL(0); if(NATIVE_GET_NUM_ARGS() != 1) { PM_RAISE(retv, PM_RET_EX_TYPE); return retv; } switch (OBJ_GET_TYPE(pa)) { //case OBJ_TYPE_STR: // ptr = (char const *)&(((pPmString_t)pa)->val); // // TODO: unimplemented // break; case OBJ_TYPE_INT: ival = ((pPmInt_t) pa)->val; push_int(ival); break; case OBJ_TYPE_FLT: fval = ((pPmFloat_t) pa)->val; push_float(fval); break; default: /* Raise TypeError */ PM_RAISE(retv, PM_RET_EX_TYPE); } NATIVE_SET_TOS(PM_NONE); return retv; }
static void f_ultraparse( INT32 args ) { FD f = -1; int lines=0, cls, c=0, my_fd=1, tzs=0, state=0, next; unsigned char *char_pointer=0; /* array with offsets for fields in the string buffer */ int buf_points[16]; INT32 v=0, offs0=0, len=0, bytes=0, gotdate=0; INT32 last_hour=0, last_date=0, last_year=0, last_month=0, this_date=0, broken_lines=0, tmpinteger=0, field_position=0; time_t start; unsigned char *read_buf; struct svalue *statfun, *daily, *pagexts=0, *file, *refsval, *log_format; unsigned char *buf; char *field_buf; #ifdef BROKEN_LINE_DEBUG INT32 broken_line_pos=0; unsigned char *broken_line; #endif INT32 *state_list, *save_field_num, *field_endings, num_states; char *notref = 0; INT32 state_pos=0, bufpos=0, i, fieldnum=0; struct pike_string *url_str = 0, *ref_str = 0, *rfc_str = 0, *hst_str = 0, *tmpagent = 0; struct svalue *url_sval; ONERROR unwind_protect; unsigned INT32 hits_per_hour[24]; unsigned INT32 hosts_per_hour[24]; unsigned INT32 pages_per_hour[24]; unsigned INT32 sessions_per_hour[24]; double kb_per_hour[24]; unsigned INT32 session_length[24]; /* struct mapping *unique_per_hour = allocate_mapping(1);*/ struct mapping *hits_per_error = allocate_mapping(10); struct mapping *error_urls = allocate_mapping(10); struct mapping *error_refs = allocate_mapping(10); struct mapping *user_agents = allocate_mapping(10); struct mapping *directories = allocate_mapping(20); struct mapping *referrers = allocate_mapping(1); struct mapping *refsites = allocate_mapping(1); struct mapping *referredto = allocate_mapping(1); struct mapping *pages = allocate_mapping(1); struct mapping *hosts = allocate_mapping(1); struct mapping *hits = allocate_mapping(1); struct mapping *session_start = allocate_mapping(1); struct mapping *session_end = allocate_mapping(1); struct mapping *hits20x = allocate_mapping(300); struct mapping *hits302 = allocate_mapping(2); struct mapping *sites = allocate_mapping(1); struct mapping *domains = allocate_mapping(1); struct mapping *topdomains = allocate_mapping(1); struct mapping *tmpdest = NULL; /* struct mapping *hits30x = allocate_mapping(2);*/ if(args>6 && sp[-1].type == T_INT) { offs0 = sp[-1].u.integer; pop_n_elems(1); --args; } if(args>5 && sp[-1].type == T_STRING) { notref = sp[-1].u.string->str; pop_n_elems(1); --args; } lmu = 0; get_all_args("UltraLog.ultraparse", args, "%*%*%*%*%*", &log_format, &statfun, &daily, &file, &pagexts); if(log_format->type != T_STRING) Pike_error("Bad argument 1 to Ultraparse.ultraparse, expected string.\n"); if(statfun->type != T_FUNCTION) Pike_error("Bad argument 2 to Ultraparse.ultraparse, expected function.\n"); if(daily->type != T_FUNCTION) Pike_error("Bad argument 3 to Ultraparse.ultraparse, expected function.\n"); if(pagexts->type != T_MULTISET) Pike_error("Bad argument 5 to Ultraparse.ultraparse, expected multiset.\n"); if(file->type == T_OBJECT) { f = fd_from_object(file->u.object); if(f == -1) Pike_error("UltraLog.ultraparse: File is not open.\n"); my_fd = 0; } else if(file->type == T_STRING && file->u.string->size_shift == 0) { do { f=fd_open(file->u.string->str, fd_RDONLY, 0); } while(f < 0 && errno == EINTR); if(errno < 0) Pike_error("UltraLog.ultraparse(): Failed to open file for reading (errno=%d).\n", errno); } else Pike_error("Bad argument 4 to UltraLog.ultraparse, expected string or object .\n"); state_list = malloc((log_format->u.string->len +3) * sizeof(INT32)); save_field_num = malloc((log_format->u.string->len +3) * sizeof(INT32)); field_endings = malloc((log_format->u.string->len +3) * sizeof(INT32)); num_states = parse_log_format(log_format->u.string, state_list, field_endings, save_field_num); if(num_states < 1) { free(state_list); free(save_field_num); free(field_endings); Pike_error("UltraLog.ultraparse(): Failed to parse log format.\n"); } fd_lseek(f, offs0, SEEK_SET); read_buf = malloc(READ_BLOCK_SIZE+1); buf = malloc(MAX_LINE_LEN+2); #ifdef BROKEN_LINE_DEBUG broken_line = malloc(MAX_LINE_LEN*10); #endif MEMSET(hits_per_hour, 0, sizeof(hits_per_hour)); MEMSET(hosts_per_hour, 0, sizeof(hosts_per_hour)); MEMSET(session_length, 0, sizeof(session_length)); MEMSET(pages_per_hour, 0, sizeof(pages_per_hour)); MEMSET(sessions_per_hour, 0, sizeof(sessions_per_hour)); MEMSET(kb_per_hour, 0, sizeof(kb_per_hour)); /*url_sval.u.type = TYPE_STRING;*/ BUFSET(0); field_position = bufpos; buf_points[0] = buf_points[1] = buf_points[2] = buf_points[3] = buf_points[4] = buf_points[5] = buf_points[6] = buf_points[7] = buf_points[8] = buf_points[9] = buf_points[10] = buf_points[11] = buf_points[12] = buf_points[13] = buf_points[14] = buf_points[15] = 0; while(1) { /* THREADS_ALLOW();*/ do { len = fd_read(f, read_buf, READ_BLOCK_SIZE); } while(len < 0 && errno == EINTR); /* THREADS_DISALLOW();*/ if(len <= 0) break; /* nothing more to read or error. */ offs0 += len; char_pointer = read_buf+len - 1; while(len--) { c = char_pointer[-len]; cls = char_class[c]; #if 0 fprintf(stdout, "DFA(%d:%d): '%c' (%d) ", state, state_pos, c, (int)c); switch(cls) { case CLS_WSPACE: fprintf(stdout, "CLS_WSPACE\n"); break; case CLS_CRLF: fprintf(stdout, "CLS_CRLF\n"); break; case CLS_TOKEN: fprintf(stdout, "CLS_TOKEN\n"); break; case CLS_DIGIT: fprintf(stdout, "CLS_DIGIT\n"); break; case CLS_QUOTE: fprintf(stdout, "CLS_QUOTE\n"); break; case CLS_LBRACK: fprintf(stdout, "CLS_LBRACK\n"); break; case CLS_RBRACK: fprintf(stdout, "CLS_RBRACK\n"); break; case CLS_SLASH: fprintf(stdout, "CLS_SLASH\n"); break; case CLS_COLON: fprintf(stdout, "CLS_COLON\n"); break; case CLS_HYPHEN: fprintf(stdout, "CLS_HYPHEN/CLS_MINUS\n"); break; case CLS_PLUS: fprintf(stdout, "CLS_PLUS\n"); break; default: fprintf(stdout, "??? %d ???\n", cls); } #endif #ifdef BROKEN_LINE_DEBUG broken_line[broken_line_pos++] = c; #endif if(cls == field_endings[state_pos]) { /* Field is done. Nullify. */ process_field: /* printf("Processing field %d of %d\n", state_pos, num_states);*/ switch(save_field_num[state_pos]) { case DATE: case HOUR: case MINUTE: case UP_SEC: case CODE: /* BUFSET(0);*/ tmpinteger = 0; for(v = field_position; v < bufpos; v++) { if(char_class[buf[v]] == CLS_DIGIT) tmpinteger = tmpinteger*10 + (buf[v]&0xf); else { goto skip; } } BUFPOINT = tmpinteger; break; case YEAR: tmpinteger = 0; for(v = field_position; v < bufpos; v++) { if(char_class[buf[v]] == CLS_DIGIT) tmpinteger = tmpinteger*10 + (buf[v]&0xf); else { goto skip; } } if(tmpinteger < 100) { if(tmpinteger < 60) tmpinteger += 2000; else tmpinteger += 1900; } BUFPOINT = tmpinteger; break; case BYTES: v = field_position; switch(char_class[buf[v++]]) { case CLS_QUESTION: case CLS_HYPHEN: if(v == bufpos) tmpinteger = 0; else { goto skip; } break; case CLS_DIGIT: tmpinteger = (buf[field_position]&0xf); for(; v < bufpos; v++) { if(char_class[buf[v]] == CLS_DIGIT) tmpinteger = tmpinteger*10 + (buf[v]&0xf); else { goto skip; } } /* printf("Digit: %d\n", tmpinteger);*/ break; default: goto skip; } BUFPOINT = tmpinteger; /* bufpos++;*/ break; case MONTH: /* Month */ /* BUFSET(0);*/ /* field_buf = buf + field_positions[state_pos];*/ switch(bufpos - field_position) { case 2: tmpinteger = 0; for(v = field_position; v < bufpos; v++) { if(char_class[buf[v]] == CLS_DIGIT) tmpinteger = tmpinteger*10 + (buf[v]&0xf); else { goto skip; } } break; case 3: switch(((buf[field_position]|0x20)<<16)|((buf[field_position+1]|0x20)<<8)| (buf[field_position+2]|0x20)) { case ('j'<<16)|('a'<<8)|'n': tmpinteger = 1; break; case ('f'<<16)|('e'<<8)|'b': tmpinteger = 2; break; case ('m'<<16)|('a'<<8)|'r': tmpinteger = 3; break; case ('a'<<16)|('p'<<8)|'r': tmpinteger = 4; break; case ('m'<<16)|('a'<<8)|'y': tmpinteger = 5; break; case ('j'<<16)|('u'<<8)|'n': tmpinteger = 6; break; case ('j'<<16)|('u'<<8)|'l': tmpinteger = 7; break; case ('a'<<16)|('u'<<8)|'g': tmpinteger = 8; break; case ('s'<<16)|('e'<<8)|'p': tmpinteger = 9; break; case ('o'<<16)|('c'<<8)|'t': tmpinteger = 10; break; case ('n'<<16)|('o'<<8)|'v': tmpinteger = 11; break; case ('d'<<16)|('e'<<8)|'c': tmpinteger = 12; break; } break; default: goto skip; } /*printf("Month: %0d\n", mm);*/ if(tmpinteger < 1 || tmpinteger > 12) goto skip; /* Broken Month */ BUFPOINT = tmpinteger; /* bufpos++;*/ break; case ADDR: case REFER: case AGENT: case TZ: case METHOD: case URL: case RFC: case PROTO: BUFSET(0); SETPOINT(); /* printf("Field %d, pos %d, %s\n", save_field_num[state_pos],BUFPOINT,*/ /* buf + BUFPOINT); */ break; } state_pos++; field_position = bufpos; if(cls != CLS_CRLF) continue; } else if(cls != CLS_CRLF) { BUFSET(c); continue; } else { /* printf("Processing last field (%d).\n", state_pos);*/ goto process_field; /* End of line - process what we got */ } /* printf("%d %d\n", state_pos, num_states);*/ /* buf_points[8] = buf_points[9] = buf_points[10] = buf_points[11] = buf;*/ /* buf_points[12] = buf_points[13] = buf_points[14] = buf_points[15] = buf;*/ #if 0 if(!((lines+broken_lines)%100000)) { push_int(lines+broken_lines); push_int((int)((float)offs0/1024.0/1024.0)); apply_svalue(statfun, 2); pop_stack(); /*printf("%5dk lines, %5d MB\n", lines/1000, (int)((float)offs0/1024.0/1024.0));*/ } #endif if(state_pos < num_states) { #ifdef BROKEN_LINE_DEBUG broken_line[broken_line_pos] = 0; printf("too few states (pos=%d): %s\n", state_pos, broken_line); #endif broken_lines++; goto ok; } #define yy buf_points[YEAR] #define mm buf_points[MONTH] #define dd buf_points[DATE] #define h buf_points[HOUR] #define m buf_points[MINUTE] #define s buf_points[UP_SEC] #define v buf_points[CODE] #define bytes buf_points[BYTES] this_date = (yy*10000) + (mm*100) + dd; if(!this_date) { broken_lines++; goto ok; } #if 1 if(!last_date) { /* First loop w/o a value.*/ last_date = this_date; last_hour = h; } else { if(last_hour != h || last_date != this_date) { pages_per_hour[last_hour] += hourly_page_hits(hits20x, pages, hits, pagexts->u.multiset, 200); /* pages_per_hour[last_hour] +=*/ /* hourly_page_hits(hits304, pages, hits, pagexts->u.multiset, 300);*/ /* printf("%5d %5d for %d %02d:00\n",*/ /* pages_per_hour[last_hour], hits_per_hour[last_hour],*/ /*last_date, last_hour);*/ if(m_sizeof(session_start)) { summarize_sessions(last_hour, sessions_per_hour, session_length, session_start, session_end); free_mapping(session_start); free_mapping(session_end); session_start = allocate_mapping(1); session_end = allocate_mapping(1); } hosts_per_hour[last_hour] += m_sizeof(sites); do_map_addition(hosts, sites); free_mapping(sites); sites = allocate_mapping(100); last_hour = h; free_mapping(hits20x); /* Reset this one */ /* free_mapping(hits304); Reset this one */ /* hits304 = allocate_mapping(2);*/ hits20x = allocate_mapping(2); } #if 1 if(last_date != this_date) { /* printf("%d %d\n", last_date, this_date);*/ tmpdest = allocate_mapping(1); summarize_refsites(refsites, referrers, tmpdest); free_mapping(referrers); referrers = tmpdest; tmpdest = allocate_mapping(1); clean_refto(referredto, tmpdest, pagexts->u.multiset); free_mapping(referredto); referredto = tmpdest; summarize_directories(directories, pages); summarize_directories(directories, hits); tmpdest = allocate_mapping(1); http_decode_mapping(user_agents, tmpdest); free_mapping(user_agents); user_agents = tmpdest; tmpdest = allocate_mapping(1); summarize_hosts(hosts, domains, topdomains, tmpdest); free_mapping(hosts); hosts = tmpdest; #if 1 push_int(last_date / 10000); push_int((last_date % 10000)/100); push_int((last_date % 10000)%100); push_mapping(pages); push_mapping(hits); push_mapping(hits302); push_mapping(hits_per_error); push_mapping(error_urls); push_mapping(error_refs); push_mapping(referredto); push_mapping(refsites); push_mapping(referrers); push_mapping(directories); push_mapping(user_agents); push_mapping(hosts); push_mapping(domains); push_mapping(topdomains); for(i = 0; i < 24; i++) { push_int(sessions_per_hour[i]); } f_aggregate(24); for(i = 0; i < 24; i++) { push_int(hits_per_hour[i]); hits_per_hour[i] = 0; } f_aggregate(24); for(i = 0; i < 24; i++) { push_int(pages_per_hour[i]); pages_per_hour[i] = 0; } f_aggregate(24); for(i = 0; i < 24; i++) { /* KB per hour.*/ push_float(kb_per_hour[i]); kb_per_hour[i] = 0.0; } f_aggregate(24); for(i = 0; i < 24; i++) { push_float(sessions_per_hour[i] ? ((float)session_length[i] / (float)sessions_per_hour[i]) / 60.0 : 0.0); sessions_per_hour[i] = 0; session_length[i] = 0; } f_aggregate(24); for(i = 0; i < 24; i++) { push_int(hosts_per_hour[i]); hosts_per_hour[i] = 0; } f_aggregate(24); apply_svalue(daily, 23); pop_stack(); #else free_mapping(error_refs); free_mapping(referredto); free_mapping(refsites); free_mapping(directories); free_mapping(error_urls); free_mapping(hits); free_mapping(hits_per_error); free_mapping(pages); free_mapping(hosts); free_mapping(domains); free_mapping(topdomains); free_mapping(referrers); free_mapping(hits302); #endif user_agents = allocate_mapping(10); hits302 = allocate_mapping(1); hits_per_error = allocate_mapping(10); error_urls = allocate_mapping(10); error_refs = allocate_mapping(10); directories = allocate_mapping(20); referrers = allocate_mapping(1); referredto = allocate_mapping(1); refsites = allocate_mapping(1); pages = allocate_mapping(1); hits = allocate_mapping(1); sites = allocate_mapping(1); hosts = allocate_mapping(1); domains = allocate_mapping(1); topdomains = allocate_mapping(1); last_date = this_date; } #endif } #endif #if 1 process_session(buf+buf_points[ADDR], h*3600+m*60+s, h, sessions_per_hour, session_length, session_start, session_end, sites); url_str = make_shared_binary_string((char *)(buf + buf_points[URL]), strlen((char *)(buf + buf_points[URL]))); #if 1 switch(v) { /* Do error-code specific logging. Error urls that are specially treated do not include auth required, service unavailable etc. They are only included in the return code summary. */ case 200: case 201: case 202: case 203: case 204: case 205: case 206: case 207: case 304: mapaddstr(hits20x, url_str); DO_REFERRER(); break; case 300: case 301: case 302: case 303: case 305: mapaddstr(hits302, url_str); DO_REFERRER(); break; case 400: case 404: case 405: case 406: case 408: case 409: case 410: case 411: case 412: case 413: case 414: case 415: case 416: case 500: case 501: DO_ERREF(); map2addint(error_urls, v, url_str); break; } /*rfc_str = http_decode_string(buf + buf_points[RFC]);*/ /*hst_str = make_shared_binary_string(buf, strlen(buf));*/ #endif free_string(url_str); mapaddint(hits_per_error, v); kb_per_hour[h] += (float)bytes / 1024.0; hits_per_hour[h]++; /*#endif*/ if(strlen((char *)(buf + buf_points[AGENT]))>1) { /* Got User Agent */ tmpagent = make_shared_string((char *)(buf + buf_points[AGENT])); mapaddstr(user_agents, tmpagent); free_string(tmpagent); } #endif lines++; #if 0 printf("%s %s %s\n%s %s %s\n%04d-%02d-%02d %02d:%02d:%02d \n%d %d\n", buf + buf_points[ADDR], buf + buf_points[REFER], buf + buf_points[ RFC ], buf + buf_points[METHOD], buf + buf_points[ URL ], buf + buf_points[PROTO], yy, mm, dd, h, m, s, v, bytes); /* if(lines > 10) exit(0);*/ #endif ok: gotdate = /* v = bytes =h = m = s = tz = tzs = dd = mm = yy = */ buf_points[0] = buf_points[1] = buf_points[2] = buf_points[3] = buf_points[4] = buf_points[5] = buf_points[6] = buf_points[7] = /*buf_points[8] = buf_points[9] = buf_points[10] =*/ buf_points[11] = buf_points[12] = buf_points[13] = buf_points[14] = buf_points[15] = bufpos = state_pos = 0; field_position = 1; #ifdef BROKEN_LINE_DEBUG broken_line_pos = 0; #endif BUFSET(0); } } cleanup: free(save_field_num); free(state_list); free(field_endings); free(buf); push_int(lines); push_int((int)((float)offs0 / 1024.0/1024.0)); push_int(1); apply_svalue(statfun, 3); pop_stack(); free(read_buf); #ifdef BROKEN_LINE_DEBUG free(broken_line); #endif if(my_fd) /* If my_fd == 0, the second argument was an object and thus we don't * want to free it. */ fd_close(f); /* push_int(offs0); */ /* printf("Done: %d %d %d ", yy, mm, dd);*/ if(yy && mm && dd) { /* printf("\nLast Summary for %d-%02d-%02d %02d:%02d\n", yy, mm, dd, h, m);*/ pages_per_hour[last_hour] += hourly_page_hits(hits20x, pages, hits, pagexts->u.multiset, 200); if(m_sizeof(session_start)) { summarize_sessions(last_hour, sessions_per_hour, session_length, session_start, session_end); } hosts_per_hour[last_hour] += m_sizeof(sites); do_map_addition(hosts, sites); free_mapping(sites); tmpdest = allocate_mapping(1); summarize_refsites(refsites, referrers, tmpdest); free_mapping(referrers); referrers = tmpdest; summarize_directories(directories, pages); summarize_directories(directories, hits); tmpdest = allocate_mapping(1); clean_refto(referredto, tmpdest, pagexts->u.multiset); free_mapping(referredto); referredto = tmpdest; tmpdest = allocate_mapping(1); http_decode_mapping(user_agents, tmpdest); free_mapping(user_agents); user_agents = tmpdest; tmpdest = allocate_mapping(1); summarize_hosts(hosts, domains, topdomains, tmpdest); free_mapping(hosts); hosts = tmpdest; push_int(yy); push_int(mm); push_int(dd); push_mapping(pages); push_mapping(hits); push_mapping(hits302); push_mapping(hits_per_error); push_mapping(error_urls); push_mapping(error_refs); push_mapping(referredto); push_mapping(refsites); push_mapping(referrers); push_mapping(directories); push_mapping(user_agents); push_mapping(hosts); push_mapping(domains); push_mapping(topdomains); for(i = 0; i < 24; i++) { push_int(sessions_per_hour[i]); } f_aggregate(24); for(i = 0; i < 24; i++) { push_int(hits_per_hour[i]); } f_aggregate(24); for(i = 0; i < 24; i++) { push_int(pages_per_hour[i]); } f_aggregate(24); for(i = 0; i < 24; i++) { push_float(kb_per_hour[i]); } f_aggregate(24); for(i = 0; i < 24; i++) { push_float(sessions_per_hour[i] ? ((float)session_length[i] / (float)sessions_per_hour[i]) / 60.0 : 0.0); } f_aggregate(24); for(i = 0; i < 24; i++) { push_int(hosts_per_hour[i]); hosts_per_hour[i] = 0; } f_aggregate(24); apply_svalue(daily, 23); pop_stack(); } else { free_mapping(error_refs); free_mapping(referredto); free_mapping(refsites); free_mapping(directories); free_mapping(error_urls); free_mapping(hits); free_mapping(hits_per_error); free_mapping(pages); free_mapping(referrers); free_mapping(hits302); free_mapping(user_agents); free_mapping(hosts); free_mapping(domains); free_mapping(topdomains); } free_mapping(hits20x); free_mapping(session_start); free_mapping(session_end); /* free_mapping(hits30x); */ printf("\nTotal lines: %d, broken lines: %d, mapping lookups: %d\n\n", lines, broken_lines, lmu); fflush(stdout); pop_n_elems(args); push_int(offs0); return; skip: broken_lines++; while(1) { while(len--) { #ifdef BROKEN_LINE_DEBUG broken_line[broken_line_pos] = char_pointer[-len]; #endif if(char_class[char_pointer[-len]] == CLS_CRLF) { #ifdef BROKEN_LINE_DEBUG broken_line[broken_line_pos] = 0; printf("Broken Line (pos=%d): %s\n", state_pos, broken_line); #endif goto ok; } } do { len = fd_read(f, read_buf, READ_BLOCK_SIZE); } while(len < 0 && errno == EINTR); if(len <= 0) break; /* nothing more to read. */ offs0 += len; char_pointer = read_buf+len - 1; } goto cleanup; }
bool run(struct context *context, struct byte_array *program, struct map *env, bool in_context) { null_check(context); null_check(program); program = byte_array_copy(program); program->current = program->data; struct program_state *state = NULL; enum Opcode inst = VM_NIL; if (context->runtime) { if (in_context) { if (!state) state = (struct program_state*)stack_peek(context->program_stack, 0); env = state->named_variables; // use the caller's variable set in the new state } else state = program_state_new(context, env); } while (program->current < program->data + program->length) { inst = (enum Opcode)*program->current; bool really = inst & VM_RLY; inst &= ~VM_RLY; #ifdef DEBUG display_program_counter(context, program); #endif program->current++; // increment past the instruction int32_t pc_offset = 0; switch (inst) { case VM_COM: case VM_ITR: if (iterate(context, inst, state, program)) goto done; break; case VM_RET: if (ret(context, program)) goto done; break; case VM_TRO: if (tro(context)) goto done; break; case VM_TRY: if (vm_trycatch(context, program)) goto done; break; case VM_EQU: case VM_MUL: case VM_DIV: case VM_ADD: case VM_SUB: case VM_NEQ: case VM_GTN: case VM_LTN: case VM_GRQ: case VM_LEQ: case VM_BND: case VM_BOR: case VM_MOD: case VM_XOR: case VM_INV: case VM_RSF: case VM_LSF: binary_op(context, inst); break; case VM_ORR: case VM_AND: pc_offset = boolean_op(context, program, inst); break; case VM_NEG: case VM_NOT: unary_op(context, inst); break; case VM_SRC: src(context, inst, program); break; case VM_DST: dst(context, really); break; case VM_STX: case VM_SET: set(context, inst, state, program); break; case VM_JMP: pc_offset = jump(context, program); break; case VM_IFF: pc_offset = iff(context, program); break; case VM_CAL: func_call(context, inst, program, NULL); break; case VM_LST: push_list(context, program); break; case VM_MAP: push_map(context, program); break; case VM_NIL: push_nil(context); break; case VM_INT: push_int(context, program); break; case VM_FLT: push_float(context, program); break; case VM_BUL: push_bool(context, program); break; case VM_STR: push_str(context, program); break; case VM_VAR: push_var(context, program); break; case VM_FNC: push_fnc(context, program); break; case VM_GET: list_get(context, really); break; case VM_PTX: case VM_PUT: list_put(context, inst, really); break; case VM_MET: method(context, program, really); break; default: vm_exit_message(context, ERROR_OPCODE); return false; } program->current += pc_offset; } if (!context->runtime) return false; done: if (!in_context) stack_pop(context->program_stack); return inst == VM_RET; }
std::vector<unsigned char> CEntityWriter::SaveEntity(CSerializationEntity& pRoot) { std::vector<unsigned char> data; // save mesh information. long magic = 0; // static mesh is being saved. if (pRoot.m_Bones.size() > 0 ) { magic = 1; // animated mesh is being saved. } push_long(data, magic); push_matrix(data, pRoot.m_Pos); assert(pRoot.m_EntityName.size()> 0); const char * cStr = pRoot.m_EntityName.c_str(); push_string(data, pRoot.m_EntityName); push_float(data, pRoot.globalScale); // save mesh information std::vector<CRenderable_Export > v = pRoot.m_ExportShapes; long num_renderables = v.size(); push_long(data, num_renderables); for (int i= 0 ; i < num_renderables ; i ++ ) { const CRenderable_Export& pRenderable = v[i]; push_long(data, pRenderable.m_UsedBones.size() ); append(pRenderable.m_UsedBones, data); push_long(data, pRenderable.m_Geometries.size() ); for (int geomIndex = 0; geomIndex < pRenderable.m_Geometries.size() ; geomIndex ++ ) { const CRenderable_AbstractGeometry& pGeometry = pRenderable.m_Geometries[geomIndex]; push_long(data, pGeometry.m_VertexBuffers.size()); for (unsigned int j = 0 ; j < pGeometry.m_VertexBuffers.size() ; j ++ ) { std::vector<unsigned char> vertexes; const CRenderable_AbstractVertexBuffer& pBuffer = pGeometry.m_VertexBuffers[j]; vertexes = SaveVertexes(pBuffer); long size = vertexes.size(); push_long(data, size); append(vertexes, data); } push_long(data, pGeometry.m_IndexBuffers.size()); for (unsigned int j = 0 ; j < pGeometry.m_IndexBuffers.size() ; j ++ ) { std::vector<unsigned char> indexes; const CRenderable_AbstractIndexBuffer& pIndex = pGeometry.m_IndexBuffers[j]; indexes = SaveIndexes(pIndex); long size = indexes.size(); push_long(data, size); append(indexes, data); } push_long(data, pGeometry.m_RenderCalls.size()); for (unsigned int j = 0 ; j < pGeometry.m_RenderCalls.size() ; j ++ ) { std::vector<unsigned char> calls; const CRenderable_AbstractRenderCall& pCall = pGeometry.m_RenderCalls[j]; calls = SaveRenderCalls(pCall); long size = calls.size(); push_long(data, size); append(calls, data); } } push_long(data, pRenderable.m_ExportMaterial.m_Name.size()); for (unsigned int i = 0 ; i < pRenderable.m_ExportMaterial.m_Name.size() ; i ++ ) { data.push_back(pRenderable.m_ExportMaterial.m_Name[i]); } } // save static bone information push_long(data, pRoot.m_Bones.size()); std::vector<CBoneSerialized>& bonez = pRoot.m_Bones; std::vector<CBoneSerialized>::iterator it = bonez.begin(); while (it != pRoot.m_Bones.end()) { /* CBoneSerialized* m_pParent; std::list<CBoneSerialized*> m_ChildrenPtr; CMatrix m_InitialMatrix; CMatrix m_InvBoneSkinMatrix; CMatrix m_FinalMatrix; CVector m_Pos; long m_Index; std::string m_ID; std::list<CMatrix> m_AnimationMatrices; */ long parentIndex = -1; if ((*it).m_pParent >= 0) { parentIndex = bonez[(*it).m_pParent].m_Index; } push_long(data, parentIndex); std::vector<unsigned char> matrixVector; matrixVector.resize(sizeof(CMatrix)); memcpy(&matrixVector[0] , &(*it).m_InitialMatrix, sizeof(CMatrix)); data.insert(data.end() , matrixVector.begin(), matrixVector.end()); memcpy(&matrixVector[0] ,&(*it).m_InvBoneSkinMatrix, sizeof(CMatrix)); data.insert(data.end() , matrixVector.begin(), matrixVector.end()); push_long(data,(*it).m_Index); push_long(data,(*it).m_ID.size()); assert( (*it).m_ID.size() < 100 ) ; CBoneSerialized& pBone = (*it); data.insert(data.end(), pBone.m_ID.begin(), pBone.m_ID.end()); //data.insert(data.end() ,(*it)->m_ID.begin() , (*it)->m_ID.end()); /*push_long(data, (*it)->m_MatrixMapping.size() ); for (int i = 0 ; i < (*it)->m_MatrixMapping.size() ; i ++ ) { data.push_back( (*it)->m_MatrixMapping[i].first ); data.push_back( (*it)->m_MatrixMapping[i].second ); }*/ //PrintBone(*it); it++; } return data; }
static void f_glGet(INT32 args) { INT32 arg1; GLint i, i2[4]; GLboolean b[4]; GLfloat f[16]; check_all_args("glGet", args, BIT_INT, 0); arg1=Pike_sp[0-args].u.integer; pop_n_elems(args); switch(arg1) { case GL_ACCUM_ALPHA_BITS: case GL_ACCUM_BLUE_BITS: case GL_ACCUM_GREEN_BITS: case GL_ACCUM_RED_BITS: case GL_ALPHA_BITS: case GL_ALPHA_TEST_FUNC: case GL_ATTRIB_STACK_DEPTH: case GL_AUX_BUFFERS: case GL_BLEND_DST: case GL_BLEND_SRC: case GL_BLUE_BITS: case GL_CLIENT_ATTRIB_STACK_DEPTH: case GL_COLOR_ARRAY_SIZE: case GL_COLOR_ARRAY_STRIDE: case GL_COLOR_ARRAY_TYPE: case GL_COLOR_MATERIAL_FACE: case GL_COLOR_MATERIAL_PARAMETER: case GL_CULL_FACE_MODE: case GL_DEPTH_BITS: case GL_DEPTH_FUNC: case GL_DRAW_BUFFER: case GL_EDGE_FLAG_ARRAY_STRIDE: case GL_FOG_HINT: case GL_FOG_MODE: case GL_FRONT_FACE: case GL_GREEN_BITS: case GL_INDEX_ARRAY_STRIDE: case GL_INDEX_ARRAY_TYPE: case GL_INDEX_BITS: case GL_INDEX_OFFSET: case GL_INDEX_SHIFT: case GL_INDEX_WRITEMASK: case GL_LINE_SMOOTH_HINT: case GL_LINE_STIPPLE_PATTERN: case GL_LINE_STIPPLE_REPEAT: case GL_LIST_BASE: case GL_LIST_INDEX: case GL_LIST_MODE: case GL_LOGIC_OP_MODE: case GL_MAP1_GRID_SEGMENTS: case GL_MATRIX_MODE: case GL_MAX_CLIENT_ATTRIB_STACK_DEPTH: case GL_MAX_ATTRIB_STACK_DEPTH: case GL_MAX_CLIP_PLANES: case GL_MAX_EVAL_ORDER: case GL_MAX_LIGHTS: case GL_MAX_LIST_NESTING: case GL_MAX_MODELVIEW_STACK_DEPTH: case GL_MAX_NAME_STACK_DEPTH: case GL_MAX_PIXEL_MAP_TABLE: case GL_MAX_PROJECTION_STACK_DEPTH: case GL_MAX_TEXTURE_SIZE: case GL_MAX_TEXTURE_STACK_DEPTH: case GL_MODELVIEW_STACK_DEPTH: case GL_NAME_STACK_DEPTH: case GL_NORMAL_ARRAY_STRIDE: case GL_NORMAL_ARRAY_TYPE: case GL_PACK_ALIGNMENT: case GL_PACK_ROW_LENGTH: case GL_PACK_SKIP_PIXELS: case GL_PACK_SKIP_ROWS: case GL_PERSPECTIVE_CORRECTION_HINT: case GL_PIXEL_MAP_A_TO_A_SIZE: case GL_PIXEL_MAP_B_TO_B_SIZE: case GL_PIXEL_MAP_G_TO_G_SIZE: case GL_PIXEL_MAP_I_TO_A_SIZE: case GL_PIXEL_MAP_I_TO_B_SIZE: case GL_PIXEL_MAP_I_TO_G_SIZE: case GL_PIXEL_MAP_I_TO_I_SIZE: case GL_PIXEL_MAP_I_TO_R_SIZE: case GL_PIXEL_MAP_R_TO_R_SIZE: case GL_PIXEL_MAP_S_TO_S_SIZE: case GL_POINT_SMOOTH_HINT: case GL_POLYGON_MODE: case GL_POLYGON_SMOOTH_HINT: case GL_PROJECTION_STACK_DEPTH: case GL_READ_BUFFER: case GL_RED_BITS: case GL_RENDER_MODE: case GL_SHADE_MODEL: case GL_STENCIL_BITS: case GL_STENCIL_CLEAR_VALUE: case GL_STENCIL_FAIL: case GL_STENCIL_FUNC: case GL_STENCIL_PASS_DEPTH_FAIL: case GL_STENCIL_PASS_DEPTH_PASS: case GL_STENCIL_REF: case GL_STENCIL_VALUE_MASK: case GL_STENCIL_WRITEMASK: case GL_SUBPIXEL_BITS: case GL_TEXTURE_BINDING_1D: case GL_TEXTURE_BINDING_2D: case GL_TEXTURE_COORD_ARRAY_SIZE: case GL_TEXTURE_COORD_ARRAY_STRIDE: case GL_TEXTURE_COORD_ARRAY_TYPE: case GL_TEXTURE_STACK_DEPTH: case GL_UNPACK_ALIGNMENT: case GL_UNPACK_ROW_LENGTH: case GL_UNPACK_SKIP_PIXELS: case GL_UNPACK_SKIP_ROWS: case GL_VERTEX_ARRAY_SIZE: case GL_VERTEX_ARRAY_STRIDE: case GL_VERTEX_ARRAY_TYPE: glGetIntegerv(arg1, &i); push_int(i); break; case GL_MAP2_GRID_SEGMENTS: case GL_MAX_VIEWPORT_DIMS: glGetIntegerv(arg1, i2); push_int(i2[0]); push_int(i2[1]); f_aggregate(2); break; case GL_SCISSOR_BOX: case GL_VIEWPORT: glGetIntegerv(arg1, i2); push_int(i2[0]); push_int(i2[1]); push_int(i2[2]); push_int(i2[3]); f_aggregate(4); break; case GL_ALPHA_TEST: case GL_AUTO_NORMAL: case GL_BLEND: case GL_CLIP_PLANE0: case GL_CLIP_PLANE1: case GL_CLIP_PLANE2: case GL_CLIP_PLANE3: case GL_CLIP_PLANE4: case GL_CLIP_PLANE5: case GL_COLOR_ARRAY: case GL_COLOR_LOGIC_OP: case GL_COLOR_MATERIAL: case GL_CULL_FACE: case GL_CURRENT_RASTER_POSITION_VALID: case GL_DEPTH_TEST: case GL_DEPTH_WRITEMASK: case GL_DITHER: case GL_DOUBLEBUFFER: case GL_EDGE_FLAG: case GL_EDGE_FLAG_ARRAY: case GL_FOG: case GL_INDEX_ARRAY: case GL_INDEX_LOGIC_OP: case GL_INDEX_MODE: case GL_LIGHT0: case GL_LIGHT1: case GL_LIGHT2: case GL_LIGHT3: case GL_LIGHT4: case GL_LIGHT5: case GL_LIGHT6: case GL_LIGHT7: case GL_LIGHTING: case GL_LIGHT_MODEL_LOCAL_VIEWER: case GL_LIGHT_MODEL_TWO_SIDE: case GL_LINE_SMOOTH: case GL_LINE_STIPPLE: case GL_MAP1_COLOR_4: case GL_MAP1_INDEX: case GL_MAP1_NORMAL: case GL_MAP1_TEXTURE_COORD_1: case GL_MAP1_TEXTURE_COORD_2: case GL_MAP1_TEXTURE_COORD_3: case GL_MAP1_TEXTURE_COORD_4: case GL_MAP1_VERTEX_3: case GL_MAP1_VERTEX_4: case GL_MAP2_COLOR_4: case GL_MAP2_INDEX: case GL_MAP2_NORMAL: case GL_MAP2_TEXTURE_COORD_1: case GL_MAP2_TEXTURE_COORD_2: case GL_MAP2_TEXTURE_COORD_3: case GL_MAP2_TEXTURE_COORD_4: case GL_MAP2_VERTEX_3: case GL_MAP2_VERTEX_4: case GL_MAP_COLOR: case GL_MAP_STENCIL: case GL_NORMAL_ARRAY: case GL_NORMALIZE: case GL_PACK_LSB_FIRST: case GL_PACK_SWAP_BYTES: case GL_POINT_SMOOTH: case GL_POLYGON_OFFSET_FILL: case GL_POLYGON_OFFSET_LINE: case GL_POLYGON_OFFSET_POINT: case GL_POLYGON_SMOOTH: case GL_POLYGON_STIPPLE: case GL_RGBA_MODE: case GL_SCISSOR_TEST: case GL_STENCIL_TEST: case GL_STEREO: case GL_TEXTURE_1D: case GL_TEXTURE_2D: case GL_TEXTURE_COORD_ARRAY: case GL_TEXTURE_GEN_Q: case GL_TEXTURE_GEN_R: case GL_TEXTURE_GEN_S: case GL_TEXTURE_GEN_T: case GL_UNPACK_LSB_FIRST: case GL_UNPACK_SWAP_BYTES: case GL_VERTEX_ARRAY: glGetBooleanv(arg1, b); push_int(b[0]); break; case GL_ALPHA_BIAS: case GL_ALPHA_SCALE: case GL_ALPHA_TEST_REF: case GL_BLUE_BIAS: case GL_BLUE_SCALE: case GL_CURRENT_INDEX: case GL_CURRENT_RASTER_DISTANCE: case GL_CURRENT_RASTER_INDEX: case GL_DEPTH_BIAS: case GL_DEPTH_CLEAR_VALUE: case GL_DEPTH_SCALE: case GL_FOG_DENSITY: case GL_FOG_END: case GL_FOG_INDEX: case GL_FOG_START: case GL_GREEN_BIAS: case GL_GREEN_SCALE: case GL_INDEX_CLEAR_VALUE: case GL_LINE_WIDTH: case GL_LINE_WIDTH_GRANULARITY: case GL_POINT_SIZE: case GL_POINT_SIZE_GRANULARITY: case GL_POLYGON_OFFSET_FACTOR: case GL_POLYGON_OFFSET_UNITS: case GL_RED_BIAS: case GL_RED_SCALE: case GL_ZOOM_X: case GL_ZOOM_Y: glGetFloatv(arg1, f); push_float(f[0]); break; case GL_DEPTH_RANGE: case GL_LINE_WIDTH_RANGE: case GL_MAP1_GRID_DOMAIN: case GL_POINT_SIZE_RANGE: glGetFloatv(arg1, f); push_float(f[0]); push_float(f[1]); f_aggregate(2); break; case GL_CURRENT_NORMAL: glGetFloatv(arg1, f); push_float(f[0]); push_float(f[1]); push_float(f[2]); f_aggregate(3); break; case GL_ACCUM_CLEAR_VALUE: case GL_COLOR_CLEAR_VALUE: case GL_CURRENT_COLOR: case GL_CURRENT_RASTER_COLOR: case GL_CURRENT_RASTER_POSITION: case GL_CURRENT_RASTER_TEXTURE_COORDS: case GL_CURRENT_TEXTURE_COORDS: case GL_FOG_COLOR: case GL_LIGHT_MODEL_AMBIENT: case GL_MAP2_GRID_DOMAIN: glGetFloatv(arg1, f); push_float(f[0]); push_float(f[1]); push_float(f[2]); push_float(f[3]); f_aggregate(4); break; case GL_COLOR_WRITEMASK: glGetBooleanv(arg1, b); push_int(b[0]); push_int(b[1]); push_int(b[2]); push_int(b[3]); f_aggregate(4); break; case GL_MODELVIEW_MATRIX: case GL_PROJECTION_MATRIX: case GL_TEXTURE_MATRIX: glGetFloatv(arg1, f); push_float(f[0]); push_float(f[1]); push_float(f[2]); push_float(f[3]); push_float(f[4]); push_float(f[5]); push_float(f[6]); push_float(f[7]); push_float(f[8]); push_float(f[9]); push_float(f[10]); push_float(f[11]); push_float(f[12]); push_float(f[13]); push_float(f[14]); push_float(f[15]); f_aggregate(16); break; default: Pike_error("glGet: Unsupported parameter name\n"); } }
static void add_normal(float x, float y, float z) { push_float(&normal, x); push_float(&normal, -z); push_float(&normal, y); }
static void add_texcoord(float u, float v) { push_float(&texcoord, u); push_float(&texcoord, 1-v); }
static void add_position(float x, float y, float z) { push_float(&position, x); push_float(&position, -z); push_float(&position, y); }