int CAimProto::aim_set_avatar_hash(HANDLE hServerConn, unsigned short &seqno, char flags, unsigned short bart_type, unsigned short &id, char size, const char* hash) { unsigned short offset = 0; char bart_type_txt[8]; ultoa(bart_type, bart_type_txt, 10); unsigned short bart_type_len = (unsigned short)mir_strlen(bart_type_txt); unsigned short req = 0x09; if (id == 0) { id = get_random(); req = 0x08; } char* buf = (char*)alloca(SNAC_SIZE + TLV_HEADER_SIZE * 2 + 20 + size + bart_type_len); aim_writesnac(0x13, req, offset, buf, get_random()); // SSI Edit/Add aim_writeshort(bart_type_len, offset, buf); // name length aim_writegeneric(bart_type_len, bart_type_txt, offset, buf); // name aim_writeshort(0, offset, buf); // group id aim_writeshort(id, offset, buf); // buddy id aim_writeshort(0x14, offset, buf); // buddy type: Buddy Icon aim_writeshort(2 + size + TLV_HEADER_SIZE, offset, buf); // length of extra data char* buf2 = (char*)alloca(2 + size); buf2[0] = flags; buf2[1] = (char)size; memcpy(&buf2[2], hash, size); aim_writetlv(0xd5, 2 + size, buf2, offset, buf); // BART return aim_sendflap(hServerConn, 0x02, offset, buf, seqno); }
trap_retval ReqGet_err_text( void ) /******************************/ { static char *DosErrMsgs[] = { #define pick(a,b) b, #include "dosmsgs.h" #undef pick }; get_err_text_req *acc; char *err_txt; _DBG( "AccErrText\r\n" ); acc = GetInPtr( 0 ); err_txt = GetOutPtr( 0 ); if( acc->err < ERR_LAST ) { strcpy( err_txt, DosErrMsgs[ acc->err ] ); _DBG( "After strcpy\r\n" ); } else { _DBG( "After acc->error_code > MAX_ERR_CODE" ); strcpy( err_txt, TRP_ERR_unknown_system_error ); ultoa( acc->err, err_txt + strlen( err_txt ), 16 ); _DBG( "After utoa()\r\n" ); } return( strlen( err_txt ) + 1 ); }
String::String(unsigned long value, unsigned char base) { init(); char buf[33]; ultoa(value, buf, base); *this = buf; }
condcode scr_c2d( parm parms[MAX_FUN_PARMS], size_t parmcount, char * * result, int32_t ressize ) { char * pval; char * pend; condcode cc; uint32_t n; char linestr[MAX_L_AS_STR]; char * p; if( (parmcount < 1) || (parmcount > 2) ) {// accept 2. parm, but ignore it cc = neg; return( cc ); } pval = parms[0].a; pend = parms[0].e; unquote_if_quoted( &pval, &pend ); n = 0; while( pval <= pend ) { n *= 256; // ignore overflow, let it wrap around n += (unsigned char)*pval; pval++; } ultoa( n, linestr, 10 ); p = linestr; while( *p && ressize > 0) { **result = *p++; *result += 1; ressize--; } return( pos ); }
static void ensureBufferReflectsCurToken( void ) { if( TokenUsesBuffer( CurToken ) ) { if( CurToken == T_CONSTANT ) { switch( ConstType ) { case TYP_UCHAR: case TYP_UINT: case TYP_ULONG: ultoa( U32Fetch( Constant64 ), Buffer, 10 ); break; case TYP_SCHAR: case TYP_SINT: case TYP_SLONG: ltoa( U32Fetch( Constant64 ), Buffer, 10 ); break; case TYP_ULONG64: case TYP_SLONG64: sti64cpy( Buffer, Constant64 ); break; } } } else { strcpy( Buffer, Tokens[ CurToken ] ); } }
int mmc_std_inquiry( SIM_HBA *hba, CCB_SCSIIO *ccb ) { SIM_MMC_EXT *ext; SCSI_INQUIRY *iptr; char buf[8]; ext = (SIM_MMC_EXT *)hba->ext; iptr = (SCSI_INQUIRY *)ccb->cam_data.cam_data_ptr; memset(iptr, 0, sizeof(*iptr)); iptr->peripheral = D_DIR_ACC; iptr->rmb = ext->normval ? CAM_FALSE : CAM_TRUE; iptr->version = INQ_VER_SPC3; // SPC-3 iptr->adlen = 32; if (ext->version < MMC_VERSION_1) { /* Vendor ID */ strcpy((char *)&iptr->vend_id[0], "SD:"); ultoa(ext->cid.sd_cid.mid, buf, 10); iptr->vend_id[3] = buf[0]; iptr->vend_id[4] = buf[1]; iptr->vend_id[5] = buf[2]; /* Product ID */ strcpy((char *)&iptr->prod_id[0], (char *)ext->cid.sd_cid.pnm); /* Product revision level, BCD code */ iptr->prod_rev[0] = (ext->cid.sd_cid.prv >> 4) + '0'; iptr->prod_rev[1] = '.'; iptr->prod_rev[2] = (ext->cid.sd_cid.prv & 0x0F) + '0'; } else {
Bool Header :: _GetMerkmalsKode (ulong &MK, char *pText) { #if _MSC_VER >= 1100 HPROJECT hPr = DEX_GetDataSourceHandle(); HeaderEntryX HD (pText,hPr); #else HeaderEntryX HD (pText); #endif if (HD.Status () != HE_INVALID) { MK = HD.EntryLong (); // KK000608 ----------------------------------- #if _MSC_VER >= 1100 long lMKode = MK; MK = DEX_MapMCodeToHandle(hPr,lMKode); // -------------------------------------------- #endif return True; } // sonst neuen Eintrag erzeugen und speichern char Buffer [20] = ""; ultoa (MK, Buffer, DEX_GetMkBase ()); HD.SetEntryText (Buffer); if (HD.WriteBack () != EC_OKAY) // Wert speichern return False; return True; }
static void syspgnumadfun( symvar *e ) // pagenumber. { e = e; ultoa( page, syspgnumadstr, 10 ); strcat( syspgnumadstr, "." ); return; };
// unsigned long to string void StrPP::ultos(const unsigned long n) { char num[15]; ultoa(n, num, 10); SetStr(num); }
/////////////////////////////////////////////////////////////////////////// // // US_PrintUnsigned() - Prints an unsigned long // /////////////////////////////////////////////////////////////////////////// void US_PrintUnsigned(longword n) { char buffer[32]; US_Print(ultoa(n,buffer,10)); }
unsigned ReqGet_err_text( void ) { static char *DosErrMsgs[] = { #define pick(a,b) b, #include "dosmsgs.h" #undef pick }; get_err_text_req *acc; char *err_txt; if( !TaskLoaded ) { acc = GetInPtr( 0 ); err_txt = GetOutPtr( 0 ); if( LoadError != NULL ) { strcpy( err_txt, LoadError ); LoadError = NULL; } else if( acc->err < ERR_LAST ) { strcpy( err_txt, DosErrMsgs[ acc->err ] ); } else { strcpy( err_txt, TRP_ERR_unknown_system_error ); ultoa( acc->err, err_txt + strlen( err_txt ), 16 ); } return( strlen( err_txt ) + 1 ); } return( DoAccess() ); }
void loop() // run over and over again { ultoa( encoder0Pos, msg1, 10); //ultoa ( second, msg1, 10); digitalWrite(12, 0); //delay(1); lcd.print( msg1); digitalWrite(12, 1); delay(100); /* if (oldSecond != second) { Serial.print(second); Serial.print(". ->"); Serial.print(millis() - starttime); Serial.println("."); delay(100); oldSecond = second; } */ }
byte ESP8266_Simple::startHttpServer(unsigned port, unsigned long (* requestHandler)(char *buffer, int bufferLength), unsigned int maxBufferSize) { char cmdBuffer[64]; byte responseCode; this->httpServerRequestHandler = requestHandler; this->httpServerMaxBufferSize = maxBufferSize; // Enter MUX mode responseCode = this->sendCommand(F("AT+CIPMUX=1")); if(responseCode != ESP8266_OK) return responseCode; // Set Server Timeout memset(cmdBuffer,0,sizeof(cmdBuffer)); strcpy_P(cmdBuffer, PSTR("AT+CIPSTO=,")); ultoa(this->generalCommandTimeoutMicroseconds/1000/1000, cmdBuffer+strlen(cmdBuffer), 10); this->sendCommand(cmdBuffer); // Start Server memset(cmdBuffer,0,sizeof(cmdBuffer)); strcpy_P(cmdBuffer, PSTR("AT+CIPSERVER=1,")); itoa(port, cmdBuffer+strlen(cmdBuffer), 10); responseCode = this->sendCommand(cmdBuffer); if(responseCode != ESP8266_OK) return responseCode; return ESP8266_OK; }
/* * Convert given signed long integer (@num) to ascii using * desired radix. Return the number of ascii chars printed. * @size: output buffer size */ static int ltoa(signed long num, char *buf, int size, int radix) { printk_assert(radix > 2 && radix <= PRINTK_MAX_RADIX); if (num < 0) { /* Make room for the '-' */ printk_assert(size >= 2); num *= -1; buf[0] = '-'; return ultoa(num, buf+1, size-1, radix) + 1; } return ultoa(num, buf, size, radix); }
//--------------------------------------------------------------------------- UINT GetTempFileName(char *PathName,char *Prefix,UINT Unique,char *TempFileName) { EasyStr Ret; WORD Num=WORD(Unique ? WORD(Unique):WORD(rand() & 0xffff)); for(;;){ Ret=PathName; Ret+=SLASH; Ret+=Prefix; Ret.SetLength(MAX_PATH+4); char *StartOfNum=Ret.Right()+1; ultoa(Num,StartOfNum,16); strupr(StartOfNum); Ret+=".TMP"; if (Ret.Length()<MAX_PATH){ if (Unique==0){ if (access(Ret,0)==0){ //File exists Num++; }else{ strcpy(TempFileName,Ret); fclose(fopen(TempFileName,"wb")); return Num; } }else{ strcpy(TempFileName,Ret); return Num; } }else{ return 0; } } }
String & String::append(unsigned long num) { char buf[11]; ultoa(num, buf, 10); append(buf, strlen(buf)); return *this; }
String::String(unsigned long value, unsigned char base) { init(); char buf[1 + 8 * sizeof(unsigned long)]; ultoa(value, buf, base); *this = buf; }
/* Adds the elfcorehdr= command line parameter to command line. */ static int cmdline_add_elfcorehdr(char *cmdline, unsigned long addr) { int cmdlen, len, align = 1024; char str[30], *ptr; /* Passing in elfcorehdr=xxxK format. Saves space required in cmdline. * Ensure 1K alignment*/ if (addr%align) return -1; addr = addr/align; ptr = str; strcpy(str, " elfcorehdr="); ptr += strlen(str); ultoa(addr, ptr); strcat(str, "K"); len = strlen(str); cmdlen = strlen(cmdline) + len; if (cmdlen > (COMMAND_LINE_SIZE - 1)) die("Command line overflow\n"); strcat(cmdline, str); #if 0 printf("Command line after adding elfcorehdr\n"); printf("%s\n", cmdline); #endif return 0; }
void DumpType( // DUMP TYPE ENTRY TYPE tp ) // - type pointer { char *id; // - id for symbol if( tp == NULL ) { printf( "NULL type\n" ); return; } if( tp->id >= TYP_MAX ) { ultoa( tp->id, unknown_type + sizeof( unknown_type ) - 2, 16 ); id = unknown_type; } else { id = id_names[ tp->id ]; } printf( "TYPE" F_BADDR " next" F_PTR " id=" F_STRING " flag" F_HEX_1 " of" F_PTR " u1" F_PTR " u2" F_PTR F_EOL , tp , tp->next , id , tp->flag , tp->of , tp->u.f.args , tp->u.f.pragma ); }
void xpcc::IOStream::writeInteger(uint32_t value) { #if defined(XPCC__CPU_AVR) char buffer[ArithmeticTraits<uint32_t>::decimalDigits + 1]; // +1 for '\0' // Uses the optimized non standard function 'ultoa()' which is // not always available. this->device->write(ultoa(value, buffer, 10)); #else char buffer[ArithmeticTraits<uint32_t>::decimalDigits + 1]; // +1 for '\0' // ptr points to the end of the string, it will be filled backwards char *ptr = buffer + ArithmeticTraits<uint32_t>::decimalDigits; *ptr = '\0'; // calculate the string backwards do{ uint32_t quot = value / 10; uint8_t rem = value - quot*10; *(--ptr) = static_cast<char>(rem) + '0'; value = quot; }while (value != 0); // write string this->device->write(ptr); #endif }
char* MyMessage::getString(char *buffer) const { uint8_t payloadType = miGetPayloadType(); if (payloadType == P_STRING) { strncpy(buffer, data, miGetLength()); buffer[miGetLength()] = 0; return buffer; } else if (buffer != NULL) { if (payloadType == P_BYTE) { itoa(bValue, buffer, 10); } else if (payloadType == P_INT16) { itoa(iValue, buffer, 10); } else if (payloadType == P_UINT16) { utoa(uiValue, buffer, 10); } else if (payloadType == P_LONG32) { ltoa(lValue, buffer, 10); } else if (payloadType == P_ULONG32) { ultoa(ulValue, buffer, 10); } else if (payloadType == P_FLOAT32) { dtostrf(fValue,2,fPrecision,buffer); } else if (payloadType == P_CUSTOM) { return getCustomString(buffer); } return buffer; } else { return NULL; } }
NAME NameDummy( void ) /********************/ { name_dummy_index_t ni; unsigned xhash; unsigned bucket; unsigned len; idname **head; char buff[ 1 + 1 + sizeof( ni ) * 3 + 1 ]; ExtraRptIncrementCtr( ctr_dummy_names ); ni = nameDummyIndex++; xhash = ni % NAME_TABLE_HASH; bucket = xhash; buff[0] = NAME_OPERATOR_OR_DUMMY_PREFIX1; buff[1] = NAME_DUMMY_PREFIX2; // the contents of the name don't have to be different just the address // but for debugging it is handy to have unique contents #ifndef NDEBUG ultoa( ni, &buff[2], 10 ); len = strlen( buff ); #else buff[2] = '0'; buff[3] = '\0'; len = 3; #endif head = &(hashTable[ bucket ]); return( nameAdd( head, bucket, xhash, buff, len ) ); }
static int add_cmdline_param(char *cmdline, uint64_t addr, char *cmdstr, char *byte) { int cmdlen, len, align = 1024; char str[COMMAND_LINE_SIZE], *ptr; /* Passing in =xxxK / =xxxM format. Saves space required in cmdline.*/ switch (byte[0]) { case 'K': if (addr%align) return -1; addr = addr/align; break; case 'M': addr = addr/(align *align); break; } ptr = str; strcpy(str, cmdstr); ptr += strlen(str); ultoa(addr, ptr); strcat(str, byte); len = strlen(str); cmdlen = strlen(cmdline) + len; if (cmdlen > (COMMAND_LINE_SIZE - 1)) die("Command line overflow\n"); strcat(cmdline, str); #if DEBUG fprintf(stderr, "Command line after adding elfcorehdr: %s\n", cmdline); #endif return 0; }
unsigned char String::concat(unsigned long num) { char buf[11]; ultoa(num, buf, 10); return concat( buf, strlen(buf) ); }
uint8_t* f2str(freq_t f, uint8_t *buffer, uint8_t len) { uint8_t i; uint8_t j; uint8_t *p; // Mhz ultoa(f_MHZ(f), buffer, 10); i = len - strlen(buffer); j = 0; p = buffer + strlen(buffer); // multiply fractional part to get the rest of required digits while (j < i) { if (j & 0b11) { f = 10 * (f - MHZ_f(f_MHZ(f))); *p = '0' + f_MHZ(f); } else{ if (j == 0) *p = ','; else *p = '.'; } ++p; ++j; } // discard ending dot if (*(p-1) == '.') --p; *p = '\0'; return buffer; }
void fib(void *n){ unsigned long val; char str_val[100]={0}; if(n == NULL) { print_str("Invalid argument\n"); print_str("Usage: fin n\n"); } val = strtol(n,NULL,10); print_str("input n is "); print_str(n); print_str("\r\n\0"); print_str("calculating... "); val = fibonacci(val); print_str("\r\n\0"); print_str("fib(n) : "); ultoa(val, str_val, 10); print_str(str_val); print_str("\r\n\n\0"); return; }
void scr_el( void ) { ifcb * cb = input_cbs->if_cb; char linestr[MAX_L_AS_STR]; scan_err = false; cb->if_flags[cb->if_level].iflast = false; cb->if_flags[cb->if_level].ifcwte = false; if( !(cb->if_flags[cb->if_level].iftrue || cb->if_flags[cb->if_level].iffalse) || cb->if_flags[cb->if_level].ifthen || cb->if_flags[cb->if_level].ifelse || cb->if_flags[cb->if_level].ifdo ) { scan_err = true; g_err( err_if_else ); if( input_cbs->fmflags & II_macro ) { ultoa( input_cbs->s.m->lineno, linestr, 10 ); g_info( inf_mac_line, linestr, input_cbs->s.m->mac->name ); } else { ultoa( input_cbs->s.f->lineno, linestr, 10 ); g_info( inf_file_line, linestr, input_cbs->s.f->filename ); } show_ifcb( "else", cb ); show_include_stack(); err_count++; return; } cb->if_flags[cb->if_level].ifelse = true; ProcFlags.keep_ifstate = true; if( input_cbs->fmflags & II_research && GlobalFlags.firstpass ) { show_ifcb( "else", cb ); } garginit(); // find end of control word while( *scan_start == ' ' ) { scan_start++; } if( *scan_start ) { // rest of line is not empty split split_input( buff2, scan_start, false );// and process next } scan_restart = scan_stop + 1; return; }
/* * generate and transmit pathname block consisting of * pathname (null terminated), * file length, mode time and file mode in octal * as provided by the Unix fstat call. * N.B.: modifies the passed name, may extend it! */ int wctxpn(const char *name) { char *p, *q; //DSERIAL.println("\nwctxpn"); strcpy(txbuf,name); p = q = txbuf + strlen(txbuf)+1; //Pete (El Supremo) fix bug - was 1024, should be TXBSIZE?? while (q < (txbuf + TXBSIZE)) *q++ = 0; // if (!Ascii && (in!=stdin) && *name && fstat(fileno(in), &f)!= -1) if (!Ascii) // I will have to figure out how to convert the uSD date/time format to a UNIX epoch // sprintf(p, "%lu %lo %o 0 %d %ld", fout.fileSize(), 0L,0600, Filesleft, Totalleft); // Avoid sprintf to save memory for small boards. This sketch doesn't know what time it is anyway ultoa(fout.fileSize(), p, 10); strcat_P(p, PSTR(" 0 0 0 ")); q = p + strlen(p); ultoa(Filesleft, q, 10); strcat_P(q, PSTR(" ")); q = q + strlen(q); ultoa(Totalleft, q, 10); Totalleft -= fout.fileSize(); //DSERIAL.print(F("wctxpn sf = ")); //DSERIAL.print(sf); //DSERIAL.print(F(" length = ")); //DSERIAL.println(Totalleft); if (--Filesleft <= 0) Totalleft = 0; if (Totalleft < 0) Totalleft = 0; /* force 1k blocks if name won't fit in 128 byte block */ //Pete (El Supremo) This can't be right??! if (txbuf[125]) // blklen=1024; blklen = TXBSIZE; else { /* A little goodie for IMP/KMD */ blklen = 128; txbuf[127] = (fout.fileSize() + 127) >>7; txbuf[126] = (fout.fileSize() + 127) >>15; } return zsendfile(txbuf, 1+strlen(p)+(p-txbuf)); }
/***************************************************************************************************************************** * * Read specified metric's value of the Winsen MH-Zxx CO2 sensor via UART, put it to output buffer on success. * * Returns: * - RESULT_IS_BUFFERED on success * - DEVICE_ERROR_TIMEOUT if device stop talking * *****************************************************************************************************************************/ int8_t getMHZxxMetricUART(const uint8_t _rxPin, const uint8_t _txPin, uint8_t* _dst, int32_t* _value, const uint8_t _wantsNumber) { uint8_t len, rc = DEVICE_ERROR_TIMEOUT; SoftwareSerial swSerial(_rxPin, _txPin); // Send query only if sensor heated if (millis() > MH_ZXX_PREHEAT_TIMEOUT) { swSerial.begin(MH_ZXX_UART_SPEED); _dst[MH_ZXX_STARTING_BYTE] = 0xFF; // Starting byte _dst[MH_ZXX_SENSOR_NUMBER] = 0x01; // Sensor No. _dst[MH_ZXX_CMD] = MH_ZXX_CMD_GAS_CONCENTRATION; // Command _dst[3] = _dst[4] = _dst[5] = _dst[6] = _dst[7] = 0x00; // Stub bytes _dst[MH_ZXX_CRC] = 0x79; // Check value // Flush all device's transmitted data to avoid get excess data in recieve buffer //serialRXFlush(&swSerial, !UART_SLOW_MODE); flushStreamRXBuffer(&swSerial, MH_ZXX_DEFAULT_READ_TIMEOUT, !UART_SLOW_MODE); // The serial stream can get out of sync. The response starts with 0xff, try to resync : https://github.com/jehy/arduino-esp8266-mh-z19-serial/blob/master/arduino-esp8266-mhz-19-serial.ino // Send command to MH-Zxx serialSend(&swSerial, _dst, MH_ZXX_PACKET_SIZE, !UART_SLOW_MODE); // Recieve from MH-Zxx // It actually do not use '\r', '\n', '\0' to terminate string len = serialRecive(&swSerial, _dst, MH_ZXX_PACKET_SIZE, MH_ZXX_DEFAULT_READ_TIMEOUT, !UART_STOP_ON_CHAR, '\r', !UART_SLOW_MODE); // Connection timeout occurs if (len < MH_ZXX_PACKET_SIZE) { rc = DEVICE_ERROR_TIMEOUT; goto finish; } // Wrong answer. buffer[0] must contain 0xFF if (0xFF != _dst[MH_ZXX_STARTING_BYTE]) { rc = DEVICE_ERROR_WRONG_ANSWER; goto finish; } // Bad CRC // CRC calculate for bytes #1..#9 (byte #0 excluded) if (_dst[MH_ZXX_CRC] != crcMHZxx(_dst)) { rc = DEVICE_ERROR_CHECKSUM; goto finish; } *_value = 256 * _dst[MH_ZXX_GAS_CONCENTRATION_HIGH_BYTE]; *_value += _dst[MH_ZXX_GAS_CONCENTRATION_LOW_BYTE]; } else { // if (millis() > MH_ZXX_PREHEAT_TIMEOUT) // Return 'good concentracion' while sensor heated *_value = MH_ZXX_PREHEAT_GAS_CONCENTRATION; } // if (millis() > MH_ZXX_PREHEAT_TIMEOUT) if (!_wantsNumber) { ultoa(*_value, (char*) _dst, 10); } rc = RESULT_IS_BUFFERED; finish: gatherSystemMetrics(); // Measure memory consumption swSerial.~SoftwareSerial(); return rc; }
String::String( const unsigned long value, const int base ) { char buf[33]; ultoa(value, buf, 10); getBuffer( _length = strlen(buf) ); if ( _buffer != NULL ) strcpy( _buffer, buf ); }