size_t ASPSOldGen::available_for_contraction() { size_t uncommitted_bytes = virtual_space()->uncommitted_size(); if (uncommitted_bytes != 0) { return uncommitted_bytes; } ParallelScavengeHeap* heap = (ParallelScavengeHeap*)Universe::heap(); const size_t gen_alignment = heap->old_gen_alignment(); PSAdaptiveSizePolicy* policy = heap->size_policy(); const size_t working_size = used_in_bytes() + (size_t) policy->avg_promoted()->padded_average(); const size_t working_aligned = align_size_up(working_size, gen_alignment); const size_t working_or_min = MAX2(working_aligned, min_gen_size()); if (working_or_min > reserved().byte_size()) { // If the used or minimum gen size (aligned up) is greater // than the total reserved size, then the space available // for contraction should (after proper alignment) be 0 return 0; } const size_t max_contraction = reserved().byte_size() - working_or_min; // Use the "increment" fraction instead of the "decrement" fraction // to allow the other gen to expand more aggressively. The // "decrement" fraction is conservative because its intent is to // only reduce the footprint. size_t result = policy->promo_increment_aligned_down(max_contraction); // Also adjust for inter-generational alignment size_t result_aligned = align_size_down(result, gen_alignment); if (PrintAdaptiveSizePolicy && Verbose) { gclog_or_tty->print_cr("\nASPSOldGen::available_for_contraction:" " %d K / 0x%x", result_aligned/K, result_aligned); gclog_or_tty->print_cr(" reserved().byte_size() %d K / 0x%x ", reserved().byte_size()/K, reserved().byte_size()); size_t working_promoted = (size_t) policy->avg_promoted()->padded_average(); gclog_or_tty->print_cr(" padded promoted %d K / 0x%x", working_promoted/K, working_promoted); gclog_or_tty->print_cr(" used %d K / 0x%x", used_in_bytes()/K, used_in_bytes()); gclog_or_tty->print_cr(" min_gen_size() %d K / 0x%x", min_gen_size()/K, min_gen_size()); gclog_or_tty->print_cr(" max_contraction %d K / 0x%x", max_contraction/K, max_contraction); gclog_or_tty->print_cr(" without alignment %d K / 0x%x", policy->promo_increment(max_contraction)/K, policy->promo_increment(max_contraction)); gclog_or_tty->print_cr(" alignment 0x%x", gen_alignment); } assert(result_aligned <= max_contraction, "arithmetic is wrong"); return result_aligned; }
ULONG fmul64(ULONG ahi,ULONG alo,ULONG bhi,ULONG blo, ULONG *desthi,ULONG *destlo,ULONG rnd,ULONG prec) { ULONG g,r,s,flag; FPLONG a,b,res; /* Reserved operand check */ flag = reserved(ahi,alo,bhi,blo,0); if (flag != 0 ) return(flag); flag = (flag<<FLAGWIDTH) | reserved(ahi,alo,bhi,blo,1); if (flag != 0 ) return(flag); if (flag) { *desthi = 0; *destlo = 0; return(flag); } /* Extract fields */ a.sign = BFEXTU(ahi,31,1); b.sign = BFEXTU(bhi,31,1); a.exp = BFEXTU(ahi,20,11); b.exp = BFEXTU(bhi,20,11); a.manthi = BFEXTU(ahi,0,20); b.manthi = BFEXTU(bhi,0,20); a.mantlo = alo; b.mantlo = blo; /* Insert Hidden Bits */ if (a.exp != 0) a.manthi |= 0x00100000; if (b.exp != 0) b.manthi |= 0x00100000; /* Perform Multiplication */ multd(a.sign,a.exp,a.manthi,a.mantlo,b.sign,b.exp,b.manthi,b.mantlo, &res.sign,&res.exp,&res.manthi,&res.mantlo,&s); /* Round */ if (prec != SINGLE) { g = (res.mantlo>>1)&1; r = res.mantlo&1; res.mantlo >>= 2; res.mantlo |= res.manthi<<30; res.manthi >>= 2; flag |= roundd(res.exp,&res.sign,&res.manthi,&res.mantlo,g,r,s,rnd); }
/* This program reads a C program and count the number of reserved words */ int main (int argc, char * argv[]) { FILE * arq; char * reservadas [] = { "auto", "break", "case", "char", "const", "continue", "default", "do", "double", "else", "enum", "extern", "float", "for", "goto", "if", "int", "long", "register", "return", "short", "signed", "sizeof", "static", "struct", "switch", "typedef", "union", "unsigned", "void", "volatile", "while", ""}; int count; char word[1000], *filename; if (argc != 2) { printf ("Use: %s <source C programa filename>\n", argv[0]); return 0; } filename = argv[1]; arq = fopen (filename, "r"); if (arq == NULL) { printf ("File %s could not be found\n", filename); return 0; } count = 0; while (read_word (arq, word) == 1) if (reserved (word, reservadas) == 1) count++; printf ("File %s contains %d reserved words\n", filename, count); fclose (arq); return 0; }
HeapRegion* HeapRegionManager::new_heap_region(uint hrm_index) { G1CollectedHeap* g1h = G1CollectedHeap::heap(); HeapWord* bottom = g1h->bottom_addr_for_region(hrm_index); MemRegion mr(bottom, bottom + HeapRegion::GrainWords); assert(reserved().contains(mr), "invariant"); return g1h->new_heap_region(hrm_index, mr); }
//--------------------------------------------------------------------------- void File_AvsV::Data_Parse() { //Parsing switch (Element_Code) { case 0xB0: video_sequence_start(); break; case 0xB1: video_sequence_end(); break; case 0xB2: user_data_start(); break; case 0xB5: extension_start(); break; case 0xB3: case 0xB6: picture_start(); break; case 0xB7: video_edit(); break; case 0xB4: case 0xB8: reserved(); break; default: if (Element_Code>=0x00 && Element_Code<=0xAF) slice(); else if (Element_Code==0xE0 && Element_Size>=2 && CC2(Buffer+Buffer_Offset)==0x0000) { Trusted=0; //This is surely an extract from MPEG-TS Trusted_IsNot("Unattended element"); } else Trusted_IsNot("Unattended element"); } if (File_Offset+Buffer_Offset+Element_Size==File_Size && Frame_Count>0 && Count_Get(Stream_Video)==0) //Finalize frames in case of there are less than Frame_Count_Valid frames { //No need of more Accept("AVS Video"); Finish("AVS Video"); } }
lexid *lextable::enter(const char *str, int lextype) { int h = hash(str); while (1) { int i = (h & LEXTABLESIZE - 1); lexid *entry = table[i]; if (entry == NULL) { // there is no entry in the lex table // but is it a reserved word in a different case context? if (reserved(str)) { // yes, it is. get the entry in the reserved words table return enter_reserved(str); } else { /* no, it is not. Enter it and return */ table[i] = entry = new lexid(str, lextype); return (entry); } } else if (strcmp(entry->getname(), str) == 0) { return (entry); } else { /* try again */ h = rehash(h); } } }
//--------------------------------------------------------------------------- void File_AvsV::Data_Parse() { //Parsing switch (Element_Code) { case 0xB0: video_sequence_start(); break; case 0xB1: video_sequence_end(); break; case 0xB2: user_data_start(); break; case 0xB5: extension_start(); break; case 0xB3: case 0xB6: picture_start(); break; case 0xB7: video_edit(); break; case 0xB4: case 0xB8: reserved(); break; default: if (Element_Code>=0x00 && Element_Code<=0xAF) slice(); else { if (Frame_Count==0 && Buffer_TotalBytes>Buffer_TotalBytes_FirstSynched_Max) Trusted=0; Trusted_IsNot("Unattended element"); } } if (File_Offset+Buffer_Offset+Element_Size==File_Size && Frame_Count>0 && Count_Get(Stream_Video)==0) //Finalize frames in case of there are less than Frame_Count_Valid frames { //No need of more Accept("AVS Video"); Finish("AVS Video"); } }
// Tortuous route to get here! // m_HotKey looses focus and calls parent (CListCtrl) that calls here void COptionsShortcuts::OnHotKeyKillFocus(const int item, const UINT id, const WORD wVirtualKeyCode, const WORD wModifiers) { CString str(L""); CString cs_warning; MapMenuShortcutsIter iter, inuse_iter; st_MenuShortcut st_mst; st_mst.siVirtKey = wVirtualKeyCode; st_mst.cModifier = wVirtualKeyCode == 0 ? 0 : (unsigned char)wModifiers; // Stop compiler complaining - put this here even if not needed already_inuse inuse(st_mst); if (!CMenuShortcut::IsNormalShortcut(st_mst)) { // Invalid shortcut cs_warning.LoadString(IDS_SHCT_WARNING1); goto set_warning; } str = CMenuShortcut::FormatShortcut(st_mst); if (std::find_if(m_ReservedShortcuts.begin(), m_ReservedShortcuts.end(), reserved(st_mst)) != m_ReservedShortcuts.end()) { // Reserved shortcut ignored cs_warning.Format(IDS_SHCT_WARNING2, str); goto set_warning; } // Check not already in use (ignore if deleting current shortcut) iter = m_MapMenuShortcuts.find(id); if (st_mst.siVirtKey != 0) { inuse_iter = std::find_if(m_MapMenuShortcuts.begin(), m_MapMenuShortcuts.end(), inuse); if (inuse_iter != m_MapMenuShortcuts.end() && inuse_iter->first != iter->first) { // Shortcut in use cs_warning.Format(IDS_SHCT_WARNING3, str, inuse_iter->second.name.c_str()); goto set_warning; } } // Not reserved and not already in use - implement iter->second.siVirtKey = st_mst.siVirtKey; iter->second.cModifier = st_mst.cModifier; m_ShortcutLC.SetItemText(item, 0, str); // SHCT_SHORTCUTKEYS m_ShortcutLC.RedrawItems(item, item); // SHCT_MENUITEMTEXT m_ShortcutLC.SetColumnWidth(0, m_iColWidth); // SHCT_SHORTCUTKEYS m_ShortcutLC.SetColumnWidth(1, LVSCW_AUTOSIZE_USEHEADER); // SHCT_MENUITEMTEXT m_ShortcutLC.UpdateWindow(); return; set_warning: m_stc_warning.SetWindowText(cs_warning); m_stc_warning.ShowWindow(SW_SHOW); }
void Registers<Reg>::release(Reg reg){ assert(descriptors[static_cast<int>(reg)] == retainVariable); descriptors.at(static_cast<int>(reg)) = nullptr; assert(!reserved(reg)); }
void Registers<Reg>::reserve(Reg reg){ assert(!used(reg)); descriptors.at(static_cast<int>(reg)) = retainVariable; assert(reserved(reg)); }
std::shared_ptr<Variable> Registers<Reg>::operator[](Reg reg){ //This method should never be called when the register is not used assert(used(reg)); assert(!reserved(reg)); return descriptors.at(static_cast<int>(reg)); }
TUint8 DISIRouter::ReserveNewDynamicObjId() { // No tracing with mutex #ifdef WITHOUT_WRAPPERS_IN_USE TUint8 firstAllowedObjId = KFirstAllowedObjId; #else TUint8 firstAllowedObjId = KLastKernelChannel; #endif for( TInt i(firstAllowedObjId); i < KMaxAmountOfObjId; i++ ) { if( !iClientTable[ i ] ) { TBool reserved( EFalse ); for( TUint8 j = 0; j < iStaticObjIdTable.Count(); j++ ) { if( j == iStaticObjIdTable[ j ]->iObjId ) { reserved = ETrue; break; } } if( !reserved ) { return i; } } } return KNotInitializedId; }
void URI::addQueryParameter(const std::string& param, const std::string& val) { std::string reserved(RESERVED_QUERY); reserved += "=&"; if (!_query.empty()) _query += '&'; encode(param, reserved, _query); _query += '='; encode(val, reserved, _query); }
char* lex(char* ppg, std::map<std::string,int> &names, PreCompiler_Callback precomp) throw (InterpEx*) { reserved(names); int nextord = names.size(); char* res = new char[strlen(ppg)*6]; //this should suffice, haha. char* toks = res; char* start = ppg; char* pos = ppg; whitespace(ppg); tolower(ppg); debug(std::cout << "lexing...\n";)
void parse_argument_list(){ set_parse_err(argument_number >= MAX_ARGS,EMANYARGS); ignore_spaces(); if(reserved(peek_token())) return; char * arg = malloc(MAX_ARGLEN+1); program_call[programs] .arguments[argument_number] = arg; char c; int i; for(i = 0, c = next_token(); i < MAX_ARGLEN && !reserved(c); i++, c = next_token() ){ arg[i] = c; } set_parse_err(i >= MAX_ARGLEN,EARGLONG); arg[i] = '\0'; argument_number++; ignore_spaces(); switch(c = peek_token()){ case EOS: case '|': break; default: if(!reserved(c)){ parse_argument_list(); }else{ set_parse_err(true,EINVCHAR); } break; } }
void PSOldGen::resize(size_t desired_free_space) { ParallelScavengeHeap* heap = (ParallelScavengeHeap*)Universe::heap(); assert(heap->kind() == CollectedHeap::ParallelScavengeHeap, "Sanity"); const size_t alignment = heap->min_alignment(); const size_t size_before = _virtual_space.committed_size(); size_t new_size = used_in_bytes() + desired_free_space; new_size = align_size_up(new_size, alignment); assert(_max_gen_size == reserved().byte_size(), "max new size problem?"); // Adjust according to our min and max new_size = MAX2(MIN2(new_size, _max_gen_size), _min_gen_size); const size_t current_size = capacity_in_bytes(); if (new_size == current_size) { // No change requested return; } if (new_size > current_size) { size_t change_bytes = new_size - current_size; expand(change_bytes); } else { size_t change_bytes = current_size - new_size; // shrink doesn't grab this lock, expand does. Is that right? MutexLocker x(ExpandHeap_lock); shrink(change_bytes); } if (PrintAdaptiveSizePolicy) { gclog_or_tty->print_cr("AdaptiveSizePolicy::old generation size: " "collection: %d " "(" SIZE_FORMAT ") -> (" SIZE_FORMAT ") ", heap->total_collections(), size_before, _virtual_space.committed_size()); } }
size_t DefNewGeneration::max_capacity() const { const size_t alignment = GenCollectedHeap::heap()->collector_policy()->space_alignment(); const size_t reserved_bytes = reserved().byte_size(); return reserved_bytes - compute_survivor_size(reserved_bytes, alignment); }
/*=========================== * lextok -- lex the next token *=========================*/ static int lextok (PACTX pactx, YYSTYPE * lvalp, INT c, INT t) { INT retval, mul; extern INT Yival; extern FLOAT Yfval; static char tokbuf[512]; /* token buffer */ STRING p = tokbuf; if (t == LETTER) { p = tokbuf; while (is_iden_char(c, t)) { if (p-tokbuf < (int)sizeof(tokbuf) - 3) { *p++ = c; } else { /* token overlong -- ignore end of it */ /* TODO: How can we force a parse error from here ? */ } t = chartype(c = inchar(pactx)); } *p = 0; unreadchar(pactx, c); if (reserved(tokbuf, &retval)) return retval; /* IDEN values have to be passed from yacc.y to free_iden */ *lvalp = (PNODE) strsave(tokbuf); return IDEN; } if (t == '-' || t == DIGIT || t == '.') { BOOLEAN whole = FALSE; BOOLEAN frac = FALSE; FLOAT fdiv; mul = 1; if (t == '-') { t = chartype(c = inchar(pactx)); if (t != '.' && t != DIGIT) { unreadchar(pactx, c); return '-'; } mul = -1; } Yival = 0; while (t == DIGIT) { whole = TRUE; Yival = Yival*10 + c - '0'; t = chartype(c = inchar(pactx)); } if (t != '.') { unreadchar(pactx, c); Yival *= mul; *lvalp = NULL; return ICONS; } t = chartype(c = inchar(pactx)); Yfval = 0.0; fdiv = 1.0; while (t == DIGIT) { frac = TRUE; Yfval = Yfval*10 + c - '0'; fdiv *= 10.; t = chartype(c = inchar(pactx)); } unreadchar(pactx, c); if (!whole && !frac) { unreadchar(pactx, c); if (mul == -1) { unreadchar(pactx, '.'); return '-'; } else return '.'; } Yfval = mul*(Yival + Yfval/fdiv); *lvalp = NULL; return FCONS; } if (c == '"') { INT start_line = pactx->lineno; p = tokbuf; while (TRUE) { while ((c = inchar(pactx)) != EOF && c != '"' && c != '\\') { if (p-tokbuf > sizeof(tokbuf)/sizeof(tokbuf[0]) - 3) { /* Overflowing tokbuf buffer */ /* TODO: (Perry, 2006-06-30) I don't know how to fail gracefully from here inside parser */ char msg[512]; snprintf(msg, sizeof(msg)/sizeof(msg[0]) , _("String constant overflowing internal buffer tokbuf len=%d, file: %s, start line: %ld") , sizeof(tokbuf)/sizeof(tokbuf[0]) , pactx->fullpath , start_line + 1 ); FATAL2(msg); *p = c = 0; } *p++ = c; } if (c == 0 || c == '"') { *p = 0; *lvalp = make_internal_string_node(pactx, tokbuf); return SCONS; } switch (c = inchar(pactx)) { case 'n': *p++ = '\n'; break; case 't': *p++ = '\t'; break; case 'v': *p++ = '\v'; break; case 'r': *p++ = '\r'; break; case 'b': *p++ = '\b'; break; case 'f': *p++ = '\f'; break; case '"': *p++ = '"'; break; case '\\': *p++ = '\\'; break; case EOF: *p = 0; *lvalp = make_internal_string_node(pactx, tokbuf); return SCONS; default: *p++ = c; break; } } } if (c == EOF) return 0; return c; }
void DefNewGeneration::compute_new_size() { // This is called after a gc that includes the following generation // (which is required to exist.) So from-space will normally be empty. // Note that we check both spaces, since if scavenge failed they revert roles. // If not we bail out (otherwise we would have to relocate the objects) if (!from()->is_empty() || !to()->is_empty()) { return; } int next_level = level() + 1; GenCollectedHeap* gch = GenCollectedHeap::heap(); assert(next_level < gch->_n_gens, "DefNewGeneration cannot be an oldest gen"); Generation* next_gen = gch->_gens[next_level]; size_t old_size = next_gen->capacity(); size_t new_size_before = _virtual_space.committed_size(); size_t min_new_size = spec()->init_size(); size_t max_new_size = reserved().byte_size(); assert(min_new_size <= new_size_before && new_size_before <= max_new_size, "just checking"); // All space sizes must be multiples of Generation::GenGrain. size_t alignment = Generation::GenGrain; // Compute desired new generation size based on NewRatio and // NewSizeThreadIncrease size_t desired_new_size = old_size/NewRatio; int threads_count = Threads::number_of_non_daemon_threads(); size_t thread_increase_size = threads_count * NewSizeThreadIncrease; desired_new_size = align_size_up(desired_new_size + thread_increase_size, alignment); // Adjust new generation size desired_new_size = MAX2(MIN2(desired_new_size, max_new_size), min_new_size); assert(desired_new_size <= max_new_size, "just checking"); bool changed = false; if (desired_new_size > new_size_before) { size_t change = desired_new_size - new_size_before; assert(change % alignment == 0, "just checking"); if (expand(change)) { changed = true; } // If the heap failed to expand to the desired size, // "changed" will be false. If the expansion failed // (and at this point it was expected to succeed), // ignore the failure (leaving "changed" as false). } if (desired_new_size < new_size_before && eden()->is_empty()) { // bail out of shrinking if objects in eden size_t change = new_size_before - desired_new_size; assert(change % alignment == 0, "just checking"); _virtual_space.shrink_by(change); changed = true; } if (changed) { // The spaces have already been mangled at this point but // may not have been cleared (set top = bottom) and should be. // Mangling was done when the heap was being expanded. compute_space_boundaries(eden()->used(), SpaceDecorator::Clear, SpaceDecorator::DontMangle); MemRegion cmr((HeapWord*)_virtual_space.low(), (HeapWord*)_virtual_space.high()); Universe::heap()->barrier_set()->resize_covered_region(cmr); if (Verbose && PrintGC) { size_t new_size_after = _virtual_space.committed_size(); size_t eden_size_after = eden()->capacity(); size_t survivor_size_after = from()->capacity(); gclog_or_tty->print("New generation size " SIZE_FORMAT "K->" SIZE_FORMAT "K [eden=" SIZE_FORMAT "K,survivor=" SIZE_FORMAT "K]", new_size_before/K, new_size_after/K, eden_size_after/K, survivor_size_after/K); if (WizardMode) { gclog_or_tty->print("[allowed " SIZE_FORMAT "K extra for %d threads]", thread_increase_size/K, threads_count); } gclog_or_tty->cr(); } } }
void hyperstone_device::opaf() { LOCAL_DECODE_INIT; no_decode(decode); reserved(decode); }
int proceso( int num, int padre ) { int v1 ; int retcode = 0; int no_devuelve = 0 ; int (*externa)(struct _fun_params*); int temp,oo; unsigned int utemp; int cpas=0; #ifdef DBG int actual_lin; #endif int _status=reservedptr("status"); int _param_offset; num_proc = num ; imem = procs_s[num_proc].imem ; //printf("num_proc: %d\n",num); while( retcode == 0 ) { //printf("imem: %i\tnum_proc: %i\tsp: %i\tpila[sp]: %i \n" , imem , num_proc , sp , pila[sp]) ; switch ( mem[ imem++ ] ) { case lnop://0 break; case lcar://1 pila[++sp]=mem[imem++] ; break; case lasi://2 mem[ pila[sp-1] ] = pila[sp--] ; //printf("Cargado %i en %i\n" , pila[sp+1], pila[sp] ) ; break ; case lori://3 pila[sp-1]|=pila[sp]; sp--; break; case lxor://4 pila[sp-1]^=pila[sp]; sp--; break; case land://5 pila[sp-1]&=pila[sp]; sp--; break; case ligu://6 pila[sp-1] = ( pila[sp-1] == pila[sp] ) ; sp--; break; case ldis://7 pila[sp-1] = ( pila[sp-1] != pila[sp] ) ; sp--; break; case lmay://8 pila[sp-1] = ( pila[sp-1] > pila[sp] ) ; sp--; break; case lmen://9 pila[sp-1] = ( pila[sp-1] < pila[sp] ) ; sp--; break; case lmei://10 pila[sp-1] = ( pila[sp-1] <= pila[sp] ) ; sp--; break; case lmai://11 pila[sp-1] = ( pila[sp-1] >= pila[sp] ) ; sp--; break; case ladd://12 pila[sp-1] += pila[sp] ; sp--; break; case lsub://13 pila[sp-1] -= pila[sp] ; sp--; break; case lmul://14 pila[sp-1] *= pila[sp] ; sp--; break; case ldiv://15 if(pila[sp]==0) error(145); // división entre cero pila[sp-1] /= pila[sp] ; sp--; break; case lmod://16 if(pila[sp]==0) error(145); // división entre cero pila[sp-1] %= pila[sp] ; sp--; break; case lneg://17 pila[sp] = -pila[sp] ; break ; case lptr://18 pila[sp] = mem[ pila[sp] ] ; break ; case lnot://19 pila[sp]^=-1; break ; case laid://20 pila[sp]+= procs_s[num_proc].id ; break ; case lcid://21 pila[++sp] = procs_s[num_proc].id ; break ; case lrng://22 POR HACER (debug) imem++; break ; case ljmp://23 imem = mem[ imem ] ; //printf("Nueva posicion: %i\n", imem ) ; break ; case ljpf://24 if (!(pila[sp]&1)) imem = mem[ imem ] ; else imem++; sp--; break ; case lfun://25 NO USADO break ; case lcal://26 devolver++ ; v1 = busca_proc_libre() ; procs_s[v1].imem = mem[imem++] ; temp = proceso_actual ; proceso_actual = lista_mete(v1) ; procs_s[num_proc].imem = imem ; proceso(v1,num_proc) ; proceso_actual = temp ; num_proc = num ; imem = procs_s[num_proc].imem ; break ; case lret://27 lista_quita(proceso_actual); //printf("Ret: %i\n" , num_proc) ; retcode = 1 ; break ; case lasp://28 sp--; break; case lfrm://29 procs_s[num_proc].imem = imem ; reserved("type_scan",procs_s[num_proc].id)=0; /* resetea get_id() */ reserved("id_scan",procs_s[num_proc].id)=0; if ( first_loaded ) { Call_Entrypoint(EDIV_first_load); first_loaded = 0 ; } //printf("Frame en: %i\n" , imem ) ; retcode = 1 ; break ; case lcbp://30 reserved("parameters",procs_s[num_proc].id)=mem[imem++]; reserved("param_offset",procs_s[num_proc].id)=sp-reserved("parameters",procs_s[num_proc].id)+1; /**/procs_s[num_proc].num_params = mem[ imem-1 ] ; break; case lcpa://31 mem[pila[sp]]=pila[reserved("param_offset",procs_s[num_proc].id)++]; sp--; cpas++; if(cpas==reserved("parameters",procs_s[num_proc].id)) sp-=cpas; break; case ltyp://32 if ( procs_s[num_proc].tipo != 0 ) { critical_error(3); // redefinición del tipo de proceso } procs_s[num_proc].id = (mem[2] + ( num_proc * iloc_len ))|1; if(procs_s[num_proc].id>imem_max-iloc_len) critical_error(8); // demasiados procesos en ejecución memcpy(&mem[procs_s[num_proc].id],&mem[iloc],iloc_pub_len<<2); reserved("process_id",procs_s[num_proc].id)=procs_s[num_proc].id; if(padre!=-1) { int bigbro; if(bigbro=local("son",procs_s[padre].id)) { local("smallbro",bigbro)=procs_s[num_proc].id; local("bigbro",procs_s[num_proc].id)=bigbro; } local("son",procs_s[padre].id)=procs_s[num_proc].id; local("father",procs_s[num_proc].id)=procs_s[padre].id; } else { local("father",procs_s[num_proc].id)=0; } procs_s[num_proc].tipo = mem[ imem++ ] ; reserved("process_type",procs_s[num_proc].id) = procs_s[num_proc].tipo ; mem[procs_s[num_proc].id+_status] = 2; inicio_privadas=mem[6]; break ; case lpri://33 POR HACER? memcpy(&mem[procs_s[num_proc].id+inicio_privadas],&mem[imem+1],(mem[imem]-imem-1)<<2); inicio_privadas+=(mem[imem]-imem-1); imem=mem[imem]; break ; case lcse://34 if ( pila[sp-1] == pila[sp] ) imem++; else imem=mem[imem]; sp--; break ; case lcsr://35 if ( pila[sp-2] >= pila[sp-1] && pila[sp-2] <= pila[sp] ) imem++ ; else imem = mem[imem]; sp-=2; break ; case lshr://36 pila[sp-1] >>= pila[sp] ; sp-- ; break ; case lshl://37 pila[sp-1] <<= pila[sp] ; sp-- ; break ; case lipt://38 pila[sp] = ++mem[ pila[sp] ] ; break ; case lpti://39 COMPORTAMIENTO EXTRAÑO SI SE PONE EN UNA LINEA mem[ pila[sp] ]++; pila[sp] = mem[ pila[sp] ]-1 ; break ; case ldpt://40 pila[sp] = --mem[ pila[sp] ] ; break ; case lptd://41 COMPORTAMIENTO EXTRAÑO SI SE PONE EN UNA LINEA mem[ pila[sp] ]--; pila[sp] = mem[ pila[sp] ]+1 ; break ; case lada://42 pila[ sp-1 ] = mem[ pila[ sp-1 ] ] += pila[sp] ; sp--; break; case lsua://43 pila[ sp-1 ] = mem[ pila[ sp-1 ] ] -= pila[sp] ; sp--; break; case lmua://44 pila[ sp-1 ] = mem[ pila[ sp-1 ] ] *= pila[sp] ; sp--; break; case ldia://45 pila[ sp-1 ] = mem[ pila[ sp-1 ] ] /= pila[sp] ; sp--; break; case lmoa://46 pila[ sp-1 ] = mem[ pila[ sp-1 ] ] %= pila[sp] ; sp--; break; case lana://47 pila[ sp-1 ] = mem[ pila[ sp-1 ] ] &= pila[sp] ; sp--; break; case lora://48 pila[ sp-1 ] = mem[ pila[ sp-1 ] ] |= pila[sp] ; sp--; break; case lxoa://49 pila[ sp-1 ] = mem[ pila[ sp-1 ] ] ^= pila[sp] ; sp--; break; case lsra://50 pila[ sp-1 ] = mem[ pila[ sp-1 ] ] >>= pila[sp] ; sp--; break; case lsla://51 pila[ sp-1 ] = mem[ pila[ sp-1 ] ] <<= pila[sp] ; sp--; break; case lpar://52 POR HACER? //imem++; inicio_privadas+=mem[imem++]; break; case lrtf://53 lista_quita(num_proc) ; no_devuelve = 1 ; //printf("Return: %i\n" , num_proc) ; retcode = 1 ; break ; case lclo://54 POR HACER break ; case lfrf://55 POR HACER sp--; break ; case limp://56 carga_dll((char*)&mem[mem[imem++]]); break ; case lext://57 externa=extfuncs[mem[imem]]; // corresponder con FUNCTION_PARAMS //temp = externa(pila,&sp,mem,varindex,&procs_s,Call_Entrypoint); fp.num_params=extparms[mem[imem++]]; temp = externa(&fp) ; pila[++sp]= temp ; break ; case ldbg://58 #ifdef DBG Call_Entrypoint(EDIV_debug,imem,nombre_program,lin,0); #endif break ; /* OPCODES OPTIMIZADOS */ case lcar2://60 pila[++sp]=mem[imem++]; pila[++sp]=mem[imem++]; break; case lcar3://61 pila[++sp]=mem[imem++]; pila[++sp]=mem[imem++]; pila[++sp]=mem[imem++]; break; case lcar4://62 pila[++sp]=mem[imem++]; pila[++sp]=mem[imem++]; pila[++sp]=mem[imem++]; pila[++sp]=mem[imem++]; break; case lasiasp://63 mem[pila[sp-1]]=pila[sp]; sp-=2; break; case lcaraid://64 pila[++sp]=mem[imem++]+procs_s[num_proc].id; break; case lcarptr://65 pila[++sp]=mem[mem[imem++]]; break; case laidptr://66 pila[sp]=mem[pila[sp]+procs_s[num_proc].id]; break; case lcaraidptr://67 pila[++sp]=mem[mem[imem++]+procs_s[num_proc].id]; break; case lcaraidcpa://68 mem[mem[imem++]+procs_s[num_proc].id]=pila[reserved("param_offset",procs_s[num_proc].id)++]; //sp--; cpas++; if(cpas==reserved("parameters",procs_s[num_proc].id)) sp-=cpas; break; case laddptr://69 pila[sp-1]=mem[pila[sp-1]+pila[sp]]; sp--; break; case lfunasp://70 NO USADO break; case lcaradd://71 pila[sp]+=mem[imem++]; break; case lcaraddptr://72 pila[sp]=mem[pila[sp]+mem[imem++]]; break; case lcarmul://73 pila[sp]*=mem[imem++]; break; case lcarmuladd://74 pila[sp-1]+=pila[sp]*mem[imem++]; sp--; break; case lcarasiasp://75 mem[pila[sp]]=mem[imem++]; sp--; break; case lcarsub://76 pila[sp]-=mem[imem++]; break; case lcardiv://77 no hay nunca "cardiv 0" pila[sp]/=mem[imem++]; break; /* OPERACIONES CON DATOS DE TIPO BYTE */ case lptrchr: pila[sp-1]=(unsigned int)memb[pila[sp-1]*4+pila[sp]]; sp--; break; case lasichr: pila[sp-2]=(unsigned int)(memb[pila[sp-2]*4+pila[sp-1]]=(byte)pila[sp]); sp-=2; break; case liptchr: pila[sp-1]=(unsigned int)++memb[pila[sp-1]*4+pila[sp]]; sp--; break; case lptichr: /* o_O yo lo flipo con el visual studio! mirad la tonteria que he * tenido ke hacer! (variable utemp) * visto lo visto, hay que testear cuidadosamente TODOS los opcodes! */ utemp=pila[sp-1]; pila[sp-1]=(unsigned int)memb[utemp*4+pila[sp]]++; sp--; break; case ldptchr: pila[sp-1]=(unsigned int)--memb[pila[sp-1]*4+pila[sp]]; sp--; break; case lptdchr: /* y aqui la misma chapuza en teoria innecesaria! */ utemp=pila[sp-1]; pila[sp-1]=(unsigned int)memb[utemp*4+pila[sp]]--; sp--; break; case ladachr: pila[sp-2]=(unsigned int)(memb[pila[sp-2]*4+pila[sp-1]]+=(byte)pila[sp]); sp-=2; break; case lsuachr: pila[sp-2]=(unsigned int)(memb[pila[sp-2]*4+pila[sp-1]]-=(byte)pila[sp]); sp-=2; break; case lmuachr: pila[sp-2]=(unsigned int)(memb[pila[sp-2]*4+pila[sp-1]]*=(byte)pila[sp]); sp-=2; break; case ldiachr: /*#ifdef DBG if (pila[sp]==0) { memb[pila[sp-2]*4+pila[sp-1]]=0; sp-=2; pila[sp]=0; v_function=-2; e(145); if (call_to_debug) { process_stoped=id; return; } break; } #endif*/ pila[sp-2]=(unsigned int)(memb[pila[sp-2]*4+pila[sp-1]]/=(byte)pila[sp]); sp-=2; break; case lmoachr: /*#ifdef DBG if (pila[sp]==0) { memb[pila[sp-2]*4+pila[sp-1]]=0; sp-=2; pila[sp]=0; v_function=-2; e(145); if (call_to_debug) { process_stoped=id; return; } break; } #endif*/ pila[sp-2]=(unsigned int)(memb[pila[sp-2]*4+pila[sp-1]]%=(byte)pila[sp]); sp-=2; break; case lanachr: pila[sp-2]=(unsigned int)(memb[pila[sp-2]*4+pila[sp-1]]&=(byte)pila[sp]); sp-=2; break; case lorachr: pila[sp-2]=(unsigned int)(memb[pila[sp-2]*4+pila[sp-1]]|=(byte)pila[sp]); sp-=2; break; case lxoachr: pila[sp-2]=(unsigned int)(memb[pila[sp-2]*4+pila[sp-1]]^=(byte)pila[sp]); sp-=2; break; case lsrachr: pila[sp-2]=(unsigned int)(memb[pila[sp-2]*4+pila[sp-1]]>>=(byte)pila[sp]); sp-=2; break; case lslachr: pila[sp-2]=(unsigned int)(memb[pila[sp-2]*4+pila[sp-1]]<<=(byte)pila[sp]); sp-=2; break; case lcpachr: _param_offset=reservedptr("param_offset"); if ((unsigned int)pila[mem[procs_s[num_proc].id+_param_offset]]<256) { memb[pila[sp-1]*4+pila[sp]]=(byte)pila[mem[procs_s[num_proc].id+_param_offset]]; } else { if (pila[mem[procs_s[num_proc].id+_param_offset]]<imem_max+258*4) memb[pila[sp-1]*4+pila[sp]]=memb[pila[mem[procs_s[num_proc].id+_param_offset]]*4]; else memb[pila[sp-1]*4+pila[sp]]=(byte)pila[mem[procs_s[num_proc].id+_param_offset]]; } sp-=2; mem[procs_s[num_proc].id+_param_offset]++; break; /* OPERACIONES CON DATOS DE TIPO WORD */ case lptrwor: pila[sp-1]=(unsigned int)memw[pila[sp-1]*2+pila[sp]]; sp--; break; case lasiwor: pila[sp-2]=(unsigned int)(memw[pila[sp-2]*2+pila[sp-1]]=(word)pila[sp]); sp-=2; break; case liptwor: pila[sp-1]=(unsigned int)++memw[pila[sp-1]*2+pila[sp]]; sp--; break; case lptiwor: utemp=pila[sp-1]; pila[sp-1]=(unsigned int)memw[utemp*2+pila[sp]]++; sp--; break; case ldptwor: pila[sp-1]=(unsigned int)--memw[pila[sp-1]*2+pila[sp]]; sp--; break; case lptdwor: utemp=pila[sp-1]; pila[sp-1]=(unsigned int)memw[utemp*2+pila[sp]]--; sp--; break; case ladawor: pila[sp-2]=(unsigned int)(memw[pila[sp-2]*2+pila[sp-1]]+=(word)pila[sp]); sp-=2; break; case lsuawor: pila[sp-2]=(unsigned int)(memw[pila[sp-2]*2+pila[sp-1]]-=(word)pila[sp]); sp-=2; break; case lmuawor: pila[sp-2]=(unsigned int)(memw[pila[sp-2]*2+pila[sp-1]]*=(word)pila[sp]); sp-=2; break; case ldiawor: /* #ifdef DEBUG if (pila[sp]==0) { memw[pila[sp-2]*2+pila[sp-1]]=0; sp-=2; pila[sp]=0; v_function=-2; e(145); if (call_to_debug) { process_stoped=id; return; } break; } #endif*/ pila[sp-2]=(unsigned int)(memw[pila[sp-2]*2+pila[sp-1]]/=(word)pila[sp]); sp-=2; break; case lmoawor: /* #ifdef DEBUG if (pila[sp]==0) { memw[pila[sp-2]*2+pila[sp-1]]=0; sp-=2; pila[sp]=0; v_function=-2; e(145); if (call_to_debug) { process_stoped=id; return; } break; } #endif*/ pila[sp-2]=(unsigned int)(memw[pila[sp-2]*2+pila[sp-1]]%=(word)pila[sp]); sp-=2; break; case lanawor: pila[sp-2]=(unsigned int)(memw[pila[sp-2]*2+pila[sp-1]]&=(word)pila[sp]); sp-=2; break; case lorawor: pila[sp-2]=(unsigned int)(memw[pila[sp-2]*2+pila[sp-1]]|=(word)pila[sp]); sp-=2; break; case lxoawor: pila[sp-2]=(unsigned int)(memw[pila[sp-2]*2+pila[sp-1]]^=(word)pila[sp]); sp-=2; break; case lsrawor: pila[sp-2]=(unsigned int)(memw[pila[sp-2]*2+pila[sp-1]]>>=(word)pila[sp]); sp-=2; break; case lslawor: pila[sp-2]=(unsigned int)(memw[pila[sp-2]*2+pila[sp-1]]<<=(word)pila[sp]); sp-=2; break; case lcpawor: _param_offset=reservedptr("param_offset"); if ((unsigned)pila[mem[procs_s[num_proc].id+_param_offset]]<256) { memw[pila[sp-1]*2+pila[sp]]=(word)pila[mem[procs_s[num_proc].id+_param_offset]]; } else { if (pila[mem[procs_s[num_proc].id+_param_offset]]<imem_max+258*4) memw[pila[sp-1]*2+pila[sp]]=memw[pila[mem[procs_s[num_proc].id+_param_offset]]*2]; else memw[pila[sp-1]*2+pila[sp]]=(word)pila[mem[procs_s[num_proc].id+_param_offset]]; } sp-=2; mem[procs_s[num_proc].id+_param_offset]++; break; /* OPERACIONES CON DATOS DE TIPO STRING */ /* Nota: un puntero a cadena menor a 256 se trata siempre como "%c" */ case lstrcpy: /* #ifdef DEBUG if ((mem[pila[sp-1]-1]&0xFFF00000)!=0xDAD00000) { sp--; v_function=-2; e(164); if (call_to_debug) { process_stoped=id; return; } break; } if ((unsigned)pila[sp]>255) if ((mem[pila[sp-1]-1]&0xFFFFF)+1<strlen((char*)&mem[pila[sp]])) { sp--; v_function=-2; e(140); if (call_to_debug) { process_stoped=id; return; } break; } #endif*/ if ((unsigned)pila[sp]>255) strcpy((char*)&mem[pila[sp-1]],(char*)&mem[pila[sp]]); else sprintf((char*)&mem[pila[sp-1]],"%c\0",pila[sp]); sp--; break; case lstrfix: if (pila[sp-1]>=(oo=strlen(&memb[pila[sp-2]*4]))) { for (;oo<pila[sp-1];oo++) { memb[pila[sp-2]*4+oo]=' '; } memb[pila[sp-2]*4+oo+1]=0; } break; case lstrcat: /* #ifdef DEBUG if ((mem[pila[sp-1]-1]&0xFFF00000)!=0xDAD00000) { sp--; v_function=-2; e(164); if (call_to_debug) { process_stoped=id; return; } break; } if ((unsigned)pila[sp]>255) oo=strlen((char*)&mem[pila[sp]]); else oo=1; if ((mem[pila[sp-1]-1]&0xFFFFF)+1<strlen((char*)&mem[pila[sp-1]])+oo) { sp--; v_function=-2; e(140); if (call_to_debug) { process_stoped=id; return; } break; } #endif*/ if ((unsigned)pila[sp]>255) strcat((char*)&mem[pila[sp-1]],(char*)&mem[pila[sp]]); else sprintf((char*)&mem[pila[sp-1]],"%s%c\0",(char*)&mem[pila[sp-1]],pila[sp]); sp--; break; case lstradd: /* Strcat "en el aire" (ojo, el aire tiene tambien 0xDAD00402) */ /* #ifdef DEBUG if ((unsigned)pila[sp-1]>255) oo=strlen((char*)&mem[pila[sp-1]]); else oo=1; if ((unsigned)pila[sp]>255) oo+=strlen((char*)&mem[pila[sp]]); else oo+=1; if (oo>=1028) { sp--; v_function=-2; e(140); if (call_to_debug) { process_stoped=id; return; } break; } #endif*/ if ((unsigned)pila[sp-1]>255) { if ((unsigned)pila[sp]>255) { sprintf((char*)&mem[nullstring[nstring]],"%s%s\0",(char*)&mem[pila[sp-1]],(char*)&mem[pila[sp]]); } else { sprintf((char*)&mem[nullstring[nstring]],"%s%c\0",(char*)&mem[pila[sp-1]],pila[sp]); } } else { if ((unsigned)pila[sp]>255) { sprintf((char*)&mem[nullstring[nstring]],"%c%s\0",pila[sp-1],(char*)&mem[pila[sp]]); } else { sprintf((char*)&mem[nullstring[nstring]],"%c%c\0",pila[sp-1],pila[sp]); } } pila[--sp]=nullstring[nstring]; nstring=((nstring+1)&3); break; case lstrdec: /* cambio de tamaño "en el aire" (no da error, hace lo que puede) */ oo=strlen((char*)&mem[pila[sp-1]]); if (oo<1028) { strcpy((char*)&mem[nullstring[nstring]],(char*)&mem[pila[sp-1]]); if (pila[sp]>0) { /* Quitar caracteres */ if (pila[sp]>=oo) memb[nullstring[nstring]*4]=0; else memb[nullstring[nstring]*4+oo-pila[sp]]=0; } else if (pila[sp]<0) { /* Añadir (?) caracteres (por homogeneidad) */ pila[sp]=oo-pila[sp]; /* Nueva longitud */ if (pila[sp]>1025) pila[sp]=1025; for (;oo<pila[sp];oo++) { memb[nullstring[nstring]*4+oo]=' '; } memb[nullstring[nstring]*4+oo]=0; } } else mem[nullstring[nstring]]=0; pila[--sp]=nullstring[nstring]; nstring=((nstring+1)&3); break; case lstrsub: /* cambio de tamaño a un string */ oo=strlen((char*)&mem[pila[sp-1]]); /* #ifdef DEBUG if ((mem[pila[sp-1]-1]&0xFFF00000)!=0xDAD00000) { sp--; v_function=-2; e(164); if (call_to_debug) { process_stoped=id; return; } break; } if ((mem[pila[sp-1]-1]&0xFFFFF)+1<oo-pila[sp]) { sp--; v_function=-2; e(140); if (call_to_debug) { process_stoped=id; return; } break; } #endif*/ if (pila[sp]>0) { // Quitar caracteres if (pila[sp]>=oo) memb[pila[sp-1]*4]=0; else memb[pila[sp-1]*4+oo-pila[sp]]=0; } else if (pila[sp]<0) { /* Añadir (?) caracteres (por homogeneidad) */ pila[sp]=oo-pila[sp]; /* Nueva longitud */ for (;oo<pila[sp];oo++) { memb[pila[sp-1]*4+oo]=' '; } memb[pila[sp-1]*4+oo]=0; } sp--; break; case lstrlen: if ((unsigned)pila[sp]>255) pila[sp]=strlen((char*)&mem[pila[sp]]); else pila[sp]=1; break; case lstrigu: if ((unsigned)pila[sp-1]>255) { if ((unsigned)pila[sp]>255) { if (strcmp((char*)&mem[pila[sp-1]],(char*)&mem[pila[sp]])) pila[sp-1]=0; else pila[sp-1]=1; } else { if (strcmp((char*)&mem[pila[sp-1]],(char*)&pila[sp])) pila[sp-1]=0; else pila[sp-1]=1; } } else { if ((unsigned)pila[sp]>255) { if (strcmp((char*)&pila[sp-1],(char*)&mem[pila[sp]])) pila[sp-1]=0; else pila[sp-1]=1; } else { pila[sp-1]=(pila[sp-1]==pila[sp]); } } sp--; break; case lstrdis: if ((unsigned)pila[sp-1]>255) { if ((unsigned)pila[sp]>255) { if (strcmp((char*)&mem[pila[sp-1]],(char*)&mem[pila[sp]])) pila[sp-1]=1; else pila[sp-1]=0; } else { if (strcmp((char*)&mem[pila[sp-1]],(char*)&pila[sp])) pila[sp-1]=1; else pila[sp-1]=0; } } else { if ((unsigned)pila[sp]>255) { if (strcmp((char*)&pila[sp-1],(char*)&mem[pila[sp]])) pila[sp-1]=1; else pila[sp-1]=0; } else { pila[sp-1]=(pila[sp-1]!=pila[sp]); } } sp--; break; break; case lstrmay: if ((unsigned)pila[sp-1]>255) { if ((unsigned)pila[sp]>255) { if (strcmp((char*)&mem[pila[sp-1]],(char*)&mem[pila[sp]])>0) pila[sp-1]=1; else pila[sp-1]=0; } else { if (strcmp((char*)&mem[pila[sp-1]],(char*)&pila[sp])>0) pila[sp-1]=1; else pila[sp-1]=0; } } else { if ((unsigned)pila[sp]>255) { if (strcmp((char*)&pila[sp-1],(char*)&mem[pila[sp]])>0) pila[sp-1]=1; else pila[sp-1]=0; } else { pila[sp-1]=(pila[sp-1]>pila[sp]); } } sp--; break; break; case lstrmen: if ((unsigned)pila[sp-1]>255) { if ((unsigned)pila[sp]>255) { if (strcmp((char*)&mem[pila[sp-1]],(char*)&mem[pila[sp]])<0) pila[sp-1]=1; else pila[sp-1]=0; } else { if (strcmp((char*)&mem[pila[sp-1]],(char*)&pila[sp])<0) pila[sp-1]=1; else pila[sp-1]=0; } } else { if ((unsigned)pila[sp]>255) { if (strcmp((char*)&pila[sp-1],(char*)&mem[pila[sp]])<0) pila[sp-1]=1; else pila[sp-1]=0; } else { pila[sp-1]=(pila[sp-1]<pila[sp]); } } sp--; break; break; case lstrmei: if ((unsigned)pila[sp-1]>255) { if ((unsigned)pila[sp]>255) { if (strcmp((char*)&mem[pila[sp-1]],(char*)&mem[pila[sp]])<=0) pila[sp-1]=1; else pila[sp-1]=0; } else { if (strcmp((char*)&mem[pila[sp-1]],(char*)&pila[sp])<=0) pila[sp-1]=1; else pila[sp-1]=0; } } else { if ((unsigned)pila[sp]>255) { if (strcmp((char*)&pila[sp-1],(char*)&mem[pila[sp]])<=0) pila[sp-1]=1; else pila[sp-1]=0; } else { pila[sp-1]=(pila[sp-1]<=pila[sp]); } } sp--; break; break; case lstrmai: if ((unsigned)pila[sp-1]>255) { if ((unsigned)pila[sp]>255) { if (strcmp((char*)&mem[pila[sp-1]],(char*)&mem[pila[sp]])>=0) pila[sp-1]=1; else pila[sp-1]=0; } else { if (strcmp((char*)&mem[pila[sp-1]],(char*)&pila[sp])>=0) pila[sp-1]=1; else pila[sp-1]=0; } } else { if ((unsigned)pila[sp]>255) { if (strcmp((char*)&pila[sp-1],(char*)&mem[pila[sp]])>=0) pila[sp-1]=1; else pila[sp-1]=0; } else { pila[sp-1]=(pila[sp-1]>=pila[sp]); } } sp--; break; break; case lcpastr: _param_offset=reservedptr("param_offset"); /* #ifdef DEBUG if ((mem[pila[sp]-1]&0xFFF00000)!=0xDAD00000) { sp--; mem[id+_Param]++; v_function=-2; e(164); if (call_to_debug) { process_stoped=id; return; } break; } if ((unsigned)pila[mem[id+_Param]]>255) { if ((mem[pila[sp]-1]&0xFFFFF)+1<strlen((char*)&mem[pila[mem[id+_Param]]])) { sp--; mem[id+_Param]++; v_function=-2; e(140); if (call_to_debug) { process_stoped=id; return; } break; } } #endif*/ if ((unsigned)pila[mem[procs_s[num_proc].id+_param_offset]]>255) strcpy((char*)&mem[pila[sp]],(char*)&mem[pila[mem[procs_s[num_proc].id+_param_offset]]]); else sprintf((char*)&mem[pila[sp]],"%c\0",pila[mem[procs_s[num_proc].id+_param_offset]]); sp--; mem[procs_s[num_proc].id+_param_offset]++; break; /* Comprobación de punteros nulos */ case lnul: /* #ifdef DEBUG if (!pila[sp]) { v_function=-2; e(165); if (call_to_debug) { process_stoped=id; return; } } #endif*/ break; /* OPCODES NUEVOS DE EDIV */ case lextasp: externa=extfuncs[mem[imem]]; // corresponder con FUNCTION_PARAMS //temp = externa(pila,&sp,mem,varindex,&procs_s,Call_Entrypoint); fp.num_params=extparms[mem[imem++]]; externa(&fp); break; } #ifdef DBG Call_Entrypoint(EDIV_trace,imem,nombre_program,lin,0); #ifdef _DEBUG actual_lin=localiza_lin(imem); if(actual_lin!=last_lin) { unsigned char* p=&prog[lin[actual_lin*4+3]]; // printf("[%d|%d-%d] ",imem,lin[actual_lin*4+3],lin[actual_lin*4+4]); printf("[%d] ",imem); while(p<=&prog[lin[actual_lin*4+4]]) { putc(*p,stdout); p++; } printf("\n"); last_lin=actual_lin; } #endif /* _DEBUG */ #endif /* DBG */ } if ( devolver > 0 && no_devuelve == 0 ) { //pila[++sp] = 0 ;// AQUI SE DEBERA DEVOLVER EL ID pila[++sp]=procs_s[num_proc].id; devolver-- ; } Call_Entrypoint(EDIV_post_process); return 1 ; }
/** * Parse a comma separated list, converting to bytecode * * \param c Parsing context * \param vector Vector of tokens to process * \param ctx Pointer to vector iteration context * \param reserved Callback to determine if an identifier is reserved * \param get_value Callback to retrieve bytecode value for a token * \param style Pointer to output style * \return CSS_OK on success, * CSS_INVALID if the input is invalid * * Post condition: \a *ctx is updated with the next token to process * If the input is invalid, then \a *ctx remains unchanged. */ css_error css__comma_list_to_style(css_language *c, const parserutils_vector *vector, int *ctx, bool (*reserved)(css_language *c, const css_token *ident), css_code_t (*get_value)(css_language *c, const css_token *token, bool first), css_style *result) { int orig_ctx = *ctx; int prev_ctx = orig_ctx; const css_token *token; bool first = true; css_error error = CSS_OK; token = parserutils_vector_iterate(vector, ctx); if (token == NULL) { *ctx = orig_ctx; return CSS_INVALID; } while (token != NULL) { if (token->type == CSS_TOKEN_IDENT) { css_code_t value = get_value(c, token, first); if (reserved(c, token) == false) { lwc_string *str = NULL; uint32_t snumber; *ctx = prev_ctx; error = css__ident_list_to_string(c, vector, ctx, reserved, &str); if (error != CSS_OK) goto cleanup; error = css__stylesheet_string_add(c->sheet, str, &snumber); if (error != CSS_OK) goto cleanup; error = css__stylesheet_style_append(result, value); if (error != CSS_OK) goto cleanup; error = css__stylesheet_style_append(result, snumber); if (error != CSS_OK) goto cleanup; } else { error = css__stylesheet_style_append(result, value); if (error != CSS_OK) goto cleanup; } } else if (token->type == CSS_TOKEN_STRING) { css_code_t value = get_value(c, token, first); uint32_t snumber; error = css__stylesheet_string_add(c->sheet, lwc_string_ref(token->idata), &snumber); if (error != CSS_OK) goto cleanup; error = css__stylesheet_style_append(result, value); if (error != CSS_OK) goto cleanup; error = css__stylesheet_style_append(result, snumber); if (error != CSS_OK) goto cleanup; } else { error = CSS_INVALID; goto cleanup; } consumeWhitespace(vector, ctx); token = parserutils_vector_peek(vector, *ctx); if (token != NULL && tokenIsChar(token, ',')) { parserutils_vector_iterate(vector, ctx); consumeWhitespace(vector, ctx); token = parserutils_vector_peek(vector, *ctx); if (token == NULL || (token->type != CSS_TOKEN_IDENT && token->type != CSS_TOKEN_STRING)) { error = CSS_INVALID; goto cleanup; } } else { break; } first = false; prev_ctx = *ctx; token = parserutils_vector_iterate(vector, ctx); } cleanup: if (error != CSS_OK) *ctx = orig_ctx; return error; }
bool is_in_reserved(const void* p) const { return reserved().contains((void *)p); }
size_t Generation::max_capacity() const { return reserved().byte_size(); }
/** * Create a string from a list of IDENT/S tokens * * \param c Parsing context * \param vector Vector containing tokens * \param ctx Vector iteration context * \param reserved Callback to determine if an identifier is reserved * \param result Pointer to location to receive resulting string * \return CSS_OK on success, appropriate error otherwise. * * Post condition: \a *ctx is updated with the next token to process * If the input is invalid, then \a *ctx remains unchanged. * * The resulting string's reference is passed to the caller */ css_error css__ident_list_to_string(css_language *c, const parserutils_vector *vector, int *ctx, bool (*reserved)(css_language *c, const css_token *ident), lwc_string **result) { int orig_ctx = *ctx; const css_token *token; css_error error = CSS_OK; parserutils_buffer *buffer; parserutils_error perror; lwc_string *interned; lwc_error lerror; perror = parserutils_buffer_create((parserutils_alloc) c->alloc, c->pw, &buffer); if (perror != PARSERUTILS_OK) return css_error_from_parserutils_error(perror); /* We know this token exists, and is an IDENT */ token = parserutils_vector_iterate(vector, ctx); /* Consume all subsequent IDENT or S tokens */ while (token != NULL && (token->type == CSS_TOKEN_IDENT || token->type == CSS_TOKEN_S)) { if (token->type == CSS_TOKEN_IDENT) { /* IDENT -- if reserved, reject style */ if (reserved != NULL && reserved(c, token)) { error = CSS_INVALID; goto cleanup; } perror = parserutils_buffer_append(buffer, (const uint8_t *) lwc_string_data(token->idata), lwc_string_length(token->idata)); } else { /* S */ perror = parserutils_buffer_append(buffer, (const uint8_t *) " ", 1); } if (perror != PARSERUTILS_OK) { error = css_error_from_parserutils_error(perror); goto cleanup; } token = parserutils_vector_iterate(vector, ctx); } /* Rewind context by one step if we consumed an unacceptable token */ if (token != NULL) *ctx = *ctx - 1; /* Strip trailing whitespace */ while (buffer->length > 0 && buffer->data[buffer->length - 1] == ' ') buffer->length--; /* Intern the buffer contents */ lerror = lwc_intern_string((char *) buffer->data, buffer->length, &interned); if (lerror != lwc_error_ok) { error = css_error_from_lwc_error(lerror); goto cleanup; } *result = interned; cleanup: parserutils_buffer_destroy(buffer); if (error != CSS_OK) *ctx = orig_ctx; return error; }
// No young generation references, clear this generation's cards. void CardGeneration::clear_remembered_set() { _rs->clear(reserved()); }
int reserved (char *word, char ** reserved_words) { /* This function returns 1 if word is a reserved word; 0, otherwise */ if (strcmp ("", *reserved_words) == 0) return 0; if (strcmp (word, *reserved_words) == 0) return 1; return reserved (word, reserved_words+1); }
/* images will be saved in the current directory by default */ std::vector<string> capture(int startFrame, int endFrame, bool output = false, const char* path = "", string filename = "") { /* total number of frames */ size_t total = endFrame - startFrame; /* dynamical array of images for storing all the frames */ /* store string rather than Image objects because those objects will eat all the memory */ std::vector<string> images; this->setFrames(startFrame, false); #ifdef FFMPEG /* use ffmpeg to improve speed */ string videoPath(this->path); string framePath(path); string cmd = "ffmpeg -r \"" + Common::doubleToStr(this->getVideo().get(CV_CAP_PROP_FPS)) + "\" -ss " + Common::doubleToStr(startFrame / this->getVideo().get(CV_CAP_PROP_FPS)) + " -i " + videoPath + " -vframes \"" + Common::intToStr(total + 1) + "\" \"" + framePath + "f" + filename + "_%1d.png\""; /* excute the command */ FILE* captureProcess = popen(cmd.c_str(), "w"); if (captureProcess == NULL) { ostringstream os; os << "Failed to capture frames from the video"; Common::errorPrint(os.str().c_str()); /* exit */ exit(-1); } pclose(captureProcess); size_t i = 1; for (; i <= total + 1; i++) { /* save the image when output is [true] */ if (output && i >= startFrame) { string num = Common::intToStr(i); string reserved(path); images.push_back(reserved + "f" + filename + "_" + num + ".png"); } } #endif #ifndef FFMPEG /* this loop will cost too much time */ size_t i = startFrame; for (; i <= endFrame; i++) { Mat reservedImg; this->vdo.read(reservedImg); /* save the image when output is [true] */ if (output && i >= startFrame) { string num = Common::intToStr(i); string reserved(path); imwrite((reserved + filename + num + ".png").c_str(), reservedImg); images.push_back(reserved + "f" + filename + "_" + num + ".png"); cout << "save image: " + num << endl; } } #endif return images; }
bool valid(char c){ return alpha(c) || reserved(c); }
// Similar to PSYoungGen::resize_generation() but // allows sum of eden_size and 2 * survivor_size to exceed _max_gen_size // expands at the low end of the virtual space // moves the boundary between the generations in order to expand // some additional diagnostics // If no additional changes are required, this can be deleted // and the changes factored back into PSYoungGen::resize_generation(). bool ASPSYoungGen::resize_generation(size_t eden_size, size_t survivor_size) { const size_t alignment = virtual_space()->alignment(); size_t orig_size = virtual_space()->committed_size(); bool size_changed = false; // There used to be a guarantee here that // (eden_size + 2*survivor_size) <= _max_gen_size // This requirement is enforced by the calculation of desired_size // below. It may not be true on entry since the size of the // eden_size is no bounded by the generation size. assert(max_size() == reserved().byte_size(), "max gen size problem?"); assert(min_gen_size() <= orig_size && orig_size <= max_size(), "just checking"); // Adjust new generation size const size_t eden_plus_survivors = align_size_up(eden_size + 2 * survivor_size, alignment); size_t desired_size = MAX2(MIN2(eden_plus_survivors, gen_size_limit()), min_gen_size()); assert(desired_size <= gen_size_limit(), "just checking"); if (desired_size > orig_size) { // Grow the generation size_t change = desired_size - orig_size; HeapWord* prev_low = (HeapWord*) virtual_space()->low(); if (!virtual_space()->expand_by(change)) { return false; } if (ZapUnusedHeapArea) { // Mangle newly committed space immediately because it // can be done here more simply that after the new // spaces have been computed. HeapWord* new_low = (HeapWord*) virtual_space()->low(); assert(new_low < prev_low, "Did not grow"); MemRegion mangle_region(new_low, prev_low); SpaceMangler::mangle_region(mangle_region); } size_changed = true; } else if (desired_size < orig_size) { size_t desired_change = orig_size - desired_size; // How much is available for shrinking. size_t available_bytes = limit_gen_shrink(desired_change); size_t change = MIN2(desired_change, available_bytes); virtual_space()->shrink_by(change); size_changed = true; } else { if (Verbose && PrintGC) { if (orig_size == gen_size_limit()) { gclog_or_tty->print_cr("ASPSYoung generation size at maximum: " SIZE_FORMAT "K", orig_size/K); } else if (orig_size == min_gen_size()) { gclog_or_tty->print_cr("ASPSYoung generation size at minium: " SIZE_FORMAT "K", orig_size/K); } } } if (size_changed) { reset_after_change(); if (Verbose && PrintGC) { size_t current_size = virtual_space()->committed_size(); gclog_or_tty->print_cr("ASPSYoung generation size changed: " SIZE_FORMAT "K->" SIZE_FORMAT "K", orig_size/K, current_size/K); } } guarantee(eden_plus_survivors <= virtual_space()->committed_size() || virtual_space()->committed_size() == max_size(), "Sanity"); return true; }