void EvolutionGraphWidget::mousePressEvent(QMouseEvent* event) { event->accept(); if (event->button() == Qt::LeftButton) { if (event->modifiers().testFlag(Qt::ControlModifier))// + Control 的话 连接线 边加入到图中 { m_dotAddSelected=hitDot(Vector2f(event->x(), event->y())); if ( m_dotAddSelected.x>=0 && m_dotAddSelected.y>=0 ) if (m_startPoint==Vector2i(2500,2500)) { m_startPoint=m_dotAddSelected; } else { m_endPoint=m_dotAddSelected; dag.addEdge(m_startPoint,m_endPoint); m_newAddEdge=Edge(m_startPoint,m_endPoint); m_startPoint=Vector2i(2500,2500); m_endPoint=Vector2i(2500,2500); } //第一个 加入 start //第二个 } else { // see if a key was selected Vector2f sHit = Vector2f(event->x(), static_cast<float>(height()) - event->y()); Vector2f hit = stow(sHit); m_dotSelected=hitDot(Vector2f(event->x(), event->y())); cout<<m_dotSelected<<endl; if (m_dotSelected.x>=0) { m_curTimeStep=m_dotSelected.x; setupTransfunc(); emit sendTimeNumSelected(m_dotSelected.x+1); if (m_dotSelected.y>=0 && m_dotSelected.y<m_arryNumFeature[m_dotSelected.x+1]) { m_clusterNumSelected=m_dotSelected.y; m_pSelectedKey=m_keyColletionFull[m_dotSelected.x]->getKey(m_dotSelected.y); } } } update(); } }
void execinit(void) { char **p; nextv = 0; for(p = myenv; *p; p++) envinsert(*p, stow("")); symtraverse(S_VAR, ecopy); envinsert(0, 0); }
static Word* extractpat(char *s, char **r, char *term, char *end) { int save; char *cp; Word *w; cp = charin(s, term); if(cp){ *r = cp; if(cp == s) return 0; save = *cp; *cp = 0; w = stow(s); *cp = save; } else { *r = end; w = stow(s); } return w; }
static Word* subsub(Word *v, char *s, char *end) { int nmid; Word *head, *tail, *w, *h; Word *a, *b, *c, *d; Bufblock *buf; char *cp, *enda; a = extractpat(s, &cp, "=%&", end); b = c = d = 0; if(PERCENT(*cp)) b = extractpat(cp+1, &cp, "=", end); if(*cp == '=') c = extractpat(cp+1, &cp, "&%", end); if(PERCENT(*cp)) d = stow(cp+1); else if(*cp) d = stow(cp); head = tail = 0; buf = newbuf(); for(; v; v = v->next){ h = w = 0; if(submatch(v->s, a, b, &nmid, &enda)){ /* enda points to end of A match in source; * nmid = number of chars between end of A and start of B */ if(c){ h = w = wdup(c); while(w->next) w = w->next; } if(PERCENT(*cp) && nmid > 0){ if(w){ bufcpy(buf, w->s, strlen(w->s)); bufcpy(buf, enda, nmid); insert(buf, 0); free(w->s); w->s = strdup(buf->start); } else { bufcpy(buf, enda, nmid); insert(buf, 0); h = w = newword(buf->start); } buf->current = buf->start; } if(d && *d->s){ if(w){ bufcpy(buf, w->s, strlen(w->s)); bufcpy(buf, d->s, strlen(d->s)); insert(buf, 0); free(w->s); w->s = strdup(buf->start); w->next = wdup(d->next); while(w->next) w = w->next; buf->current = buf->start; } else h = w = wdup(d); } } if(w == 0) h = w = newword(v->s); if(head == 0) head = h; else tail->next = h; tail = w; } freebuf(buf); delword(a); delword(b); delword(c); delword(d); return head; }
void main(int argc, char **argv) { Word *w; char *s, *temp; char *files[256], **f = files, **ff; int sflag = 0; int i; int tfd = -1; Biobuf tb; Bufblock *buf; Bufblock *whatif; /* * start with a copy of the current environment variables * instead of sharing them */ Binit(&bout, 1, OWRITE); buf = newbuf(); whatif = 0; USED(argc); for(argv++; *argv && (**argv == '-'); argv++) { bufcpy(buf, argv[0], strlen(argv[0])); insert(buf, ' '); switch(argv[0][1]) { case 'a': aflag = 1; break; case 'd': if(*(s = &argv[0][2])) while(*s) switch(*s++) { case 'p': debug |= D_PARSE; break; case 'g': debug |= D_GRAPH; break; case 'e': debug |= D_EXEC; break; } else debug = 0xFFFF; break; case 'e': explain = &argv[0][2]; break; case 'f': if(*++argv == 0) badusage(); *f++ = *argv; bufcpy(buf, argv[0], strlen(argv[0])); insert(buf, ' '); break; case 'i': iflag = 1; break; case 'k': kflag = 1; break; case 'n': nflag = 1; break; case 's': sflag = 1; break; case 't': tflag = 1; break; case 'u': uflag = 1; break; case 'w': if(whatif == 0) whatif = newbuf(); else insert(whatif, ' '); if(argv[0][2]) bufcpy(whatif, &argv[0][2], strlen(&argv[0][2])); else { if(*++argv == 0) badusage(); bufcpy(whatif, &argv[0][0], strlen(&argv[0][0])); } break; default: badusage(); } } #ifdef PROF { extern etext(); monitor(main, etext, buf, sizeof buf, 300); } #endif if(aflag) iflag = 1; usage(); syminit(); initenv(); usage(); /* assignment args become null strings */ temp = 0; for(i = 0; argv[i]; i++) if(utfrune(argv[i], '=')){ bufcpy(buf, argv[i], strlen(argv[i])); insert(buf, ' '); if(tfd < 0){ temp = maketmp(); if(temp == 0) { perror("temp file"); Exit(); } close(create(temp, OWRITE, 0600)); if((tfd = open(temp, 2)) < 0){ perror(temp); Exit(); } Binit(&tb, tfd, OWRITE); } Bprint(&tb, "%s\n", argv[i]); *argv[i] = 0; } if(tfd >= 0){ Bflush(&tb); LSEEK(tfd, 0L, 0); parse("command line args", tfd, 1); remove(temp); } if (buf->current != buf->start) { buf->current--; insert(buf, 0); } symlook("MKFLAGS", S_VAR, (void *) stow(buf->start)); buf->current = buf->start; for(i = 0; argv[i]; i++){ if(*argv[i] == 0) continue; if(i) insert(buf, ' '); bufcpy(buf, argv[i], strlen(argv[i])); } insert(buf, 0); symlook("MKARGS", S_VAR, (void *) stow(buf->start)); freebuf(buf); if(f == files){ if(access(MKFILE, 4) == 0) parse(MKFILE, open(MKFILE, 0), 0); } else for(ff = files; ff < f; ff++) parse(*ff, open(*ff, 0), 0); if(DEBUG(D_PARSE)){ dumpw("default targets", target1); dumpr("rules", rules); dumpr("metarules", metarules); dumpv("variables"); } if(whatif){ insert(whatif, 0); timeinit(whatif->start); freebuf(whatif); } execinit(); /* skip assignment args */ while(*argv && (**argv == 0)) argv++; catchnotes(); if(*argv == 0){ if(target1) for(w = target1; w; w = w->next) mk(w->s); else { fprint(2, "mk: nothing to mk\n"); Exit(); } } else { if(sflag){ for(; *argv; argv++) if(**argv) mk(*argv); } else { Word *head, *tail, *t; /* fake a new rule with all the args as prereqs */ tail = 0; t = 0; for(; *argv; argv++) if(**argv){ if(tail == 0) tail = t = newword(*argv); else { t->next = newword(*argv); t = t->next; } } if(tail->next == 0) mk(tail->s); else { head = newword("command line arguments"); addrules(head, tail, strdup(""), VIR, mkinline, 0); mk(head->s); } } } if(uflag) prusage(); exits(0); }
/* ***************************************************************************** * finitestatemachine (fsm) * ***************************************************************************** * The finite state machine, containing an array of all possible microstates the * computer can be in. Apart from containing the ROM of microstates, relies on * external control by the LC2200 to progress to the next finite state. Used for * state transition by flipping the appropriate load, drive, and write switches * and updating the state to be next executed. The fsm is organized with the * first 10 bits representing the current state's opcode, z-value, and state-- * these are used for finding the next appropriate state later. The next 13 bits * tell the control unit what drive, load, and write signals should be on or * off. The next 5 bits tell the control unit what function the alu should * execute and which of the three registers the ir should drive. * * Layout of FSM by line: * sig opcode z-value state drive load write alufunc irreg nextstate * com - - - PARMO PABMIZ MR - - - * idx 0123 4 56789 01234 567890 12 345 67 8901 * bin 0000 0 00000 00000 000000 00 000 00 0000 * * For bit flipping and signaling, when updating, the fsm will provide bit * switches to explain how each current state should determine the next * sequential state by using the last four bits in the microstate line. It is * expected that the control unit take care of the following conditions: if the * current state is ifetch3, the bit sequence 1000 will search only opcodes * using the opcode in the ir; if the current state is beq3, the control unit * reads primes the z-value by triggering the alu. The default starting state * upon boot-up is at ifetch1. */ fsm_ fsm_ctor() { int romaddress; finitestatemachine *fsm = malloc(sizeof(finitestatemachine)); fsm->state = 0; //ifetch1 /* MICROSTATE BIT DETAIL * * MICROSTATE ROM LAYOUT * op z st dr ld wr fn rg + * code - ##### PARMO PABMIZ MR ### ## OZ+S * 0123 4 56789 01234 567890 12 345 67 8901 * * op 0123 the opcode address of the command * z 4 the z address of the command * st 56789 the state address of the command * dr 01234 drive bits in order: PC,ALU,REG,MEM,OFF * ld 567890 load bits in order: PC,ALU-A,ALU-B,MAR,IR,Z * wr 12 write bits in order: MEM,REG * fn 345 function bits to ALU * rg 67 register bits to IR * + 8901 how to go to the next step: * O 27: use opcode in address * Z 28: use z-val in address * + 29: increment and use state in address * S 30: whether to invoke callee-save * */ word states[] = {/* FETCH */ /* op z st dr ld wr fn rg + * code - ##### PARMO PABMIZ MR ### ## OZ+S * 0123 4 56789 01234 567890 12 345 67 8901 */ /*ifetch1*/stow("1111 0 00000 10000 010100 00 000 00 0010"),//0 /*ifetchc*/stow("1111 0 10011 00000 000000 00 000 00 0000"),//1 /*ifetch2*/stow("1111 0 00001 00010 000010 00 000 00 0010"),//2 /*ifetch3*/stow("1111 0 00010 01000 100000 00 011 00 1000"),//3 /* ADD */ /* op z st dr ld wr fn rg + * code - ##### PARMO PABMIZ MR ### ## OZ+S * 0123 4 56789 01234 567890 12 345 67 8901 */ /*add1 */stow("0000 0 10000 00100 010000 00 000 01 1010"),//4 /*add2 */stow("0000 0 10001 00100 001000 00 000 10 1010"),//5 /*add3 */stow("0000 0 10010 01000 000000 01 000 00 0000"),//6 /* NAND */ /* op z st dr ld wr fn rg + * code - ##### PARMO PABMIZ MR ### ## OZ+S * 0123 4 56789 01234 567890 12 345 67 8901 */ /*nand1 */stow("0001 0 10000 00100 010000 00 000 01 1010"),//7 /*nand2 */stow("0001 0 10001 00100 001000 00 000 10 1010"),//8 /*nand3 */stow("0001 0 10010 01000 000000 01 001 00 0000"),//9 /* ADDI */ /* op z st dr ld wr fn rg + * code - ##### PARMO PABMIZ MR ### ## OZ+S * 0123 4 56789 01234 567890 12 345 67 8901 */ /*addi1 */stow("0010 0 10000 00100 010000 00 000 01 1010"),//10 /*addi2 */stow("0010 0 10001 00001 001000 00 000 10 1010"),//11 /*addi3 */stow("0010 0 10010 01000 000000 01 000 00 0000"),//12 /* LW */ /* op z st dr ld wr fn rg + * code - ##### PARMO PABMIZ MR ### ## OZ+S * 0123 4 56789 01234 567890 12 345 67 8901 */ /*lw1 */stow("0011 0 10000 00100 010000 00 000 01 1010"),//13 /*lw2 */stow("0011 0 10001 00001 001000 00 000 00 1010"),//14 /*lw3 */stow("0011 0 10010 01000 000100 00 000 00 1010"),//15 /*lw4 */stow("0011 0 10011 00010 000000 01 000 00 0000"),//16 /* SW */ /* op z st dr ld wr fn rg + * code - ##### PARMO PABMIZ MR ### ## OZ+S * 0123 4 56789 01234 567890 12 345 67 8901 */ /*sw1 */stow("0100 0 10000 00100 010000 00 000 01 1010"),//17 /*sw2 */stow("0100 0 10001 00001 001000 00 000 00 1010"),//18 /*sw3 */stow("0100 0 10010 01000 000100 00 000 00 1010"),//19 /*sw4 */stow("0100 0 10011 00100 000000 10 000 00 0000"),//20 /* BEQ */ /* op z st dr ld wr fn rg + * code - ##### PARMO PABMIZ MR ### ## OZ+S * 0123 4 56789 01234 567890 12 345 67 8901 */ /*beq1 */stow("0101 0 10000 00100 010000 00 000 00 1010"),//21 /*beq2 */stow("0101 0 10001 00100 001000 00 000 01 1010"),//22 /*beq3 */stow("0101 0 10010 01000 000001 00 010 00 0110"),//23 /*beq4 */stow("0101 1 10011 10000 010000 00 000 00 1010"),//24 /*beq5 */stow("0101 0 10100 00001 001000 00 000 00 1010"),//25 /*beq6 */stow("0101 0 10101 01000 100000 00 000 00 0000"),//26 /* JALR */ /* op z st dr ld wr fn rg + * code - ##### PARMO PABMIZ MR ### ## OZ+S * 0123 4 56789 01234 567890 12 345 67 8901 */ /*jalr1 */stow("0110 0 10000 10000 000000 01 000 01 1010"),//27 /*jalr2 */stow("0110 0 10001 00100 010000 00 000 00 1010"),//28 /*jalr3 */stow("0110 0 10010 00001 001000 00 000 10 1010"),//29 /*jalr4 */stow("0110 0 10011 01000 100000 00 000 00 0000"),//30 // note: JALR has been modified to additionally read immediate // values and add them to the second register's value // to determine the pc value--similar to addi, lw, sw, beq /* HALT */ /* op z st dr ld wr fn rg + * code - ##### PARMO PABMIZ MR ### ## OZ+S * 0123 4 56789 01234 567890 12 345 67 8901 */ /*halt */stow("0111 0 10000 00000 000000 00 000 00 0000") //31 // APPENDIX //// | | | | | //// CODE STATE | PC ALU REG MEM OFF | PC A B MAR IR Z | MEM REG | FUNC REGNO | M T /* ORIGNAL JALR REGISTER ONLY CODE: */ /*jalr1 stow("0110 0 10000 10000 000000 01 000 01 1010"),//27*/ /*jalr2 stow("0110 0 10001 00100 100000 00 000 00 0000"),//28*/ }; for(romaddress = 0; romaddress < ROM_SIZE; romaddress++) fsm->ROM[romaddress] = states[romaddress]; return fsm; }
/* OPEN FILE * ----------------------------------------------------------------------------- * Opens the file. */ static void open_file(FILE *inputfile) { FILE *asmfile = fopen("asm_convert", "w"); FILE *parsefile; // printf("%d", fgetc(file)); char **binary; char lastline[WORD_LEN+1]; char line[WORD_LEN+1]; char data[WORD_LEN+1]; int row = 0; int col = 0; // char *line = NULL; // size_t len = 0; // ssize_t read; int r; int c; int plusone = 0; int rows = 0; if (inputfile) { while ((c = getc(inputfile)) != EOF) { if (c < 128) fprintf(asmfile, "%c", c); // printf("%d\n",c); } // putchar(c); fclose(inputfile); fclose(asmfile); } printf("------------------------------\n"); parsefile = fopen("asm_convert", "r"); // if (parsefile) { // while ((c = getc(parsefile)) != EOF) { //// if (c < 128) //// fprintf(asmfile, "%c", c); // printf("%d\n",c); //// putchar(c); // } // fclose(inputfile); // fclose(asmfile); // } // if (true) return; binary = getAllInstructions(parsefile, &row, &col); // if (true) return; printf("%d %d\n", row, col); // while ((read = getline(&line, &len, )) != -1) { // printf("Retrieved line of length %zu :\n", read); // printf("%s", line); // } for (c = WORD_LEN; c < WORD_LEN * 2; c++) { line[c-WORD_LEN] = binary[0][c]; } line[WORD_LEN] = 0; printf("LINE:%s\n", line); LC2200->pc->pc = stow(line); printf("PC:%lu %s\n", LC2200->pc->pc, wtos(LC2200->pc->pc)); for (c = 0; c < WORD_LEN ; c++) { lastline[c] = '1'; } // lastline = "11111111111111111111111111111111"; lastline[WORD_LEN] = 0; // if (true) return; for (r = 1; r < row; r++) { for (c = 0; c < WORD_LEN; c++) { line[c] = binary[r][c]; } line[WORD_LEN] = 0; // line // if (stow(line) == stow(lastline)) plusone = 1; // else plusone = 0; //// LC2200->pc->pc = stow(line); // for (c = 0; c < WORD_LEN ; c++) { // lastline[c] = bitt(wtos(stow(line) + plusone), c)+'0'; // } // // for (c = 0; c < WORD_LEN ; c++) { // line[c] = bitt(lastline, c)+'0'; // } //// lastline = wtos(stow(line) + plusone); // printf("LINE:%s\n", line); for (c = WORD_LEN; c < WORD_LEN * 2; c++) { data[c-WORD_LEN] = binary[r][c]; } data[WORD_LEN] = 0; printf("DATA:%s\n", data); LC2200->mem->MEM[stow(line)+plusone] = stow(data); printf("MEM:%lu %s\n", LC2200->mem->MEM[stow(line)+plusone], wtos(LC2200->mem->MEM[stow(line)+plusone])); // while(binary[rows] != NULL) { printf("012345678901234567890123456789012345678901234567890123456789012345\n"); printf("\nassembly instruction at row %d is %s\n", r, binary[r]); plusone++; // rows++; } LC2200->mem->MEM[stow(line)+plusone+1] = stow("0111 0000 0000 0000 0000 0000 0000 0000"); //halt fclose(parsefile); }
DWORD InstallThread::proc(LPVOID args) { InstallThread* thread = static_cast<InstallThread*>(args); thread->setRunning(true); // TODO: check dependencies // check conflicts int failed = 0; std::vector<json::Addon> conflicts1 = thread->_toRemove.removeConflicted(); // this will probably never happen size_t i, len = conflicts1.size(); failed += len; for (i = 0; i < len; i++) LOG_ERR(L"Addon %s conflicts with other addon", stow(conflicts1[i].getId()).c_str()); std::vector<json::Addon> conflicts2 = thread->_toInstall.removeConflicted(); i, len = conflicts2.size(); failed += len; for (i = 0; i < len; i++) LOG_ERR(L"Addon %s conflicts with other addon", stow(conflicts2[i].getId()).c_str()); // remove wtwUtils::Settings s; i, len = thread->_toRemove.size(); int removed = 0; for (i = 0; i < len; i++) { const json::Addon& addon = thread->_toRemove[i]; if (addon.getState() == json::Addon::INSTALLED) { AddonDeleter deleter(addon); deleter.del(s) ? removed++ : failed++; } if (thread->isAborted()) { thread->setRunning(false); return 0; } } // install len = thread->_toInstall.size(); int installed = 0, updated = 0; for (i = 0; i < len; i++) { const json::Addon& addon = thread->_toInstall[i]; if (addon.getState() == json::Addon::INSTALLED) continue; utils::BinaryFile f; utils::Http http; if (http.download2file(stow(addon.getZipUrl()).c_str(), &f)) { ZipFile zip(f.getPath()); if (!zip.isValid()) { LOG_ERR(L"Zip file for %s is invalid", stow(addon.getId()).c_str()); failed++; } else if (!zip.unzip()) { LOG_ERR(L"Failed to install (unzip) %s", stow(addon.getId()).c_str()); failed++; } else { s.setInt64(stow(addon.getId()).c_str(), addon.getTime()); s.write(); switch (addon.getState()) { case json::Addon::NOT_INSTALLED: installed++; break; case json::Addon::MODIFIED: updated++; break; } } } else LOG_ERR(L"Failed to download %s", stow(addon.getZipUrl()).c_str()); f.del(); if (thread->isAborted()) { thread->setRunning(false); return 0; } } notify(L"Zainstalowano %u, zaktualizowano %u, usunięto %u, błędów %u", installed, updated, removed, failed); thread->_toInstall.clear(); thread->_toRemove.clear(); thread->setRunning(false); return 0; }
static int rhead(char *line, Word **h, Word **t, int *attr, char **prog) { char *p; char *pp; int sep; Rune r; int n; Word *w; p = charin(line,":=<"); if(p == 0) return('?'); sep = *p; *p++ = 0; if(sep == '<' && *p == '|') { sep = '|'; p++; } *attr = 0; *prog = 0; if(sep == '=') { pp = charin(p, termchars); /* termchars is shell-dependent */ if (pp && *pp == '=') { while (p != pp) { n = chartorune(&r, p); switch(r) { default: SYNERR(-1); fprint(2, "unknown attribute '%c'\n",*p); Exit(); case 'U': *attr = 1; break; } p += n; } p++; /* skip trailing '=' */ } } if((sep == ':') && *p && (*p != ' ') && (*p != '\t')) { while (*p) { n = chartorune(&r, p); if (r == ':') break; p += n; switch(r) { default: SYNERR(-1); fprint(2, "unknown attribute '%c'\n", p[-1]); Exit(); case 'D': *attr |= DEL; break; case 'E': *attr |= NOMINUSE; break; case 'n': *attr |= NOVIRT; break; case 'N': *attr |= NOREC; break; case 'P': pp = utfrune(p, ':'); if (pp == 0 || *pp == 0) goto eos; *pp = 0; *prog = strdup(p); *pp = ':'; p = pp; break; case 'Q': *attr |= QUIET; break; case 'R': *attr |= REGEXP; break; case 'U': *attr |= UPD; break; case 'V': *attr |= VIR; break; } } if (*p++ != ':') { eos: SYNERR(-1); fprint(2, "missing trailing :\n"); Exit(); } } *h = w = stow(line); if(*w->s == 0 && sep != '<' && sep != '|') { SYNERR(mkinline-1); fprint(2, "no var on left side of assignment/rule\n"); Exit(); } *t = stow(p); return(sep); }
void testBits(LC2200_ LC2200) { word w = stow("1001"); printf("I am %lu\n", w); }
void testSystem(LC2200_ LC2200) { debug(LC2200); LC2200->pc->pc = 0; LC2200->reg->REG[3] = stow("0000 0000 0000 0000 0000 0000 0000 1110"); //reg3 starts at 14 LC2200->mem->MEM[0] = stow("0101 0011 0000 0000 0000 0000 0000 1011"); //beq fail LC2200->mem->MEM[1] = stow("0010 0101 0011 1111 1111 1111 1111 1100"); //reg5 =adds -4 to reg3 LC2200->mem->MEM[2] = stow("0010 1010 0011 0000 0000 0000 0000 0100"); //reg10=adds 4 to reg3 LC2200->mem->MEM[3] = stow("0000 0000 0000 0000 0000 0000 0000 0101"); //attempts to add reg5 to $zero LC2200->mem->MEM[4] = stow("0000 1110 0011 0000 0000 0000 0000 0101"); //reg14=reg3+reg5 LC2200->mem->MEM[5] = stow("0001 0010 0011 0000 0000 0000 0000 0011"); //reg2=reg3nandreg3 LC2200->mem->MEM[6] = stow("0010 0100 0000 0000 0000 0000 0000 0010"); //reg4+=2 LC2200->mem->MEM[7] = stow("0011 0110 0100 0000 0000 0000 0000 0100"); //reg6=mem[reg4+4] LC2200->mem->MEM[8] = stow("0100 1010 0011 0000 0000 0000 0000 0101"); //mem[reg3+5]=reg10 LC2200->mem->MEM[9] = stow("0010 0100 0100 0000 0000 0000 0000 0001"); //reg4++ LC2200->mem->MEM[10]= stow("0011 0010 0100 0000 0000 0000 0000 0000"); //reg2=mem[reg4] LC2200->mem->MEM[11]= stow("0110 0011 1111 0000 0000 0000 0000 0000"); //jump to 14 LC2200->mem->MEM[12]= stow("0111 0000 0000 0000 0000 0000 0000 0000"); //halt (jumped) LC2200->mem->MEM[13]= stow("0111 0000 0000 0000 0000 0000 0000 0000"); //halt (jumped) LC2200->mem->MEM[14]= stow("0100 0110 0011 0000 0000 0000 0000 0001"); //mem[reg3+1] = reg6 LC2200->mem->MEM[15]= stow("0111 0000 0000 0000 0000 0000 0000 0000"); //halt (overwritten) LC2200->mem->MEM[16]= stow("0101 0000 0000 0000 0000 0000 0000 0011"); //beq->pc19 LC2200->mem->MEM[17]= stow("0111 0000 0000 0000 0000 0000 0000 0000"); //halt LC2200->mem->MEM[18]= stow("0111 0000 0000 0000 0000 0000 0000 0000"); //halt LC2200->mem->MEM[19]= stow("0111 0000 0000 0000 0000 0000 0000 0000"); //halt (overwritten) LC2200->mem->MEM[20]= stow("0110 0000 0000 0000 0000 0000 0001 1000"); //jump pc24 LC2200->mem->MEM[21]= stow("0111 0000 0000 0000 0000 0000 0000 0000"); //halt LC2200->mem->MEM[22]= stow("0111 0000 0000 0000 0000 0000 0000 0000"); //halt LC2200->mem->MEM[23]= stow("0111 0000 0000 0000 0000 0000 0000 0000"); //halt LC2200->mem->MEM[24]= stow("0010 1000 1000 0000 0000 0000 0100 0000"); //reg8=reg8+64 LC2200->mem->MEM[25]= stow("0111 0000 0000 0000 0000 0000 0000 0000"); //halt LC2200->mem->MEM[50]= stow("0111 0000 0000 0000 0000 0000 0000 0000"); //emergency halt // LC2200->safetydebug = true; LC2200->statedebug = true; // LC2200->microdebug = true; // start(LC2200, 'h'); }
uint32_t Iconv::charCodeAt(const string& ansiStr, uint32_t idx) { return stow(ansiStr)[idx]; }
string Iconv::stou8(const string& s) { return wtou8(stow(s)); }