| /* |
| Copyright (c) 2011, Dmitry Grinberg (as published for DGOS on http://dgosblog.blogspot.com) |
| All rights reserved. |
| |
| Redistribution and use in source and binary forms, with or without |
| modification, are permitted provided that the following condition is met: |
| |
| * Redistributions of source code must retain the above copyright notice, this |
| list of conditions and the following disclaimer. |
| |
| THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND |
| ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED |
| WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
| DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR |
| ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES |
| (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
| LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND |
| ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS |
| SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| |
| #define ADK_INTERNAL |
| #include "fwk.h" |
| #include "printf.h" |
| #include <stdarg.h> |
| |
| typedef struct { |
| |
| void* dest; |
| uint32_t maxChars; |
| |
| void* furtherCallback; |
| void* furtherUserData; |
| |
| } PrintData; |
| |
| typedef char (*StrPrintfExCbk)(void* userData, char chr); //return 0 to stop printing |
| |
| static uint32_t StrPrvPrintfEx_number(StrPrintfExCbk putc_,void* userData,unsigned long long number,uint32_t base,char zeroExtend,char isSigned,char capitals,uint32_t padToLength, char* bail){ |
| |
| char buf[64]; |
| uint32_t idx = sizeof(buf) - 1; |
| uint32_t chr, i; |
| char neg = 0; |
| uint32_t numPrinted = 0; |
| |
| *bail = 0; |
| |
| if(padToLength > 63) padToLength = 63; |
| |
| buf[idx--] = 0; //terminate |
| |
| if(isSigned){ |
| |
| if(number & 0x8000000000000000ULL){ |
| |
| neg = 1; |
| number = -number; |
| } |
| } |
| |
| do{ |
| chr = number % base; |
| number = number / base; |
| |
| buf[idx--] = (chr >= 10)?(chr + (capitals ? 'A' : 'a') - 10):(chr + '0'); |
| |
| numPrinted++; |
| |
| }while(number); |
| |
| if(neg){ |
| |
| buf[idx--] = '-'; |
| numPrinted++; |
| } |
| |
| if(padToLength > numPrinted){ |
| |
| padToLength -= numPrinted; |
| } |
| else{ |
| |
| padToLength = 0; |
| } |
| |
| while(padToLength--){ |
| |
| buf[idx--] = zeroExtend?'0':' '; |
| numPrinted++; |
| } |
| |
| idx++; |
| |
| |
| for(i = 0; i < numPrinted; i++){ |
| |
| if(!putc_(userData,(buf + idx)[i])){ |
| |
| *bail = 1; |
| break; |
| } |
| } |
| |
| |
| return numPrinted; |
| } |
| |
| static uint32_t StrVPrintf_StrLen_withMax(const char* s,uint32_t max){ |
| |
| uint32_t len = 0; |
| |
| while((*s++) && (len < max)) len++; |
| |
| return len; |
| } |
| |
| static uint32_t StrVPrintf_StrLen(const char* s){ |
| |
| uint32_t len = 0; |
| |
| while(*s++) len++; |
| |
| return len; |
| } |
| |
| static inline char prvGetChar(const char** fmtP){ |
| |
| char ret; |
| const char* fmt; |
| |
| fmt = *fmtP; |
| ret = *fmt++; |
| *fmtP = fmt; |
| |
| return ret; |
| } |
| |
| static unsigned long long SignExt32to64(uint32_t v_){ |
| |
| unsigned long long v = v_; |
| |
| if(v & 0x80000000) v |= 0xFFFFFFFF00000000ULL; |
| |
| return v; |
| } |
| |
| static uint32_t StrVPrintfEx(StrPrintfExCbk putc_f,void* userData, const char* fmtStr,va_list vl){ |
| |
| char c; |
| uint32_t i, numPrinted = 0; |
| unsigned long long val64; |
| |
| #define putc_(_ud,_c) if(!putc_f(_ud,_c)) goto out; |
| |
| while((c = prvGetChar(&fmtStr)) != 0){ |
| |
| if(c == '\n'){ |
| |
| putc_(userData,c); |
| numPrinted++; |
| } |
| else if(c == '%'){ |
| |
| char zeroExtend = 0, useLong = 0, bail = 0, useVeryLong = 0; |
| uint32_t padToLength = 0,len; |
| const char* str; |
| int capitals = 0; |
| |
| more_fmt: |
| |
| c = prvGetChar(&fmtStr); |
| |
| switch(c){ |
| |
| case '%': |
| |
| putc_(userData,c); |
| numPrinted++; |
| break; |
| |
| case 'c': |
| |
| putc_(userData,va_arg(vl,unsigned int)); |
| numPrinted++; |
| break; |
| |
| case 's': |
| |
| str = va_arg(vl,char*); |
| if(!str) str = "(null)"; |
| if(padToLength){ |
| |
| len = StrVPrintf_StrLen_withMax(str,padToLength); |
| } |
| else{ |
| |
| padToLength = len = StrVPrintf_StrLen(str); |
| } |
| if(len > padToLength) len = padToLength; |
| else{ |
| |
| for(i=len;i<padToLength;i++) putc_(userData,L' '); |
| } |
| numPrinted += padToLength; |
| for(i = 0; i < len; i++){ |
| |
| putc_(userData,*str++); |
| } |
| numPrinted += len; |
| break; |
| |
| case '0': |
| |
| if(!zeroExtend && !padToLength){ |
| |
| zeroExtend = 1; |
| goto more_fmt; |
| } |
| |
| case '1': |
| case '2': |
| case '3': |
| case '4': |
| case '5': |
| case '6': |
| case '7': |
| case '8': |
| case '9': |
| |
| padToLength = (padToLength * 10) + c - '0'; |
| goto more_fmt; |
| |
| case 'u': |
| |
| val64 = useVeryLong ? va_arg(vl,unsigned long long) : va_arg(vl,uint32_t); |
| numPrinted += StrPrvPrintfEx_number(putc_f, userData,val64,10,zeroExtend,0,0,padToLength, &bail); |
| if(bail) goto out; |
| break; |
| |
| case 'd': |
| |
| val64 = useVeryLong ? va_arg(vl,unsigned long long) : SignExt32to64(va_arg(vl,uint32_t)); |
| numPrinted += StrPrvPrintfEx_number(putc_f, userData,val64,10,zeroExtend,1,0,padToLength, &bail); |
| if(bail) goto out; |
| break; |
| |
| case 'X': |
| |
| capitals = 1; |
| |
| case 'x': |
| |
| val64 = useVeryLong ? va_arg(vl,unsigned long long) : va_arg(vl,uint32_t); |
| numPrinted += StrPrvPrintfEx_number(putc_f, userData,val64,16,zeroExtend,0,capitals,padToLength, &bail); |
| if(bail) goto out; |
| break; |
| |
| case 'p': |
| |
| putc_(userData,'0'); |
| numPrinted++; |
| putc_(userData,'x'); |
| numPrinted++; |
| |
| val64 = va_arg(vl,unsigned long); |
| numPrinted += StrPrvPrintfEx_number(putc_f, userData,val64,16,0,0,0,0, &bail); |
| if(bail) goto out; |
| break; |
| |
| case 'b': |
| |
| val64 = useVeryLong ? va_arg(vl,unsigned long long) : va_arg(vl,uint32_t); |
| numPrinted += StrPrvPrintfEx_number(putc_f, userData,val64,2,zeroExtend,0,0,padToLength, &bail); |
| if(bail) goto out; |
| break; |
| |
| case 'l': |
| if(useLong) useVeryLong = 1; |
| useLong = 1; |
| goto more_fmt; |
| |
| default: |
| |
| putc_(userData,c); |
| numPrinted++; |
| break; |
| } |
| } |
| else{ |
| |
| putc_(userData,c); |
| numPrinted++; |
| } |
| } |
| |
| putc_(userData,0); //terminate it |
| numPrinted++; |
| |
| out: |
| |
| return numPrinted; |
| } |
| |
| |
| static char StrPrintF_putc(void* ud, char c){ |
| |
| PrintData* pd = ud; |
| char** dst = pd->dest; |
| char ret = 1; |
| |
| if(pd->maxChars-- == 1){ |
| |
| c = 0; |
| ret = 0; |
| } |
| |
| if(pd->furtherCallback){ |
| |
| ret = ((printf_write_c)pd->furtherCallback)(pd->furtherUserData, c); |
| } |
| else{ |
| *(*dst)++ = c; |
| } |
| |
| |
| return ret; |
| } |
| |
| uint32_t _sprintf(char* dst, const char* fmtStr, ...){ |
| |
| uint32_t ret; |
| va_list vl; |
| PrintData pd; |
| |
| pd.dest = &dst; |
| pd.maxChars = 0xFFFFFFFF; |
| pd.furtherCallback = NULL; |
| |
| va_start(vl,fmtStr); |
| |
| ret = StrVPrintfEx(&StrPrintF_putc, &pd, fmtStr,vl); |
| |
| va_end(vl); |
| |
| return ret; |
| } |
| |
| uint32_t _snprintf(char* dst, uint32_t maxChars, const char* fmtStr, ...){ |
| |
| uint32_t ret; |
| va_list vl; |
| PrintData pd; |
| |
| pd.dest = &dst; |
| pd.maxChars = maxChars; |
| pd.furtherCallback = NULL; |
| |
| va_start(vl,fmtStr); |
| |
| ret = StrVPrintfEx(&StrPrintF_putc, &pd, fmtStr,vl); |
| |
| va_end(vl); |
| |
| return ret; |
| } |
| |
| uint32_t _csprintf(printf_write_c writeF, void* writeD, const char* fmtStr, ...){ |
| |
| uint32_t ret; |
| va_list vl; |
| PrintData pd; |
| |
| pd.dest = NULL; |
| pd.maxChars = 0xFFFFFFFF; |
| pd.furtherCallback = writeF; |
| pd.furtherUserData = writeD; |
| |
| va_start(vl,fmtStr); |
| |
| ret = StrVPrintfEx(&StrPrintF_putc, &pd, fmtStr,vl); |
| |
| va_end(vl); |
| |
| return ret; |
| } |
| |
| uint32_t _csnprintf(printf_write_c writeF, void* writeD, uint32_t maxChars, const char* fmtStr, ...){ |
| |
| uint32_t ret; |
| va_list vl; |
| PrintData pd; |
| |
| pd.dest = NULL; |
| pd.maxChars = maxChars; |
| pd.furtherCallback = writeF; |
| pd.furtherUserData = writeD; |
| |
| va_start(vl,fmtStr); |
| |
| ret = StrVPrintfEx(&StrPrintF_putc, &pd, fmtStr,vl); |
| |
| va_end(vl); |
| |
| return ret; |
| } |
| |
| uint32_t _vsprintf(char* dst, const char* fmtStr, va_list vl){ |
| |
| uint32_t ret; |
| PrintData pd; |
| |
| pd.dest = &dst; |
| pd.maxChars = 0xFFFFFFFF; |
| pd.furtherCallback = NULL; |
| |
| ret = StrVPrintfEx(&StrPrintF_putc, &pd, fmtStr,vl); |
| |
| return ret; |
| } |
| |
| uint32_t _vsnprintf(char* dst, uint32_t maxChars, const char* fmtStr, va_list vl){ |
| |
| uint32_t ret; |
| PrintData pd; |
| |
| pd.dest = &dst; |
| pd.maxChars = maxChars; |
| pd.furtherCallback = NULL; |
| |
| ret = StrVPrintfEx(&StrPrintF_putc, &pd, fmtStr,vl); |
| |
| return ret; |
| } |
| |
| uint32_t _cvsprintf(printf_write_c writeF, void* writeD, const char* fmtStr, va_list vl){ |
| |
| uint32_t ret; |
| PrintData pd; |
| |
| pd.dest = NULL; |
| pd.maxChars = 0xFFFFFFFF; |
| pd.furtherCallback = writeF; |
| pd.furtherUserData = writeD; |
| |
| ret = StrVPrintfEx(&StrPrintF_putc, &pd, fmtStr,vl); |
| |
| return ret; |
| } |
| |
| uint32_t _cvsnprintf(printf_write_c writeF, void* writeD, uint32_t maxChars, const char* fmtStr, va_list vl){ |
| |
| uint32_t ret; |
| PrintData pd; |
| |
| pd.dest = NULL; |
| pd.maxChars = maxChars; |
| pd.furtherCallback = writeF; |
| pd.furtherUserData = writeD; |
| |
| ret = StrVPrintfEx(&StrPrintF_putc, &pd, fmtStr,vl); |
| |
| return ret; |
| } |
