void GCodeExport::switchExtruder(int new_extruder) { if (current_extruder == new_extruder) return; if (!isRetracted) // assumes the last retraction already was an extruder switch retraction { writeRetraction_extruderSwitch(); } int old_extruder = current_extruder; current_extruder = new_extruder; if (flavor == EGCodeFlavor::MACH3) resetExtrusionValue(); isRetracted = true; writeCode(extruder_attr[old_extruder].end_code.c_str()); if (flavor == EGCodeFlavor::MAKERBOT) *output_stream << "M135 T" << current_extruder << "\n"; else // TinyG TODO: find out what a T code does *output_stream << "T" << current_extruder << "\n"; writeCode(extruder_attr[new_extruder].start_code.c_str()); //Change the Z position so it gets re-writting again. We do not know if the switch code modified the Z position. currentPosition.z += 1; }
void TclWriter::writeHeaderFile(UMLClassifier * c, QFile & fileh) { // open stream for writing QTextStream stream(&fileh); mStream = &stream; // reset the indent level m_indentLevel = 0; // write header blurb QString str = getHeadingFile(".tcl"); if (!str.isEmpty()) { str.replace(QRegExp("%filename%"), fileName_); str.replace(QRegExp("%filepath%"), fileh.fileName()); writeCode(str); } // set current namespace writeCode("namespace eval " + mNamespace + " {"); m_indentLevel++; // check on already existing writeComm("Do not load twice"); writeCode("if {[namespace exist " + className_ + "]} return"); // source used superclass files UMLClassifierList superclasses = c->getSuperClasses(); if (superclasses.count() > 0) { writeComm ("Source found and used class files and import class command if necessary"); foreach (UMLClassifier * classifier , superclasses ) { writeUse(classifier); }
void GCodeExport::switchExtruder(int new_extruder) { if (current_extruder == new_extruder) return; writeRetraction_extruderSwitch(); resetExtrusionValue(); // should be called on the old extruder int old_extruder = current_extruder; current_extruder = new_extruder; if (flavor == EGCodeFlavor::MACH3) { resetExtrusionValue(); // also zero the E value on the new extruder } writeCode(extruder_attr[old_extruder].end_code.c_str()); if (flavor == EGCodeFlavor::MAKERBOT) { *output_stream << "M135 T" << current_extruder << "\n"; } else { *output_stream << "T" << current_extruder << "\n"; } writeCode(extruder_attr[new_extruder].start_code.c_str()); //Change the Z position so it gets re-writting again. We do not know if the switch code modified the Z position. currentPosition.z += 1; }
/** * Write end code and flush bitstream * @param s LZW state * @return Number of bytes written or -1 on error */ int ff_lzw_encode_flush(LZWEncodeState * s) { if (s->last_code != -1) writeCode(s, s->last_code); writeCode(s, s->end_code); flush_put_bits(&s->pb); s->last_code = -1; return writtenBytes(s); }
/** * Write end code and flush bitstream * @param s LZW state * @return Number of bytes written or -1 on error */ int ff_lzw_encode_flush(LZWEncodeState *s, void (*lzw_flush_put_bits)(PutBitContext *)) { if (s->last_code != -1) writeCode(s, s->last_code); writeCode(s, s->end_code); lzw_flush_put_bits(&s->pb); s->last_code = -1; return writtenBytes(s); }
//----------------------------------------------------------------- // end of data void mgLZWEncode::compressTerm() { // Flush out the buffered code if (!m_firstByte) writeCode(m_waitingCode); // Send an EOF code writeCode(m_EOFCode); // Flush the bit-packing buffer if (m_curBits > 0) writeLZWByte(m_curAccum & 0xFF); }
void encodeData(istream& input, const map<int, string> &encodingMap, obitstream& output) { int byte = input.get(); // continue until input end of input, byte == -1 while (byte != -1) { string code = encodingMap.at(byte); writeCode(code, output); byte = input.get(); } string eofCode = encodingMap.at(PSEUDO_EOF); writeCode(eofCode, output); }
void GCodeExport::startExtruder(int new_extruder) { if (new_extruder != current_extruder) // wouldn't be the case on the very first extruder start if it's extruder 0 { if (flavor == EGCodeFlavor::MAKERBOT) { *output_stream << "M135 T" << new_extruder << new_line; } else { *output_stream << "T" << new_extruder << new_line; } } current_extruder = new_extruder; assert(getCurrentExtrudedVolume() == 0.0 && "Just after an extruder switch we haven't extruded anything yet!"); resetExtrusionValue(); // zero the E value on the new extruder, just to be sure writeCode(extruder_attr[new_extruder].start_code.c_str()); CommandSocket::setExtruderForSend(new_extruder); CommandSocket::setSendCurrentPosition( getPositionXY() ); //Change the Z position so it gets re-writting again. We do not know if the switch code modified the Z position. currentPosition.z += 1; }
void emitLOC(REG reg, const int Const) { int opcode = 0x00; int SizeOfopcode = 1; switch (reg) { case REG_EAX : opcode = 0xB8; break; case REG_EBX : opcode = 0xBB; break; case REG_ECX : break; case REG_EDX : break; case REG_ESI : break; case REG_EDI : break; case REG_ESP : break; case REG_EBP : break; default : return ; } writeCode(opcode, SizeOfopcode, Const, 4); }
/** * LZW main compress function * @param s LZW state * @param inbuf Input buffer * @param insize Size of input buffer * @return Number of bytes written or -1 on error */ int ff_lzw_encode(LZWEncodeState *s, const uint8_t *inbuf, int insize) { int i; if(insize * 3 > (s->bufsize - s->output_bytes) * 2) { return -1; } if (s->last_code == LZW_PREFIX_EMPTY) clearTable(s); for (i = 0; i < insize; i++) { uint8_t c = *inbuf++; int code = findCode(s, c, s->last_code); if (s->tab[code].hash_prefix == LZW_PREFIX_FREE) { writeCode(s, s->last_code); addCode(s, c, s->last_code, code); code = hash(0, c); } s->last_code = s->tab[code].code; if (s->tabsize >= s->maxcode - 1) { clearTable(s); } } return writtenBytes(s); }
//----------------------------------------------------------------- // reset compressor and issue a clear code void mgLZWEncode::clearBlock() { clearHash(); // delete all the symbols m_freeCode = m_clearCode + 2; writeCode(m_clearCode); // inform decoder m_bits = m_initBits; // reset code size m_maxCode = MAXCODE(m_bits); }
void GCodeExport::finalize(double moveSpeed, const char* endCode) { writeFanCommand(0); writeCode(endCode); log("Print time: %d\n", int(getTotalPrintTime())); log("Filament: %d\n", int(getTotalFilamentUsed(0))); for(int n=1; n<MAX_EXTRUDERS; n++) if (getTotalFilamentUsed(n) > 0) log("Filament%d: %d\n", n + 1, int(getTotalFilamentUsed(n))); output_stream->flush(); }
void GCodeExport::finalize(int maxObjectHeight, double moveSpeed, const char* endCode) { writeFanCommand(0); setZ(maxObjectHeight + 5000); writeMove(Point3(0,0,maxObjectHeight + 5000) + getPositionXY(), moveSpeed, 0); writeCode(endCode); log("Print time: %d\n", int(getTotalPrintTime())); log("Filament: %d\n", int(getTotalFilamentUsed(0))); for(int n=1; n<MAX_EXTRUDERS; n++) if (getTotalFilamentUsed(n) > 0) log("Filament%d: %d\n", n + 1, int(getTotalFilamentUsed(n))); output_stream->flush(); }
void GCodeExport::finalize(const char* endCode) { writeFanCommand(0); writeCode(endCode); long print_time = getTotalPrintTime(); int mat_0 = getTotalFilamentUsed(0); log("Print time: %d\n", print_time); log("Print time (readable): %dh %dm %ds\n", print_time / 60 / 60, (print_time / 60) % 60, print_time % 60); log("Filament: %d\n", mat_0); for(int n=1; n<MAX_EXTRUDERS; n++) if (getTotalFilamentUsed(n) > 0) log("Filament%d: %d\n", n + 1, int(getTotalFilamentUsed(n))); output_stream->flush(); }
int main(void) { char command[100] = {'\0'}; help(); signal(SIGINT, intHandler); while (true) { prompt(command); writeCode(command); } return 0; }
/*! * 换一台打印机 * \param newExtruder 新的打印机的序号 */ void GCodeExport::switchExtruder(int newExtruder) { if (extruderNr == newExtruder) return; if (flavor == GCODE_FLAVOR_BFB) { if (!isRetracted) *output_stream << "M103\r\n"; isRetracted = true; return; } resetExtrusionValue(); if (flavor == GCODE_FLAVOR_ULTIGCODE || flavor == GCODE_FLAVOR_REPRAP_VOLUMATRIC) { *output_stream << "G10 S1\n"; }else{ *output_stream << "G1 F" << (extruderSwitchRetractionSpeed * 60) << " " << extruderCharacter[extruderNr] << std::setprecision(5) << (extrusion_amount - extruderSwitchRetraction) << "\n"; currentSpeed = extruderSwitchRetractionSpeed; } extruderNr = newExtruder; if (flavor == GCODE_FLAVOR_MACH3) resetExtrusionValue(); isRetracted = true; writeCode(preSwitchExtruderCode[extruderNr].c_str()); if (flavor == GCODE_FLAVOR_MAKERBOT) *output_stream << "M135 T" << extruderNr << "\n"; else *output_stream << "T" << extruderNr << "\n"; writeCode(postSwitchExtruderCode[extruderNr].c_str()); //Change the Z position so it gets re-writting again. We do not know if the switch code modified the Z position. currentPosition.z += 1; }
void emitMov(REG reg, int loc, VTYPE vtype) { int opcode = 0x89; int SizeOfopcode = 2; char oprand = 0x00; char opmod = 0x00; char oprm = 0x05; char opreg = 0x00; switch (reg) { case REG_EAX : opreg = 0x00; break; case REG_EBX : opreg = 0x03; break; case REG_ECX : opreg = 0x01; break; case REG_EDX : opreg = 0x02; break; case REG_ESI : opreg = 0x06; break; case REG_EDI : opreg = 0x07; break; case REG_ESP : opreg = 0x04; break; case REG_EBP : opreg = 0x05; break; default : return ; } oprand += (opreg << 3); oprand += oprm; opcode += (oprand << 8); writeCode(opcode, SizeOfopcode, loc, 4); AddVarRef(loc, offset - 4, vtype); }
void HuffmanTree::writeCode(Tree* node,Writer& w) { if (node!=root) { writeCode(node->getParent(),w); if (node->isLeftChild()) { //cout << 0; w.writeBit(0); } else { //cout << 1; w.writeBit(1); } } }
/** * Clear LZW code table * @param s LZW state */ static void clearTable(LZWEncodeState * s) { int i, h; writeCode(s, s->clear_code); s->bits = 9; for (i = 0; i < LZW_HASH_SIZE; i++) { s->tab[i].hash_prefix = LZW_PREFIX_FREE; } for (i = 0; i < 256; i++) { h = hash(0, i); s->tab[h].code = i; s->tab[h].suffix = i; s->tab[h].hash_prefix = LZW_PREFIX_EMPTY; } s->tabsize = 258; }
/******************************************************************************* * Main ******************************************************************************/ int main(int argc, char const* argv[]) { int argi = 0; tgState *T = tgState_create(&tgMalloc, NULL); TOPT_PARSE(argi, argc, argv, options) { case TERR_ARGUMENT: // Not an option, assume it's a file. writeCode(T, argv[argi++], NULL); break; default: printf("tc has encountered a fatal error!\n"); exit(1); } tgState_free(T); return 0; }
void GCodeExport::switchExtruder(int new_extruder, const RetractionConfig& retraction_config_old_extruder) { if (current_extruder == new_extruder) return; bool force = true; bool extruder_switch = true; writeRetraction(&const_cast<RetractionConfig&>(retraction_config_old_extruder), force, extruder_switch); resetExtrusionValue(); // zero the E value on the old extruder, so that the current_e_value is registered on the old extruder int old_extruder = current_extruder; writeCode(extruder_attr[old_extruder].end_code.c_str()); startExtruder(new_extruder); }
void writeSendCodelockPacket(uint8_t* packet_start, int code, uint32_t count, uint32_t len, pcap_t* adHandle) { // write the current code writeCode(packet_start, code); // seq numbers increment_sequence_number(packet_start, 5, count); increment_sequence_number(packet_start, 11, count); increment_sequence_number(packet_start, 14, count); // checksums write_checksum_ip(packet_start); InsertUDPChecksum(packet_start, len); // fire away pcap_sendpacket(adHandle, packet_start, len); }
void Functionality::addTask(vector<string> eventDetails) { EventStorage tempEvent; int tempCode; int tempDigit; string tempString; ifstream eventCodeGenerate("EventCode.txt"); eventCodeGenerate>>tempCode; eventCodeGenerate.close(); tempCode += 1; ofstream writeCode("EventCode.txt"); writeCode<<tempCode; writeCode.close(); while(tempCode != 0) { tempDigit = tempCode%10; tempString += char(tempDigit+48); tempCode /= 10; } eventDetails.pop_back(); eventDetails.push_back(tempString); tempEvent.storeUserInput(eventDetails, 0); string eventPriority=tempEvent.getPriority(); if(eventPriority[0] == '1') { highPriority.push_back(tempEvent); undoHighVector.push_back(highPriority); undoCount.push_back(0); } else if(eventPriority[0] == '2') { normalPriority.push_back(tempEvent); undoNormalVector.push_back(normalPriority); undoCount.push_back(1); } redoCount.clear(); redoHighVector.clear(); redoNormalVector.clear(); callSort(); updateFile(); notificationFile(); }
void emitMul(REG reg1, REG reg2) { int opcode = 0x0FAF; int SizeOfopcode = 2; char opmod = 0xC0; char temp = 0x00; switch (reg2) { case REG_EAX : temp = 0x00; break; case REG_EBX : temp = 0x03; break; case REG_ECX : temp = 0x01; break; case REG_EDX : temp = 0x02; break; } opmod += temp; switch (reg1) { case REG_EAX : temp = 0x00; break; case REG_EBX : temp = 0x03; break; case REG_ECX : temp = 0x01; break; case REG_EDX : temp = 0x02; break; } opmod += (temp << 3); writeCode(opcode, SizeOfopcode, opmod, 1); }
void GCodeExport::finalize(int maxObjectHeight, int moveSpeed, const char* endCode) { writeFanCommand(0); writeRetraction(); setZ(maxObjectHeight + 5000); writeMove(getPositionXY(), moveSpeed, 0); writeCode(endCode); log("Print time: %d\n", int(getTotalPrintTime())); log("Filament: %d\n", int(getTotalFilamentUsed(0))); log("Filament2: %d\n", int(getTotalFilamentUsed(1))); if (getFlavor() == GCODE_FLAVOR_ULTIGCODE) { char numberString[16]; sprintf(numberString, "%d", int(getTotalPrintTime())); replaceTagInStart("<__TIME__>", numberString); sprintf(numberString, "%d", int(getTotalFilamentUsed(0))); replaceTagInStart("<FILAMENT>", numberString); sprintf(numberString, "%d", int(getTotalFilamentUsed(1))); replaceTagInStart("<FILAMEN2>", numberString); } }
int Encoding::length(const unsigned char *output) const { return writeCode((unsigned char*)output, false); }
/** Opens appropriate files and handles them @param argc number of command line arguments @param argv array of command line arguments @return the exit status of the program */ int main( int argc, char *argv[] ) { char *wordFile = "words.txt"; FILE *input; FILE *output; if ( argc < 3 || argc > 4 ) { fprintf( stderr, "usage: pack <input.txt> <compressed.raw> [wordfile.txt]\n" ); exit( 1 ); } input = fopen( argv[ 1 ], "r" ); if ( !input ) { printf( "usage: readFile <input-file>\n" ); exit( 1 ); } output = fopen( argv[ 2 ], "wb" ); if ( !output ) { printf( "usage: readFile <input-file>\n" ); exit( 1 ); } if ( argc == 4 ) { wordFile = argv[ 3 ]; } WordList *wordList = readWordList( wordFile ); #ifdef DEBUG // Report the entire contents of the word list, once it's built. printf( "---- word list -----\n" ); for ( int i = 0; i < wordList->len; i++ ) printf( "%d == %s\n", i, wordList->words[ i ] ); printf( "--------------------\n" ); #endif // ... // Read the contents of the whole file into one big buffer. This could be more // efficient, but it simplifies the rest of the program. char *buffer = readFile( input ); // Write out codes for everything in the buffer. int pos = 0; PendingBits pending = { 0, 0 }; while ( buffer[ pos ] ) { // Get the next code. int code = bestCode( wordList, buffer + pos ); #ifdef DEBUG printf( "%d <- %s\n", code, wordList->words[ code ] ); #endif // Write it out and move ahead by the number of characters we just encoded. writeCode( code, &pending, output ); pos += strlen( wordList->words[ code ] ); } // Write out any remaining bits in the last, partial byte. flushBits( &pending, output ); // ... fclose( input ); fclose( output ); freeWordList( wordList ); return EXIT_SUCCESS; }
//----------------------------------------------------------------- // compress a byte void mgLZWEncode::compressByte( BYTE nByte) { if (m_firstByte) { // need to initialize nWaitingCode m_waitingCode = nByte; m_firstByte = FALSE; return; } // Probe hash table to see if a symbol exists for // waiting_code followed by nByte. HashInt i = ((HashInt) nByte << (MAX_LZW_BITS-8)) + m_waitingCode; HashInt nDisp; // i is less than twice 2**MAX_LZW_BITS, therefore less than twice HSIZE if (i >= HASH_SIZE) i -= HASH_SIZE; mgLZWHash lProbeValue = HASH_ENTRY(m_waitingCode, nByte); // is first probed slot not empty? if (m_hashCode[i] != 0) { if (m_hashValue[i] == lProbeValue) { m_waitingCode = m_hashCode[i]; return; } if (i == 0) // secondary hash (after G. Knott) nDisp = 1; else nDisp = HASH_SIZE - i; for (;;) { i -= nDisp; if (i < 0) i += HASH_SIZE; if (m_hashCode[i] == 0) break; // hit empty slot if (m_hashValue[i] == lProbeValue) { m_waitingCode = m_hashCode[i]; return; } } } // here when hashtable[i] is an empty slot; desired symbol not in table writeCode(m_waitingCode); if (m_freeCode < LZW_TABLE_SIZE) { m_hashCode[i] = m_freeCode++; // add symbol to hashtable m_hashValue[i] = lProbeValue; } else clearBlock(); m_waitingCode = nByte; }
//----------------------------------------------------------------- // start of data void mgLZWEncode::compressInit() { // write an initial Clear code writeCode(m_clearCode); }