vtkPolyData* Foam::vtkPV3Foam::patchVTKMesh ( const polyPatch& p ) { vtkPolyData* vtkmesh = vtkPolyData::New(); if (debug) { Info<< "<beg> Foam::vtkPV3Foam::patchVTKMesh - " << p.name() << endl; printMemory(); } // Convert Foam mesh vertices to VTK const Foam::pointField& points = p.localPoints(); vtkPoints *vtkpoints = vtkPoints::New(); vtkpoints->Allocate( points.size() ); forAll(points, i) { vtkPV3FoamInsertNextPoint(vtkpoints, points[i]); }
vtkPolyData* Foam::vtkPV4Foam::patchVTKMesh ( const word& name, const PatchType& p ) { vtkPolyData* vtkmesh = vtkPolyData::New(); if (debug) { Info<< "<beg> Foam::vtkPV4Foam::patchVTKMesh - " << name << endl; printMemory(); } // Convert OpenFOAM mesh vertices to VTK const Foam::pointField& points = p.localPoints(); vtkPoints* vtkpoints = vtkPoints::New(); vtkpoints->Allocate(points.size()); forAll(points, i) { vtkInsertNextOpenFOAMPoint(vtkpoints, points[i]); }
int executeUserCommand(char *assembly, char *bin, struct Processor *proc, char **tokens, int *breakPoints) { if (strcmp(tokens[0], "reg")==0) { tokens++; printReg(proc, tokens); return 0; } else if (strcmp(tokens[0], "mem")==0) { tokens++; printMemory(proc, tokens); return 0; } else if (strcmp(tokens[0], "pc")==0) { printPC(proc); return 0; } else if (strcmp(tokens[0], "search")==0) { tokens++; search(proc, tokens); return 0; } else if (strcmp(tokens[0], "stp")==0) { step(proc); return 0; } else if (strcmp(tokens[0], "list")==0) { listInstruction(assembly, ((proc->pc)/4)+1); return 0; } else if (strcmp(tokens[0], "--help")==0) { system("cat help.txt | less"); return 0; } else if (strcmp(tokens[0], "run")==0) { run(proc,breakPoints); return 0; } else if (strcmp(tokens[0],"q")==0) { return confirmToQuit(); } else if (strcmp(tokens[0],"break")==0) { setBreakPoints(breakPoints,tokens+1); return 0; } return 0; }
/* The main program */ int main() { int initBytes = 0; int numBytes = 0; int pid = 0; //Initialize memory and get rid of newline at the end scanf("%d", &initBytes); initializeMemory(initBytes); //Grab the command and call the appropiate method char c = getchar(); while(c != EOF) { if(!isspace(c)) printf("%c\n", c); if(c == 'A') //allocate { scanf("%d", &numBytes); scanf("%d", &pid); allocate(numBytes, pid); } else if(c == 'D') //deallocate { scanf("%d", &pid); deallocate(pid); } else if(c == 'P') //print memory printMemory(); else if(isspace(c)) ; // do nothing but don't hit the else else fprintf(stderr, "Invalid command, must be 'A' 'D' or 'P'"); c = getchar(); } }
/** * Executes one instruction */ void clockTick(int sig) { //Uses bit manipulation to isolate all values int instruction = (instructionMemory[programCounter] >> 26) & 0x3f; //000111111 int field1 = instructionMemory[programCounter] >> 21 & 0x01f; //00000011111; int field2 = (instructionMemory[programCounter] >> 16) & 0x01f; //0000000000011111; int field3 = (instructionMemory[programCounter] >> 11) & 0x01f; //000000000000000011111; int field5 = instructionMemory[programCounter] & 0x03f; //00000000000000000000000000111111; int addressField = instructionMemory[programCounter] & 0x0000ffff; //00000000000000001111111111111111; int jType = instructionMemory[programCounter] & 0x03ffffff ; //00000011111111111111111111111111 //Print Summary printf("\nProgram Counter: %d op: %d field1: %d field2: %d field3 Register: %d address: %d\n", programCounter, instruction, registers[field1].value, registers[field2].value, field3, addressField); switch(instruction) { //add or subtract case 0: switch(field5) { //add case 32:; int sum = registers[field1].value + registers[field2].value; changeRegisterValue(®isters[field3], sum); programCounter++; break; //subtract case 34:; int difference = registers[field1].value - registers[field2].value; changeRegisterValue(®isters[field3], difference); programCounter++; break; //slt case 42:; int lessThan = 0; if(registers[field1].value < registers[field2].value) { lessThan = 1; } changeRegisterValue(®isters[field3], lessThan); programCounter++; break; //and case 36:; int andValue = 0; if(registers[field1].value == 1 && registers[field2].value == 1) { andValue = 1; } changeRegisterValue(®isters[field3], andValue); programCounter++; break; //end case 12:; flag = 1; //call exit break; } break; //addi case 8:; int sum = registers[field1].value + addressField; changeRegisterValue(®isters[field2], sum); programCounter++; break; //sw case 43:; int address1 = registers[field1].value + addressField; memory[address1] = registers[field2].value; programCounter++; break; //j case 2:; int moveTo = (jType-(4194304/4))-9; //this could be off by 1 programCounter = moveTo; break; //beq case 4:; if(registers[field1].value == registers[field2].value) { programCounter = programCounter + addressField; } else { programCounter++; } break; //illegal operation default:; flag = 1; break; } printf("REGISTERS\n"); printRegisters(); printf("MEMORY\n"); printMemory(); printf("\n"); //Call next alarm alarm(1); }
vtkUnstructuredGrid* Foam::vtkPV3Foam::volumeVTKMesh ( const fvMesh& mesh, polyDecomp& decompInfo ) { const cellModel& tet = *(cellModeller::lookup("tet")); const cellModel& pyr = *(cellModeller::lookup("pyr")); const cellModel& prism = *(cellModeller::lookup("prism")); const cellModel& wedge = *(cellModeller::lookup("wedge")); const cellModel& tetWedge = *(cellModeller::lookup("tetWedge")); const cellModel& hex = *(cellModeller::lookup("hex")); vtkUnstructuredGrid* vtkmesh = vtkUnstructuredGrid::New(); if (debug) { Info<< "<beg> Foam::vtkPV3Foam::volumeVTKMesh" << endl; printMemory(); } const cellShapeList& cellShapes = mesh.cellShapes(); // Number of additional points needed by the decomposition of polyhedra label nAddPoints = 0; // Number of additional cells generated by the decomposition of polyhedra label nAddCells = 0; // face owner is needed to determine the face orientation const labelList& owner = mesh.faceOwner(); labelList& superCells = decompInfo.superCells(); labelList& addPointCellLabels = decompInfo.addPointCellLabels(); // Scan for cells which need to be decomposed and count additional points // and cells if (!reader_->GetUseVTKPolyhedron()) { if (debug) { Info<< "... scanning for polyhedra" << endl; } forAll(cellShapes, cellI) { const cellModel& model = cellShapes[cellI].model(); if ( model != hex && model != wedge && model != prism && model != pyr && model != tet && model != tetWedge ) { const cell& cFaces = mesh.cells()[cellI]; forAll(cFaces, cFaceI) { const face& f = mesh.faces()[cFaces[cFaceI]]; label nQuads = 0; label nTris = 0; f.nTrianglesQuads(mesh.points(), nTris, nQuads); nAddCells += nQuads + nTris; } nAddCells--; nAddPoints++; } } } // Set size of additional point addressing array // (from added point to original cell) addPointCellLabels.setSize(nAddPoints); // Set size of additional cells mapping array // (from added cell to original cell) if (debug) { Info<<" mesh nCells = " << mesh.nCells() << nl <<" nPoints = " << mesh.nPoints() << nl <<" nAddCells = " << nAddCells << nl <<" nAddPoints = " << nAddPoints << endl; } superCells.setSize(mesh.nCells() + nAddCells); if (debug) { Info<< "... converting points" << endl; } // Convert OpenFOAM mesh vertices to VTK vtkPoints* vtkpoints = vtkPoints::New(); vtkpoints->Allocate(mesh.nPoints() + nAddPoints); const Foam::pointField& points = mesh.points(); forAll(points, i) { vtkInsertNextOpenFOAMPoint(vtkpoints, points[i]); }
void Foam::vtkPVFoam::convertMeshPatches ( vtkMultiBlockDataSet* output, int& blockNo ) { arrayRange& range = arrayRangePatches_; range.block(blockNo); // set output block label datasetNo = 0; // restart at dataset 0 const fvMesh& mesh = *meshPtr_; const polyBoundaryMesh& patches = mesh.boundaryMesh(); if (debug) { Info<< "<beg> Foam::vtkPVFoam::convertMeshPatches" << endl; printMemory(); } for (int partId = range.start(); partId < range.end(); ++partId) { if (!partStatus_[partId]) { continue; } const word patchName = getPartName(partId); labelHashSet patchIds(patches.patchSet(List<wordRe>(1, wordRe(patchName)))); if (debug) { Info<< "Creating VTK mesh for patches [" << patchIds <<"] " << patchName << endl; } vtkPolyData* vtkmesh = nullptr; if (patchIds.size() == 1) { vtkmesh = patchVTKMesh(patchName, patches[patchIds.begin().key()]); } else { // Patch group. Collect patch faces. label sz = 0; forAllConstIter(labelHashSet, patchIds, iter) { sz += patches[iter.key()].size(); } labelList meshFaceLabels(sz); sz = 0; forAllConstIter(labelHashSet, patchIds, iter) { const polyPatch& pp = patches[iter.key()]; forAll(pp, i) { meshFaceLabels[sz++] = pp.start()+i; } } UIndirectList<face> fcs(mesh.faces(), meshFaceLabels); uindirectPrimitivePatch pp(fcs, mesh.points()); vtkmesh = patchVTKMesh(patchName, pp); } if (vtkmesh) { AddToBlock(output, vtkmesh, range, datasetNo, patchName); vtkmesh->Delete(); partDataset_[partId] = datasetNo++; } }
void Foam::vtkPV3Foam::convertMeshCellSets ( vtkMultiBlockDataSet* output ) { if (debug) { Info<< "<beg> Foam::vtkPV3Foam::convertMeshCellSets" << endl; printMemory(); } const selectionInfo& selector = selectInfoCellSets_; vtkDataArraySelection* arraySelection = reader_->GetRegionSelection(); // Create the cell sets and add as dataset if (selector.size()) { const fvMesh& mesh = *meshPtr_; for ( int regionId = selector.start(); regionId < selector.end(); ++regionId) { if (!selectedRegions_[regionId]) { continue; } word selectName = getFirstWord ( arraySelection->GetArrayName(regionId) ); if (debug) { Info<< "Creating VTK mesh for cellSet: " << selectName << " region index: " << regionId << endl; } const cellSet cSet(mesh, selectName); fvMeshSubset subsetter ( IOobject ( "set", mesh.time().constant(), mesh, IOobject::NO_READ, IOobject::NO_WRITE ), mesh ); subsetter.setLargeCellSubset(cSet); const label datasetId = GetNumberOfDataSets(output, selector); vtkUnstructuredGrid* vtkmesh = vtkUnstructuredGrid::New(); addVolumeMesh ( subsetter.subMesh(), vtkmesh, csetSuperCells_[datasetId] ); // renumber - superCells must contain global cell ids inplaceRenumber ( subsetter.cellMap(), csetSuperCells_[datasetId] ); AddToBlock ( output, selector, datasetId, vtkmesh, selectName + ":cellSet" ); selectedRegionDatasetIds_[regionId] = datasetId; vtkmesh->Delete(); } } if (debug) { Info<< "<end> Foam::vtkPV3Foam::convertMeshCellSets" << endl; printMemory(); } }
int main(void) { irmemloc = (u32*) memalign(0x1000, 0x1000); resultStartup = IRU_Initialize(irmemloc, 0x1000); resultSetBit = IRU_SetBitRate(0xB); recordedIR = (u32*) malloc(REC_SIZE * NUM_OF_BUTTONS); //Currently there are 11(NUM_OF_BUTTONS) recordable buttons. (start switches mode) recentIR = (u32*) calloc(REC_SIZE, 0x1); //Whatever was last viewed in memory resultGetStatus = irucmd_GetTransferState(&StatusIR); srvInit(); // services aptInit(); // applets hidInit(NULL); // input gfxInitDefault(); // gfx gfxSetDoubleBuffering(GFX_TOP, true); gfxSetDoubleBuffering(GFX_BOTTOM, true); bot = gfxGetFramebuffer(GFX_BOTTOM, GFX_LEFT, NULL, NULL); top = gfxGetFramebuffer(GFX_TOP, GFX_LEFT, NULL, NULL); if(setjmp(exitJmp)) goto exit; clearScreen(); gfxFlushBuffers(); gfxSwapBuffers(); bool startToggle = false; bool upToggle = false; bool downToggle = false; while(aptMainLoop()) { bot = gfxGetFramebuffer(GFX_BOTTOM, GFX_LEFT, NULL, NULL); top = gfxGetFramebuffer(GFX_TOP, GFX_LEFT, NULL, NULL); hidScanInput(); irrstScanInput(); u32 kHeld = hidKeysHeld(); circlePosition circlePad; circlePosition cStick; hidCstickRead(&cStick); hidCircleRead(&circlePad); touchPosition touch; touchRead(&touch); clearScreen(); char keys[30] = "ABXY URDL SEST LR ZLZR"; if(kHeld & KEY_A) { keys[0] = '*'; ir('A'); } if(kHeld & KEY_B) { keys[1] = '*'; ir('B'); } if(kHeld & KEY_X) { keys[2] = '*'; ir('X'); } if(kHeld & KEY_Y) { keys[3] = '*'; ir('Y'); } if(kHeld & KEY_DUP) { keys[5] = '*'; if(upToggle) { if(bitrate < 18) { bitrate++; resultSetBit = IRU_SetBitRate(bitrate); } upToggle = false; } } else { upToggle = true; } if(kHeld & KEY_DRIGHT) { keys[6] = '*'; ir('R'); } if(kHeld & KEY_DDOWN) { keys[7] = '*'; if(downToggle) { if(bitrate > 3) { bitrate--; resultSetBit = IRU_SetBitRate(bitrate); } downToggle = false; } } else { downToggle = true; } if(kHeld & KEY_DLEFT) { keys[8] = '*'; ir('L'); } if(kHeld & KEY_SELECT) { keys[10] = '*'; keys[11] = '*'; ir('S'); } if(kHeld & KEY_START) { keys[12] = '*'; keys[13] = '*'; if(startToggle) { rec = !rec; startToggle = false; } } else { startToggle = true; } if(kHeld & KEY_L) { keys[15] = '*'; ir('L'); } if(kHeld & KEY_R) { keys[16] = '*'; ir('R'); } if(kHeld & KEY_ZL) { keys[18] = '*'; keys[19] = '*'; ir('1'); } if(kHeld & KEY_ZR) { keys[20] = '*'; keys[21] = '*'; ir('2'); } drawString(top, 10, 10, keys); drawString(top, 10, 20, "Circle Pad x: %04+d, y: %04+d", circlePad.dx, circlePad.dy); drawString(top, 10, 30, "Touch x: %04d, y: %04d", touch.px, touch.py ); if(resultStartup == 0) { drawString(top, 10, 40, "IR started!"); } else { drawString(top, 10, 40, "IR Init |Error: %x", resultStartup); } if(resultSetBit == 0) { drawString(top, 10, 50, "IR bit rate works!"); } else { drawString(top, 10, 50, "IR bit rate |Error: %x", resultSetBit); } if(resultTransferIR == 0) { drawString(top, 10, 60, "IR transfer works!"); } else { drawString(top, 10, 60, "IR transfer |Error: %x", resultTransferIR); } irucmd_GetTransferState(&StatusIR); drawString(top, 10, 70, "IR mode: %x", StatusIR); drawString(top, 10, 80, "Got %d bytes", TransIR); drawString(top, 10, 90, "Bitrate: %d (see IRU:SetBitRate)", bitrate); printMemory(NULL,REC_SIZE,10, false); //might be dangerous? if(rec) { drawString(top, 10, 210, "Recording mode active."); }else{ drawString(top, 10, 210, "Sending mode active."); } drawString(top, 10, 220, "Start + Select to exit."); if((kHeld & KEY_START) && (kHeld & KEY_SELECT)) longjmp(exitJmp, 1); gfxFlushBuffers(); gspWaitForVBlank(); gfxSwapBuffers(); } exit: //I should really be fixing these. free(recordedIR); //Crashes the program. Should free on release. free(irmemloc); //Crashes the program. Should free on release. free(recentIR); //Crashes the program. Should free on release. IRU_Shutdown(); //Crashes the program. Should free on release. gfxExit(); hidExit(); aptExit(); srvExit(); return 0; }
void Foam::vtkPV3Foam::convertMeshCellSets ( vtkMultiBlockDataSet* output, int& blockNo ) { partInfo& selector = partInfoCellSets_; selector.block(blockNo); // set output block label datasetNo = 0; // restart at dataset 0 const fvMesh& mesh = *meshPtr_; // resize for decomposed polyhedra csetPolyDecomp_.setSize(selector.size()); if (debug) { Info<< "<beg> Foam::vtkPV3Foam::convertMeshCellSets" << endl; printMemory(); } for (int partId = selector.start(); partId < selector.end(); ++partId) { const word partName = getPartName(partId); if (!partStatus_[partId]) { continue; } if (debug) { Info<< "Creating VTK mesh for cellSet=" << partName << endl; } const cellSet cSet(mesh, partName); fvMeshSubset subsetMesh ( IOobject ( "set", mesh.time().constant(), mesh, IOobject::NO_READ, IOobject::NO_WRITE ), mesh ); subsetMesh.setLargeCellSubset(cSet); vtkUnstructuredGrid* vtkmesh = volumeVTKMesh ( subsetMesh.subMesh(), csetPolyDecomp_[datasetNo] ); if (vtkmesh) { // superCells + addPointCellLabels must contain global cell ids inplaceRenumber ( subsetMesh.cellMap(), csetPolyDecomp_[datasetNo].superCells() ); inplaceRenumber ( subsetMesh.cellMap(), csetPolyDecomp_[datasetNo].addPointCellLabels() ); // copy pointMap as well, otherwise pointFields fail csetPolyDecomp_[datasetNo].pointMap() = subsetMesh.pointMap(); AddToBlock(output, vtkmesh, selector, datasetNo, partName); vtkmesh->Delete(); partDataset_[partId] = datasetNo++; } } // anything added? if (datasetNo) { ++blockNo; } if (debug) { Info<< "<end> Foam::vtkPV3Foam::convertMeshCellSets" << endl; printMemory(); } }
/* * function processes each command the user enters * returns 1 if step or continue * returns 0 on success * returns -1 on error */ int runCommand(char command[]) { char *name = strtok(command, " "); char *arg1, *arg2, *arg3; int arg1value, arg2value; struct address translatedAddr; if(strcmp(name,"help")==0 || strcmp(name,"h")==0) //"help" to display all commands { printf("\n step / s\n\t Single step the exection\n\n"); printf(" continue / c\n\t Continue to next breakpoint \n\n"); printf(" reg / r \n\t Prints the value of all registers \n\n"); printf(" reg / r <register_name> \n\t Prints the value of a particular register \n\n"); printf(" reg / r <register_name1> <register_name2> \n\t Prints the value of all registers from <register_name1> to <register_name2> \n\n"); printf(" mem / m <page_num> \n\t Displays contents of a memory page \n\n"); printf(" mem / m <page_num1> <page_num2> \n\t Displays contents of memory pages from <page_num1> to <page_num2>\n\n"); printf(" pcb / p \n \t Displays the PCB with state as running \n\n"); printf(" pcb / p <pid> \n\t Displays the <pid> th PCB \n\n"); printf(" pagetable / pt \n \t Displays the page table at location pointed by PTBR \n\n"); printf(" pagetable / pt <pid> \n\t Displays the <pid> th page table \n\n"); printf(" filetable / ft \n \t Displays the System Wide Open File Table\n\n"); printf(" memfreelist / mf \n \t Displays the Memory Free List\n\n"); printf(" diskfreelist / df \n \t Displays the Memory copy of Disk Free List\n\n"); printf(" fat \n \t Displays the Memory Copy of File Allocation Table\n\n"); printf(" location / l <address> \n \t Displays the content at memory address (Translation takes place in USER mode)\n\n"); printf(" watch / w <physical address> \n \t Sets a watch point at this address\n\n"); printf(" watchclear / wc \n \t Clears all the watch points\n\n"); printf(" exit / e \n\t Exit the interface and Halt the machine\n"); printf(" help / h\n"); } else if (strcmp(name,"step") == 0 || strcmp(name,"s") == 0) //Single Stepping { step_flag = ENABLE; return 1; } else if (strcmp(name,"continue") == 0 || strcmp(name,"c") == 0) //Continue till next breakpoint { step_flag = DISABLE; return 1; } else if (strcmp(name,"reg")==0 || strcmp(name,"r")==0) //Prints the registers. { arg1 = strtok(NULL, " "); arg2 = strtok(NULL, " "); if(arg1 == NULL) printRegisters(R0, NUM_REGS-1); else if(arg2 == NULL) { arg1value = getRegArg(arg1); if(arg1value == -1) { printf("Illegal argument for \"%s\". See \"help\" for more information",name); return -1; } else printRegisters(arg1value,arg1value); } else { arg1value = getRegArg(arg1); arg2value = getRegArg(arg2); if(arg1value == -1 || arg2value == -1) { printf("Illegal argument for \"%s\". See \"help\" for more information",name); return -1; } else { if(arg1value > arg2value) //swap them { arg1value = arg1value + arg2value; arg2value = arg1value - arg2value; arg1value = arg1value - arg2value; } printRegisters(arg1value,arg2value); } } } else if (strcmp(name,"mem")==0 || strcmp(name,"m")==0) //displays pages in memory { arg1 = strtok(NULL, " "); arg2 = strtok(NULL, " "); if(arg1 == NULL) { printf("Insufficient argument for \"%s\". See \"help\" for more information",name); return -1; } else if(arg2 == NULL) { arg1value = atoi(arg1); if(arg1value >0 && arg1value < NUM_PAGES) printMemory(arg1value); else { printf("Illegal argument for \"%s\". See \"help\" for more information",name); return -1; } } else { arg1value = atoi(arg1); arg2value = atoi(arg2); if(arg1value > arg2value) //swap them { arg1value = arg1value + arg2value; arg2value = arg1value - arg2value; arg1value = arg1value - arg2value; } if(arg1value >0 && arg2value < NUM_PAGES) { while(arg1value <= arg2value) { printMemory(arg1value); arg1value++; } } else { printf("Illegal argument for \"%s\". See \"help\" for more information",name); return -1; } } } else if (strcmp(name,"pcb")==0 || strcmp(name,"p")==0) //displays PCB of a process { arg1 = strtok(NULL, " "); if(arg1 == NULL) //finds the PCB with state as running { int page_no, word_no; arg1value = 0; while(arg1value < NUM_PCB) { page_no = (READY_LIST + arg1value * PCB_ENTRY + 1) / PAGE_SIZE; word_no = (READY_LIST + arg1value * PCB_ENTRY + 1) % PAGE_SIZE; if(getInteger(page[page_no].word[word_no]) == STATE_RUNNING) break; arg1value++; } if(arg1value == NUM_PCB) { printf("No PCB found with state as running"); return -1; } } else { arg1value = atoi(arg1); if(arg1value<0 || arg1value >=NUM_PCB) { printf("Illegal argument for \"%s\". See \"help\" for more information",name); return -1; } } printPCB(arg1value); } else if (strcmp(name,"pagetable")==0 || strcmp(name,"pt")==0) //displays Page Table of a process { arg1 = strtok(NULL, " "); if(arg1 == NULL) //finds the page table using PTBR { int page_no, word_no; arg1value = getInteger(reg[PTBR_REG]); if(arg1value < PAGE_TABLE || arg1value > (PAGE_TABLE + ((NUM_PCB-1)*NUM_PAGE_TABLE*PAGE_TABLE_ENTRY)) ) { printf("Illegal PTBR value"); return -1; } } else { if(atoi(arg1) < 0 || atoi(arg1) >= NUM_PCB ) { printf("Illegal argument for \"%s\". See \"help\" for more information",name); return -1; } arg1value = PAGE_TABLE + atoi(arg1) * (PAGE_TABLE_ENTRY * NUM_PAGE_TABLE); } printPageTable(arg1value); } else if (strcmp(name,"filetable")==0 || strcmp(name,"ft")==0) //displays System Wide Open File Table printFileTable(); else if (strcmp(name,"memfreelist")==0 || strcmp(name,"mf")==0) //displays Memory Free Lisk printMemFreeList(); else if (strcmp(name,"diskfreelist")==0 || strcmp(name,"df")==0) //displays Disk Free List printDiskFreeList(); else if (strcmp(name,"fat")==0) //displays File Allocation Table printFAT(); else if (strcmp(name,"location")==0 || strcmp(name,"l")==0 ) //displays a content of a memory location { arg1 = strtok(NULL, " "); if(arg1 == NULL) { printf("Insufficient argument for \"%s\". See \"help\" for more information",name); return -1; } translatedAddr = translate_debug(atoi(arg1)); if(getType(arg1) == TYPE_STR || (translatedAddr.page_no == -1 && translatedAddr.word_no == -1) ) { printf("Illegal argument for \"%s\". See \"help\" for more information",name); return -1; } printLocation(translatedAddr); } else if (strcmp(name,"watch")==0 || strcmp(name,"w")==0 ) //Sets watch point to a memory location { arg1 = strtok(NULL, " "); if(arg1 == NULL) { printf("Insufficient argument for \"%s\". See \"help\" for more information",name); return -1; } if( getType(arg1) == TYPE_STR || atoi(arg1) < 0 || atoi(arg1) >= SIZE_OF_MEM ) { printf("Illegal argument for \"%s\". See \"help\" for more information",name); return -1; } if( watch_count >= NUM_WATCH) { printf("You have already used %d watch points. No more watch points can be set.\nUse \"watchclear\" to clear all watch points. \n", NUM_WATCH ); return -1; } watch[watch_count].addr.page_no = atoi(arg1) / PAGE_SIZE; watch[watch_count].addr.word_no = atoi(arg1) % PAGE_SIZE; strcpy(watch[watch_count].value, page[watch[watch_count].addr.page_no].word[watch[watch_count].addr.word_no]); watch_count++; printf("Watch point %d set.\n",watch_count); } else if (strcmp(name,"watchclear")==0 || strcmp(name,"wc")==0 ) //Clears all watch points { initialize_Watch(); printf("All watch points cleared.\n"); } else if (strcmp(name,"exit")==0 || strcmp(name,"e")==0) //Exits the interface exit(0); else { printf("Unknown command \"%s\". See \"help\" for more information",name); return -1; } return 0; }
void Foam::vtkPV3Foam::convertMeshCellZones ( vtkMultiBlockDataSet* output, int& blockNo ) { arrayRange& range = arrayRangeCellZones_; range.block(blockNo); // set output block label datasetNo = 0; // restart at dataset 0 const fvMesh& mesh = *meshPtr_; // resize for decomposed polyhedra zonePolyDecomp_.setSize(range.size()); if (range.empty()) { return; } if (debug) { Info<< "<beg> Foam::vtkPV3Foam::convertMeshCellZones" << endl; printMemory(); } const cellZoneMesh& zMesh = mesh.cellZones(); for (int partId = range.start(); partId < range.end(); ++partId) { const word zoneName = getPartName(partId); const label zoneId = zMesh.findZoneID(zoneName); if (!partStatus_[partId] || zoneId < 0) { continue; } if (debug) { Info<< "Creating VTK mesh for cellZone[" << zoneId << "] " << zoneName << endl; } fvMeshSubset subsetter(mesh); subsetter.setLargeCellSubset(zMesh[zoneId]); vtkUnstructuredGrid* vtkmesh = volumeVTKMesh ( subsetter.subMesh(), zonePolyDecomp_[datasetNo] ); if (vtkmesh) { // superCells + addPointCellLabels must contain global cell ids inplaceRenumber ( subsetter.cellMap(), zonePolyDecomp_[datasetNo].superCells() ); inplaceRenumber ( subsetter.cellMap(), zonePolyDecomp_[datasetNo].addPointCellLabels() ); // copy pointMap as well, otherwise pointFields fail zonePolyDecomp_[datasetNo].pointMap() = subsetter.pointMap(); AddToBlock(output, vtkmesh, range, datasetNo, zoneName); vtkmesh->Delete(); partDataset_[partId] = datasetNo++; } } // anything added? if (datasetNo) { ++blockNo; } if (debug) { Info<< "<end> Foam::vtkPV3Foam::convertMeshCellZones" << endl; printMemory(); } }
void Foam::vtkPV3Foam::convertMeshPointSets ( vtkMultiBlockDataSet* output ) { if (debug) { Info<< "<beg> Foam::vtkPV3Foam::convertMeshPointSets" << endl; printMemory(); } const selectionInfo& selector = selectInfoPointSets_; vtkDataArraySelection* arraySelection = reader_->GetRegionSelection(); // Create the point sets and add as dataset if (selector.size()) { const fvMesh& mesh = *meshPtr_; for ( int regionId = selector.start(); regionId < selector.end(); ++regionId ) { if (!selectedRegions_[regionId]) { continue; } word selectName = getFirstWord ( arraySelection->GetArrayName(regionId) ); if (debug) { Info<< "Creating VTK mesh for pointSet: " << selectName << " region index: " << regionId << endl; } const pointSet pSet(mesh, selectName); const label datasetId = GetNumberOfDataSets(output, selector); vtkPolyData* vtkmesh = vtkPolyData::New(); addPointSetMesh ( mesh, pSet, vtkmesh ); AddToBlock ( output, selector, datasetId, vtkmesh, selectName + ":pointSet" ); selectedRegionDatasetIds_[regionId] = datasetId; vtkmesh->Delete(); } } if (debug) { Info<< "<end> Foam::vtkPV3Foam::convertMeshPointSets" << endl; printMemory(); } }
void Foam::vtkPV3Foam::convertMeshPointZones ( vtkMultiBlockDataSet* output ) { if (debug) { Info<< "<beg> Foam::vtkPV3Foam::convertMeshPointZones" << endl; printMemory(); } const selectionInfo& selector = selectInfoPointZones_; const fvMesh& mesh = *meshPtr_; // Create the point sets and add as dataset if (selector.size()) { const pointZoneMesh& pzMesh = mesh.pointZones(); // use the zoneId directly instead of the name for (int zoneI=0; zoneI < selector.size(); ++zoneI) { const int regionId = selector.start() + zoneI; if (!selectedRegions_[regionId]) { continue; } if (debug) { Info<< "Creating VTK mesh for pointZone: " << zoneI << endl; } const label datasetId = GetNumberOfDataSets(output, selector); vtkPolyData* vtkmesh = vtkPolyData::New(); addPointZoneMesh ( mesh, pzMesh[zoneI], vtkmesh ); AddToBlock ( output, selector, datasetId, vtkmesh, pzMesh.names()[zoneI] + ":pointZone" ); selectedRegionDatasetIds_[regionId] = datasetId; vtkmesh->Delete(); } } if (debug) { Info<< "<end> Foam::vtkPV3Foam::convertMeshPointZones" << endl; printMemory(); } }
int main(){ pcap_t *pt; char *dev; char errbuf[128]; struct bpf_program fp; bpf_u_int32 maskp,netp; int ret,i=0,inum; int pcap_time_out=5; char filter[128]; unsigned char *packet; struct pcap_pkthdr hdr; pcap_if_t *alldevs = NULL,*d; pid_t pid; char ch[10],str = 'n'; attHead att_head; head = init_ip_list(head); att_head = init_attHead(); if(pcap_findalldevs(&alldevs,errbuf)==-1) { fprintf(stderr,"find interface failed!\n"); return; } for(d=alldevs;d;d=d->next){ printf("%d. %s\n",++i,d->name); if(d->description) printf("(%s)\n",d->description); else printf("(no description available)\n"); } if(i==1) dev=alldevs->name; else { printf("input a interface:(1-%d)",i); scanf("%d",&inum); if(inum<1||inum>i) { printf("interface number out of range\n"); return; } for(d=alldevs,i=1;i<inum;d=d->next,i++); dev=d->name; } printf("dev:%s\n",dev); ret=pcap_lookupnet(dev,&netp,&maskp,errbuf); printf(""); if(ret==-1){ fprintf(stderr,"%s\n",errbuf); return; } pt=pcap_open_live(dev,BUFSIZ,1,pcap_time_out,errbuf); if(pt==NULL){ fprintf(stderr,"open error :%s\n",errbuf); return; } while(1) { printf("if you want to quit press y,else press any other key!\n"); scanf("%c",&str); if(str == 'y')break; pid = vfork(); if(pid < 0){ printf("fail to fork\n"); }else if(pid == 0){ if(signal(SIGALRM,timer_handler) == SIG_ERR){ perror("can't set handler for SIGALRM\n"); exit(0); } alarm(1); while(1){ packet=(char *)pcap_next(pt,&hdr); if(packet==NULL) continue; else{ printf("\n\n\n"); printf("get a packet\n"); ethernet_packet_callback(NULL,&hdr,packet); num++; printf("\n"); if(flag == arp){ init_data(att_head,num,"arp","xxxxxxxx","broadcast"); printMemory(att_head); flag = 0; } else{ switch(flag){ case ip: strcpy(ch,"ip");break; case tcp: strcpy(ch,"tcp");break; case udp: strcpy(ch,"udp");break; case http: strcpy(ch,"http");break; case oicq: strcpy(ch,"oicq");break; case webqq: strcpy(ch,"webqq");break; case msnms: strcpy(ch,"msnms");break; default: strcpy(ch,"xxx"); strcpy(srcip,"xxxxxxxx"); strcpy(desip,"xxxxxxxx"); other_num++; other_bytes = other_bytes+hdr.len; break; } init_data(att_head,num,ch,srcip,desip); printMemory(att_head); flag = 0; } } printf("\n"); printf("其他包的总数:%d 其他包的总字节数:%ld\n",other_num,other_bytes); printf("ip包的总数:%d ip包的总字节数:%ld\n",ip_num,ip_bytes); printf("arp包的总数:%d arp包的总字节数:%ld\n",arp_num,arp_bytes); printf("tcp包的总数:%d tcp包的总字节数:%ld\n",tcp_num,tcp_bytes); printf("udp包的总数:%d udp包的总字节数:%ld\n",udp_num,udp_bytes); printf("oicq包的总数:%d oicq包的总字节数:%ld\n",oicq_num,oicq_bytes); printf("http包的总数:%d http包的总字节数: %ld\n",http_num,http_bytes); printf("web qq包的总数:%d web qq包的总字节数: %ld\n",webqq_num,webqq_bytes); printf("msnms包的总数:%d msnms包的总字节数: %ld\n",msnms_num,msnms_bytes); display_ip_list(head); } } else{ delete_ip_list(head,1); if(wait(NULL) == -1){ printf("fail to wait\n"); exit(1); } } } pcap_close(pt); saveTable(att_head); free_ip_list(head); free_data(att_head); return 0; /* pt = pcap_open_offline("msn.pcap",errbuf); if(pt == NULL){ printf("ERROR:could not open pcap file: %s\n",errbuf); exit(-1); } pcap_loop(pt,-1,ðernet_packet_callback,NULL); pcap_close(pt); return 0;*/ }
/** Handle s2e_op instruction. Instructions: 0f 3f XX XX XX XX XX XX XX XX XX: opcode */ void BaseInstructions::handleBuiltInOps(S2EExecutionState* state, uint64_t opcode) { switch((opcode>>8) & 0xFF) { case 0: { /* s2e_check */ uint32_t v = 1; state->writeCpuRegisterConcrete(CPU_OFFSET(regs[R_EAX]), &v, 4); } break; case 1: state->enableSymbolicExecution(); break; case 2: state->disableSymbolicExecution(); break; case 3: { /* s2e_make_symbolic */ makeSymbolic(state, false); break; } case 4: { /* s2e_is_symbolic */ isSymbolic(state); break; } case 5: { /* s2e_get_path_id */ state->writeCpuRegister(offsetof(CPUX86State, regs[R_EAX]), klee::ConstantExpr::create(state->getID(), klee::Expr::Int32)); break; } case 6: { /* s2e_kill_state */ killState(state); break; } case 7: { /* s2e_print_expression */ printExpression(state); break; } case 8: { //Print memory contents printMemory(state); break; } case 9: state->enableForking(); break; case 10: state->disableForking(); break; case 0x10: { /* s2e_print_message */ printMessage(state, opcode >> 16); break; } case 0x11: { /* s2e_make_concolic */ makeSymbolic(state, true); break; } case 0x20: /* concretize */ concretize(state, true); break; case 0x21: { /* replace an expression by one concrete example */ concretize(state, false); break; } case 0x30: { /* Get number of active states */ uint32_t count = s2e()->getExecutor()->getStatesCount(); state->writeCpuRegisterConcrete(CPU_OFFSET(regs[R_EAX]), &count, sizeof(uint32_t)); break; } case 0x31: { /* Get number of active S2E instances */ uint32_t count = s2e()->getCurrentProcessCount(); state->writeCpuRegisterConcrete(CPU_OFFSET(regs[R_EAX]), &count, sizeof(uint32_t)); break; } case 0x32: { /* Sleep for a given number of seconds */ sleep(state); break; } case 0x50: { /* disable/enable timer interrupt */ uint64_t disabled = opcode >> 16; if(disabled) s2e()->getMessagesStream(state) << "Disabling timer interrupt\n"; else s2e()->getMessagesStream(state) << "Enabling timer interrupt\n"; state->writeCpuState(CPU_OFFSET(timer_interrupt_disabled), disabled, 8); break; } case 0x51: { /* disable/enable all apic interrupts */ uint64_t disabled = opcode >> 16; if(disabled) s2e()->getMessagesStream(state) << "Disabling all apic interrupt\n"; else s2e()->getMessagesStream(state) << "Enabling all apic interrupt\n"; state->writeCpuState(CPU_OFFSET(all_apic_interrupts_disabled), disabled, 8); break; } case 0x52: { /* Gets the current S2E memory object size (in power of 2) */ uint32_t size = S2E_RAM_OBJECT_BITS; state->writeCpuRegisterConcrete(CPU_OFFSET(regs[R_EAX]), &size, 4); break; } case 0x70: /* merge point */ state->jumpToSymbolicCpp(); s2e()->getExecutor()->queueStateForMerge(state); break; default: s2e()->getWarningsStream(state) << "BaseInstructions: Invalid built-in opcode " << hexval(opcode) << '\n'; break; } }
void interpretPrompt(References* r, CPUStatus* cpu, int* status) { // show prompt ready printf("> "); fflush(stdout); // get new command char* line = (char*) calloc(MAX_STRING_LENGTH, sizeof(char)); if (line == NULL) { perror("calloc error in interpretPrompt\n"); exit(EXIT_FAILURE); } if (fgets(line, MAX_STRING_LENGTH, stdin) == NULL) { perror("fgets error in interpretPrompt\n"); exit(EXIT_FAILURE); } // remove endline removeEndLine(line); int assembleCode = 0; // interpreter commands if (stringEquals(line, "regs") == 0) { printRegisters(cpu); *status = RUN_COMMAND; free(line); return; } else if (stringEquals(line, "mem") == 0) { printMemory(cpu); *status = RUN_COMMAND; free(line); return; } else if (stringEquals(line, "exit") == 0) { *status = EXECUTE_HALT; free(line); return; } else if (stringEquals(line, "show") == 0) { printInstructions(r); *status = RUN_COMMAND; free(line); return; } else { // assemble One Pass assembleCode = onePass(r, cpu, line); } // execute interpreter if (assembleCode == ASSEMBLE_OK || (assembleCode == ASSEMBLE_LABEL && r->currentAddress > 4)) { interpret(r, cpu, status); } free(line); }
void Foam::vtkPV3Foam::convertMeshFaceZones ( vtkMultiBlockDataSet* output, int& blockNo ) { partInfo& selector = partInfoFaceZones_; selector.block(blockNo); // set output block label datasetNo = 0; // restart at dataset 0 const fvMesh& mesh = *meshPtr_; if (!selector.size()) { return; } if (debug) { Info<< "<beg> Foam::vtkPV3Foam::convertMeshFaceZones" << endl; printMemory(); } const faceZoneMesh& zMesh = mesh.faceZones(); for (int partId = selector.start(); partId < selector.end(); ++partId) { const word zoneName = getPartName(partId); const label zoneId = zMesh.findZoneID(zoneName); if (!partStatus_[partId] || zoneId < 0) { continue; } if (debug) { Info<< "Creating VTKmesh for faceZone[" << zoneId << "] " << zoneName << endl; } vtkPolyData* vtkmesh = faceZoneVTKMesh(mesh, zMesh[zoneId]); if (vtkmesh) { AddToBlock(output, vtkmesh, selector, datasetNo, zoneName); vtkmesh->Delete(); partDataset_[partId] = datasetNo++; } } // anything added? if (datasetNo) { ++blockNo; } if (debug) { Info<< "<end> Foam::vtkPV3Foam::convertMeshFaceZones" << endl; printMemory(); } }
void printARM (ARM* arm) { printRegisters(arm); printMemory(arm); }
int main(int argc, char *argv[]) { // A201860038A00798E903A818A9028501A60165008501860088D0F5 // const char program[] = { 0xC8, 0x20, 0x00, 0x00 }; // const char program[] = { 0xA2, 0x01, 0x86, 0x00, 0x38, 0xA0, 0x07, 0x98, 0xE9, 0x03, 0xA8, 0x18, 0xA9, 0x02, 0x85, 0x01, 0xA6, 0x01, 0x65, 0x00, 0x85, 0x01, 0x86, 0x00, 0x88, 0xD0, 0xF5 }; if(argc != 2) { printf("Usage: %s program \n", argv[0]); return -1; } char *program; int program_length = readFileBytes(argv[1], &program); printf("Program (%i bytes): \n", program_length); int i; for(i = 0; i < program_length; i++) { printf("%i:%02X ", i, (unsigned char)program[i]); } printf("\n"); CPU cpu; initializeCPU(&cpu); cpu.pc = 0x4000; writeMemory(&cpu, program, cpu.pc, program_length); // cpu.pc += 559; // 700 // 799 // cpu.pc += 799; // test 06 // cpu.pc += 1192; // test 09 // char *buf = malloc(sizeof(char) * 2); // buf[0] = 0xC0; // buf[1] = 0x01; // writeMemory(&cpu, buf, 0x0105, 2); // cpu.ps = 0x1; // cpu.a = 0x7; // cpu.x = 0x2; // cpu.y = 0x3; // char *buf2 = malloc(sizeof(char) * 2); // buf2[0] = 0x08; // buf2[1] = 0xEE; // writeMemory(&cpu, buf2, 0x0105, 2); // printf("cpu->ps: %i\n", cpu.ps); // printf("cpu->sp: %i\n", cpu.sp); char str[1]; // int i; for(;;) { printf("cpu->pc: %i\n", cpu.pc); // scanf("%s", str); step(&cpu); printMemory(&cpu); printf("\n\n\n"); printf("cpu->sp: %x\n", cpu.sp); printf("cpu->a: %x\n", cpu.a); printf("cpu->x: %x\n", cpu.x); printf("cpu->y: %x\n", cpu.y); printf("cpu->ps: %x\n\n", cpu.ps); if(cpu.pc == 17825) { break; } } printMemory(&cpu); printf("### results:\n"); printf("cpu->sp: %x\n", cpu.sp); printf("cpu->a: %x\n", cpu.a); printf("cpu->x: %x\n", cpu.x); printf("cpu->y: %x\n", cpu.y); printf("cpu->ps: %x\n", cpu.ps); printf("cpu->cycles: %i\n", cpu.cycles); // printf("%s\n", ); // printbitssimple(cpu.ps); printf("MEMORY 9: %x\n", *cpu.memory[0x80]); printf("MEMORY final: %x\n", *cpu.memory[0x0210]); freeCPU(&cpu); return 0; }
void Foam::vtkPV3Foam::convertMeshCellZones ( vtkMultiBlockDataSet* output ) { if (debug) { Info<< "<beg> Foam::vtkPV3Foam::convertMeshCellZones" << endl; printMemory(); } const selectionInfo& selector = selectInfoCellZones_; const fvMesh& mesh = *meshPtr_; // Create the cell zone(s) and add as DataSet(CELLZONE, 0..n) if (selector.size()) { const cellZoneMesh& czMesh = mesh.cellZones(); // use the zoneId directly instead of the name for (int zoneI=0; zoneI < selector.size(); ++zoneI) { const int regionId = selector.start() + zoneI; if (!selectedRegions_[regionId]) { continue; } if (debug) { Info<< "Creating VTK mesh for cellZone: " << zoneI << endl; } fvMeshSubset subsetter ( IOobject ( "set", mesh.time().constant(), mesh, IOobject::NO_READ, IOobject::NO_WRITE ), mesh ); subsetter.setLargeCellSubset(labelHashSet(czMesh[zoneI])); const label datasetId = GetNumberOfDataSets(output, selector); vtkUnstructuredGrid* vtkmesh = vtkUnstructuredGrid::New(); addVolumeMesh ( subsetter.subMesh(), vtkmesh, zoneSuperCells_[datasetId] ); // renumber - superCells must contain global cell ids inplaceRenumber ( subsetter.cellMap(), zoneSuperCells_[datasetId] ); AddToBlock ( output, selector, datasetId, vtkmesh, czMesh.names()[zoneI] + ":cellZone" ); selectedRegionDatasetIds_[regionId] = datasetId; vtkmesh->Delete(); } } if (debug) { Info<< "<end> Foam::vtkPV3Foam::convertMeshCellZones" << endl; printMemory(); } }