Choco OS  V.0.16.9.0
Join to the chocolate world
oc_kprint.c
Go to the documentation of this file.
1 
27 #include <oc_kprint.h>
28 #include <oc_streamman.h>
29 #include <oc_processman.h>
30 #include <oc_stdlib.h>
31 #include <string.h>
32 #include <math.h>
33 #include <ctype.h>
34 
40 #define _________________________________________MACROS_SECTION_____________________________________________________________________________
41 
42 #define ZEROPAD 1
43 #define SIGN 2
44 #define PLUS 4
45 #define SPACE 8
46 #define LEFT 16
47 #define SPECIAL 32
48 #define LARGE 64
49 #define IsDigit(c) ((c) >= '0' && (c) <= '9')
50 #define IsBinary(c) ((c) >= '0' && (c) <= '1')
51 #define IsOctal(c) ((c) >= '0' && (c) <= '8')
52 #define IsHex(c) ( IsDigit(c) || ( (c) >= 'a' && (c) <= 'f' ) || ( (c) >= 'A' && (c) <= 'F' ))
53 
54 
55 #undef _________________________________________MACROS_SECTION_____________________________________________________________________________
56 
62 #define _________________________________________TYPES_SECTION______________________________________________________________________________
63 
64 typedef enum
65 {
66  /* d / i specifiers */
67  PointerType_Int = 0 ,
68  PointerType_SignedChar = 1 ,
69  PointerType_ShortInt = 2 ,
70  PointerType_LongInt = 3 ,
71  PointerType_LongLongInt = 4 ,
72  PointerType_IntMax = 5 ,
73  PointerType_Size = 6 ,
74  PointerType_PtrDiff = 7 ,
75 
76  /* u o x */
77  PointerType_UnsignedInt = 0 ,
78  PointerType_UnsignedChar = 1 ,
79  PointerType_UnsignedShortInt = 2 ,
80  PointerType_UnsignedLongInt = 3 ,
81  PointerType_UnsignedLongLongInt = 4 ,
82  PointerType_UnsignedIntMax = 5 ,
83 
84  /* f e g a */
85  PointerType_Float = 0 ,
86  PointerType_Double = 3 ,
87  PointerType_LongDouble = 8 ,
88 
89  /* c s [] [^] */
90  PointerType_Char = 0 ,
91  PointerType_WChar = 3 ,
92 
93  /* p */
94  PointerType_Void = 0 ,
95 
96 } PointerType_t;
97 
98 typedef enum
99 {
100  ScanfFlags_Ignored = (1<<0) ,
101  ScanfFlags_Signed = (1<<1) ,
102  ScanfFlags_Unsigned = (1<<2) ,
103 } ScanfFlags_t;
104 
105 #undef _________________________________________TYPES_SECTION______________________________________________________________________________
106 
107 
113 #define _________________________________________LOCAL_PROTOTYPES_SECTION___________________________________________________________________
114 
115 static oC_ErrorCode_t ReadInputStream( oC_Stream_t * outStream );
116 static oC_ErrorCode_t ReadOutputStream( oC_Stream_t * outStream );
117 static bool PutcToBuffer( char ** outBuffer , char * EndPointer , char C );
118 static int SkipAToI(const char ** Format );
119 static oC_ErrorCode_t PutNumber( char ** outBuffer , char * EndPointer , long Number , int Base , int FieldWidth , int Precision, int Type );
120 static oC_ErrorCode_t PutLongFloatInHex( char ** outBuffer , char * EndPointer , unsigned char * Address, int FieldWidth, int Precision, int Type );
121 static oC_ErrorCode_t PutFloatInHex( char ** outBuffer , char * EndPointer , unsigned char * Address, int FieldWidth, int Precision, int Type );
122 static oC_ErrorCode_t PutFloat( char ** outBuffer , char * EndPointer , double Number , int FieldWidth, int Precision, char Format, int Flags );
123 static oC_ErrorCode_t ReadNumber( const char ** Buffer , va_list * ArgumentList , int Base , ScanfFlags_t Flags , int FieldWidth , PointerType_t PointerType );
124 static oC_ErrorCode_t ReadFloat( const char ** Buffer , va_list * ArgumentList , ScanfFlags_t Flags , int FieldWidth , PointerType_t PointerType );
125 static oC_ErrorCode_t ReadChar( const char ** Buffer , va_list * ArgumentList , ScanfFlags_t Flags , int FieldWidth );
126 static oC_ErrorCode_t ReadString( const char ** Buffer , va_list * ArgumentList , ScanfFlags_t Flags , int FieldWidth );
127 static oC_ErrorCode_t ReadPointer( const char ** Buffer , va_list * ArgumentList , ScanfFlags_t Flags );
128 static oC_ErrorCode_t ReadScanset( const char ** Buffer , va_list * ArgumentList , ScanfFlags_t Flags , int FieldWidth , const char * ScansetBegin , const char * ScansetEnd , bool ScansetInverted );
129 
130 #undef _________________________________________LOCAL_PROTOTYPES_SECTION___________________________________________________________________
131 
132 
138 #define _________________________________________VARIABLES_SECTION__________________________________________________________________________
139 
140 static bool ModuleEnabledFlag = false;
141 static const char *Digits = "0123456789abcdefghijklmnopqrstuvwxyz";
142 static const char *UpperDigits = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
143 
144 #undef _________________________________________VARIABLES_SECTION__________________________________________________________________________
145 
146 
152 #define _________________________________________INTERFACE_SECTION__________________________________________________________________________
153 
154 //==========================================================================================================================================
155 //==========================================================================================================================================
156 oC_ErrorCode_t oC_KPrint_TurnOn( void )
157 {
158  oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;
159 
160  if(oC_AssignErrorCodeIfFalse(&errorCode,ModuleEnabledFlag == false , oC_ErrorCode_ModuleIsTurnedOn))
161  {
162  ModuleEnabledFlag = true;
163  errorCode = oC_ErrorCode_None;
164  }
165 
166  return errorCode;
167 }
168 
169 //==========================================================================================================================================
170 //==========================================================================================================================================
171 oC_ErrorCode_t oC_KPrint_TurnOff( void )
172 {
173  oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;
174 
175  if(oC_AssignErrorCodeIfFalse(&errorCode,ModuleEnabledFlag == true , oC_ErrorCode_ModuleNotStartedYet))
176  {
177  ModuleEnabledFlag = false;
178  errorCode = oC_ErrorCode_None;
179  }
180 
181  return errorCode;
182 }
183 
184 //==========================================================================================================================================
195 //==========================================================================================================================================
196 oC_ErrorCode_t oC_KPrint_Format( char * outBuffer , oC_UInt_t Size , const char * Format , va_list ArgumentList )
197 {
198  oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;
199 
200  if(
201  oC_AssignErrorCodeIfFalse(&errorCode, ModuleEnabledFlag == true , oC_ErrorCode_ModuleNotStartedYet) &&
202  oC_AssignErrorCodeIfFalse(&errorCode, isram(outBuffer) , oC_ErrorCode_OutputAddressNotInRAM) &&
203  oC_AssignErrorCodeIfFalse(&errorCode, isaddresscorrect(Format) , oC_ErrorCode_WrongAddress)
204  )
205  {
206  int flags;
207  int fieldWidth;
208  int precision;
209  int qualifier;
210  int base;
211  char * endPointer = &outBuffer[Size];
212  char * startBuffer= outBuffer;
213 
214  errorCode = oC_ErrorCode_None;
215 
216  for( ;*Format != '\0';Format++)
217  {
218 #define _putc(c) if(PutcToBuffer(&outBuffer,endPointer,c)==false){ errorCode = oC_ErrorCode_OutputBufferTooSmall; break; }
219  if(*Format != '%')
220  {
221  _putc(*Format);
222  continue;
223  }
224 
225  //==============================================================================================================================
226  /*
227  * Read format flags
228  */
229  //==============================================================================================================================
230  flags = 0;
231 
232 repeat:
233  Format++;
234  switch (*Format)
235  {
236  case '-': flags |= LEFT; goto repeat;
237  case '+': flags |= PLUS; goto repeat;
238  case ' ': flags |= SPACE; goto repeat;
239  case '#': flags |= SPECIAL; goto repeat;
240  case '0': flags |= ZEROPAD; goto repeat;
241  }
242 
243  //==============================================================================================================================
244  /*
245  * Read field width
246  */
247  //==============================================================================================================================
248  fieldWidth = -1;
249 
250  if( IsDigit(*Format) )
251  {
252  fieldWidth = SkipAToI(&Format);
253  }
254  else if(*Format == '*')
255  {
256  Format++;
257  fieldWidth = va_arg(ArgumentList, int);
258 
259  if(fieldWidth < 0)
260  {
261  fieldWidth = -fieldWidth;
262  flags |= LEFT;
263  }
264  }
265 
266  //==============================================================================================================================
267  /*
268  * Read precision
269  */
270  //==============================================================================================================================
271  precision = -1;
272  if (*Format == '.')
273  {
274  ++Format;
275 
276  if( IsDigit(*Format) )
277  {
278  precision = SkipAToI(&Format);
279  }
280  else if (*Format == '*')
281  {
282  ++Format;
283  precision = va_arg(ArgumentList, int);
284  }
285  if (precision < 0)
286  {
287  precision = 0;
288  }
289  }
290 
291  //==============================================================================================================================
292  /*
293  * Read the conversion qualifier
294  */
295  //==============================================================================================================================
296  qualifier = -1;
297  if (*Format == 'h' || *Format == 'l' || *Format == 'L')
298  {
299  qualifier = *Format;
300  Format++;
301  }
302 
303  // Default base
304  base = 10;
305 
306  //==============================================================================================================================
307  /*
308  * Recognize the identifier
309  */
310  //==============================================================================================================================
311  switch(*Format)
312  {
313  // /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
314  /* Character identifier section */
315  case 'c':
316  {
317  if(!(flags & LEFT))
318  {
319  while (--fieldWidth > 0)
320  {
321  _putc(' ');
322  }
323  }
324 
325  _putc((unsigned char) va_arg(ArgumentList, int));
326 
327  while (--fieldWidth > 0)
328  {
329  _putc(' ');
330  }
331  continue;
332  }
333  // /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
334  /* String identifier section */
335  case 's':
336  {
337  int length = 0;
338  char * string = va_arg(ArgumentList, char *);
339  int index = 0;
340 
341  if( string == NULL )
342  {
343  string = "<NULL>";
344  }
345  else if (isaddresscorrect(string)==false)
346  {
347  string = "<string address not correct>";
348  errorCode = oC_ErrorCode_WrongAddress;
349  }
350 
351  length = strnlen(string, precision);
352 
353  if (!(flags & LEFT))
354  {
355  while (--fieldWidth >= length )
356  {
357  _putc(' ');
358  }
359  }
360  for (index = 0; index < length; ++index)
361  {
362  fieldWidth--;
363  _putc(*string++);
364  }
365 
366  while (--fieldWidth > 0)
367  {
368  _putc(' ');
369  }
370 
371  continue;
372  }
373  // /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
374  /* Pointer identifier section */
375  case 'p':
376  {
377  if( fieldWidth == -1 )
378  {
379  fieldWidth = 2 * sizeof(void *) + 2; // + 2 for a 0x
380  flags |= ZEROPAD | SPECIAL;
381  }
382  oC_AssignErrorCode(&errorCode , PutNumber(&outBuffer , endPointer , (unsigned long) va_arg(ArgumentList, void *), 16, fieldWidth, precision, flags));
383  continue;
384  }
385  // /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
386  /* Nothing printed identifier section */
387  case 'n':
388  {
389  if (qualifier == 'l')
390  {
391  long *ip = va_arg(ArgumentList, long *);
392  if(oC_AssignErrorCodeIfFalse(&errorCode , isram(ip) , oC_ErrorCode_OutputAddressNotInRAM))
393  {
394  *ip = (outBuffer - startBuffer);
395  }
396  }
397  else
398  {
399  int *ip = va_arg(ArgumentList, int *);
400  if(oC_AssignErrorCodeIfFalse(&errorCode , isram(ip) , oC_ErrorCode_OutputAddressNotInRAM))
401  {
402  *ip = (outBuffer - startBuffer);
403  }
404  }
405  }
406  continue;
407  // /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
408  /* Hexadecimal floating point */
409  case 'A':
410  {
411  flags |= LARGE;
412  }
413  // no break
414  case 'a':
415  {
416  if (qualifier == 'l')
417  {
418  oC_AssignErrorCode(&errorCode , PutLongFloatInHex(&outBuffer , endPointer , va_arg(ArgumentList, unsigned char *), fieldWidth, precision, flags));
419  }
420  else
421  {
422  oC_AssignErrorCode(&errorCode , PutFloatInHex(&outBuffer , endPointer , va_arg(ArgumentList, unsigned char *), fieldWidth, precision, flags));
423  }
424  continue;
425  }
426 
427  // /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
428  /* Integer numbers */
429  case 'o':
430  base = 8;
431  break;
432 
433  case 'X':
434  flags |= LARGE;
435  // no break
436  case 'x':
437  base = 16;
438  break;
439 
440  case 'd':
441  case 'i':
442  flags |= SIGN;
443  // no break
444  case 'u':
445  break;
446 
447  // /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
448  /* Floating numbers */
449  case 'E':
450  case 'G':
451  case 'e':
452  case 'f':
453  case 'g':
454  {
455  double dnumber = va_arg(ArgumentList, double);
456  oC_AssignErrorCode(&errorCode , PutFloat(&outBuffer , endPointer , dnumber , fieldWidth, precision, *Format, flags | SIGN));
457  }
458  continue;
459  default:
460  if( *Format != '%' )
461  {
462  _putc('%');
463  }
464  if (*Format)
465  {
466  _putc(*Format);
467  }
468  else
469  {
470  --Format;
471  }
472  continue;
473  }
474  unsigned long number = 0;
475 
476  if (qualifier == 'l')
477  {
478  number = va_arg(ArgumentList, unsigned long);
479  }
480  else if (qualifier == 'h')
481  {
482  if (flags & SIGN)
483  {
484  number = va_arg(ArgumentList, int);
485  }
486  else
487  {
488  number = va_arg(ArgumentList, unsigned int);
489  }
490  }
491  else if (flags & SIGN)
492  {
493  number = va_arg(ArgumentList, int);
494  }
495  else
496  {
497  number = va_arg(ArgumentList, unsigned int);
498  }
499  oC_AssignErrorCode(&errorCode , PutNumber(&outBuffer , endPointer , number , base , fieldWidth , precision , flags));
500  if(errorCode == oC_ErrorCode_OutputBufferTooSmall)
501  {
502  endPointer--;
503  *endPointer = '\0';
504  }
505 #undef _putc
506  }
507  }
508 
509  return errorCode;
510 }
511 
512 //==========================================================================================================================================
513 //==========================================================================================================================================
514 oC_ErrorCode_t oC_KPrint_Printf( char * outBuffer , oC_UInt_t Size , oC_IoFlags_t IoFlags , const char * Format , ... )
515 {
516  oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;
517 
518  if(oC_AssignErrorCodeIfFalse(&errorCode,ModuleEnabledFlag == true , oC_ErrorCode_ModuleNotStartedYet))
519  {
520  va_list argumentList;
521 
522  va_start(argumentList, Format);
523  errorCode = oC_KPrint_VPrintf(outBuffer,Size,IoFlags,Format,argumentList);
524  va_end(argumentList);
525  }
526 
527  return errorCode;
528 }
529 
530 //==========================================================================================================================================
531 //==========================================================================================================================================
532 oC_ErrorCode_t oC_KPrint_VPrintf( char * outBuffer , oC_UInt_t Size , oC_IoFlags_t IoFlags , const char * Format , va_list ArgumentList )
533 {
534  oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;
535 
536  if(oC_AssignErrorCodeIfFalse(&errorCode,ModuleEnabledFlag == true , oC_ErrorCode_ModuleNotStartedYet))
537  {
538  errorCode = oC_KPrint_Format(outBuffer,Size,Format,ArgumentList);
539 
540  if(!oC_ErrorOccur(errorCode) || errorCode == oC_ErrorCode_OutputBufferTooSmall )
541  {
542  errorCode = oC_KPrint_WriteToStdOut(IoFlags,outBuffer,strlen(outBuffer));
543  }
544  }
545 
546  return errorCode;
547 }
548 
549 //==========================================================================================================================================
550 //==========================================================================================================================================
551 oC_ErrorCode_t oC_KPrint_DriverPrintf( char * outBuffer , oC_UInt_t Size , oC_IoFlags_t IoFlags , oC_Driver_t Driver , const char * Format , ... )
552 {
553  oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;
554 
555  if(oC_AssignErrorCodeIfFalse(&errorCode,ModuleEnabledFlag == true , oC_ErrorCode_ModuleNotStartedYet))
556  {
557  va_list argumentList;
558  oC_Stream_t stream = NULL;
559 
560  va_start(argumentList, Format);
561  if(
562  oC_AssignErrorCode( &errorCode , ReadOutputStream(&stream) ) &&
563  oC_AssignErrorCodeIfFalse(&errorCode , oC_Stream_GetDriver(stream) != Driver , oC_ErrorCode_RecursiveDriverUsage) &&
564  oC_AssignErrorCode( &errorCode , oC_KPrint_Format(outBuffer,Size,Format,argumentList))
565  )
566  {
567  errorCode = oC_KPrint_WriteToStdOut(IoFlags,outBuffer,Size);
568  }
569  va_end(argumentList);
570  }
571 
572  return errorCode;
573 }
574 
575 //==========================================================================================================================================
576 //==========================================================================================================================================
577 oC_ErrorCode_t oC_KPrint_FormatScanf( const char * Buffer , const char * Format , va_list ArgumentList )
578 {
579  oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;
580 
581  if(
582  oC_AssignErrorCodeIfFalse(&errorCode, ModuleEnabledFlag == true , oC_ErrorCode_ModuleNotStartedYet) &&
583  oC_AssignErrorCodeIfFalse(&errorCode, isaddresscorrect(Buffer) , oC_ErrorCode_WrongAddress) &&
584  oC_AssignErrorCodeIfFalse(&errorCode, isaddresscorrect(Format) , oC_ErrorCode_WrongAddress)
585  )
586  {
587 #define _getc() (*Buffer++)
588  errorCode = oC_ErrorCode_None;
589 
590 
591  for(;oC_ErrorOccur(errorCode) == false && isaddresscorrect(Format) && isaddresscorrect(Buffer) && (*Format) && (*Buffer); Format++ )
592  {
593  if(*Format == '%')
594  {
595  ScanfFlags_t flags = 0;
596  oC_UInt_t fieldWidth = 0;
597  PointerType_t pointerType= 0;
598  int base = 0;
599 
600  Format++; /* Skip '%' */
601 
602  /* Check if argument is ignored */
603  if(*Format == '*')
604  {
605  flags |= ScanfFlags_Ignored;
606  Format++;
607  }
608 
609  /* Read field width */
610  while(IsDigit(*Format) && isaddresscorrect(Format))
611  {
612  fieldWidth *= 10;
613  fieldWidth += (int)(*Format - '0');
614  Format++;
615  }
616 
617  /* Read length = pointer type */
618  switch(*Format)
619  {
620  case 'h':
621  Format++;
622  if(*Format == 'h')
623  {
624  Format++;
625  pointerType = 1;
626  }
627  else
628  {
629  pointerType = 2;
630  }
631  break;
632  case 'l':
633  Format++;
634  if(*Format == 'l')
635  {
636  Format++;
637  pointerType = 4;
638  }
639  else
640  {
641  pointerType = 3;
642  }
643  break;
644  case 'j':
645  Format++;
646  pointerType = 5;
647  break;
648  case 'z':
649  Format++;
650  pointerType = 6;
651  break;
652  case 't':
653  Format++;
654  pointerType = 7;
655  break;
656  case 'L':
657  Format++;
658  pointerType = 8;
659  break;
660  }
661 
662  switch(*Format)
663  {
664  case '%':
665  if(_getc() != *Format)
666  {
667  errorCode = oC_ErrorCode_StringNotAsExpected;
668  }
669  break;
670  /* Auto-base integer */
671  case 'i':
672  flags |= ScanfFlags_Signed;
673  base = 0;
674 
675  errorCode = ReadNumber( &Buffer , &ArgumentList , base , flags , fieldWidth , pointerType );
676  break;
677  /* Binary integer */
678  case 'b':
679  flags |= ScanfFlags_Unsigned;
680  base = 2;
681 
682  errorCode = ReadNumber( &Buffer , &ArgumentList , base , flags , fieldWidth , pointerType );
683  break;
684  /* Decimal integer */
685  case 'd':
686  case 'u':
687  flags |= ScanfFlags_Signed;
688  base = 10;
689 
690  errorCode = ReadNumber( &Buffer , &ArgumentList , base , flags , fieldWidth , pointerType );
691  break;
692  /* Octal integer */
693  case 'o':
694  flags |= ScanfFlags_Unsigned;
695  base = 8;
696 
697  errorCode = ReadNumber( &Buffer , &ArgumentList , base , flags , fieldWidth , pointerType );
698  break;
699  /* Hexadecimal integer */
700  case 'x':
701  flags |= ScanfFlags_Unsigned;
702  base = 16;
703 
704  errorCode = ReadNumber( &Buffer , &ArgumentList , base , flags , fieldWidth , pointerType );
705  break;
706  /* Floating-point */
707  case 'f':
708  case 'e':
709  case 'g':
710  case 'a':
711  flags |= ScanfFlags_Signed;
712  base = 0;
713 
714  errorCode = ReadFloat( &Buffer , &ArgumentList , flags , fieldWidth , pointerType );
715  break;
716  /* Character */
717  case 'c':
718  errorCode = ReadChar( &Buffer , &ArgumentList , flags , fieldWidth );
719  break;
720  /* String */
721  case 's':
722  errorCode = ReadString( &Buffer , &ArgumentList, flags , fieldWidth );
723  break;
724  case 'p':
725  errorCode = ReadPointer( &Buffer , &ArgumentList , flags );
726  break;
727  case '[':
728  {
729  bool scansetInverted = false;
730 
731  Format++;
732 
733  if(*Format == '^')
734  {
735  Format++;
736  scansetInverted = true;
737  }
738 
739  const char * scansetBegin = Format;
740  const char * scansetEnd = Format;
741 
742  while( (isaddresscorrect(scansetEnd)) && (*scansetEnd != 0) && (*scansetEnd != ']'))
743  {
744  scansetEnd++;
745  Format++;
746  }
747 
748  errorCode = ReadScanset( &Buffer , &ArgumentList , flags , fieldWidth , scansetBegin , scansetEnd , scansetInverted );
749  }
750  break;
751 
752  case 'n':
753  default:
754  errorCode = oC_ErrorCode_SpecifierNotHandled;
755  break;
756 
757  }
758  }
759  else if(*Format == *Buffer)
760  {
761  Buffer++;
762  continue;
763  }
764  else
765  {
766  errorCode = oC_ErrorCode_StringNotAsExpected;
767  break;
768  }
769  }
770 
771 #undef _getc
772  }
773 
774  return errorCode;
775 }
776 
777 //==========================================================================================================================================
778 //==========================================================================================================================================
779 oC_ErrorCode_t oC_KPrint_Scanf( char * outBuffer , oC_UInt_t Size , oC_IoFlags_t IoFlags , const char * Format , ... )
780 {
781  oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;
782 
783  if(oC_AssignErrorCodeIfFalse(&errorCode, ModuleEnabledFlag == true , oC_ErrorCode_ModuleNotStartedYet))
784  {
785  va_list argumentList;
786  va_start(argumentList,Format);
787  errorCode = oC_KPrint_VScanf(outBuffer,Size,IoFlags,Format,argumentList);
788  va_end(argumentList);
789  }
790 
791  return errorCode;
792 }
793 
794 //==========================================================================================================================================
795 //==========================================================================================================================================
796 oC_ErrorCode_t oC_KPrint_VScanf( char * outBuffer , oC_UInt_t Size , oC_IoFlags_t IoFlags , const char * Format , va_list ArgumentList )
797 {
798  oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;
799 
800  if(
801  oC_AssignErrorCodeIfFalse(&errorCode, ModuleEnabledFlag == true , oC_ErrorCode_ModuleNotStartedYet) &&
802  oC_AssignErrorCodeIfFalse(&errorCode, isaddresscorrect(Format) , oC_ErrorCode_WrongAddress) &&
803  oC_AssignErrorCode(&errorCode, oC_KPrint_ReadFromStdIn(IoFlags,outBuffer,Size))
804  )
805  {
806  errorCode = oC_KPrint_FormatScanf(outBuffer,Format,ArgumentList);
807  }
808 
809  return errorCode;
810 }
811 
812 //==========================================================================================================================================
813 //==========================================================================================================================================
814 oC_ErrorCode_t oC_KPrint_WriteToStdOut( oC_IoFlags_t IoFlags , const char * Buffer , uint32_t Size )
815 {
816  oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;
817 
818  if(oC_AssignErrorCodeIfFalse(&errorCode , ModuleEnabledFlag == true , oC_ErrorCode_ModuleNotStartedYet))
819  {
820  oC_Stream_t stream = NULL;
821 
822  if(oC_AssignErrorCode(&errorCode , ReadOutputStream(&stream)))
823  {
824  char * eolRef = strchr(Buffer,'\n');
825  const char newline[] = "\r";
826 
827  if(eolRef != NULL)
828  {
829  uint32_t sentBytes = 0;
830  do
831  {
832  uint32_t newLineSize = 1;
833  uint32_t bytesToSend = 0;
834  bool sendEol = false;
835 
836  for( uint32_t i = sentBytes ; i < Size ; i++ )
837  {
838  bytesToSend++;
839 
840  if(Buffer[i] == '\n')
841  {
842  sendEol = true;
843  break;
844  }
845  }
846 
847  if(
848  ErrorCode( oC_Stream_Write( stream, &Buffer[sentBytes], &bytesToSend, IoFlags ))
849  && (
850  sendEol == false
851  || ErrorCode( oC_Stream_Write( stream, newline, &newLineSize, IoFlags ))
852  )
853  )
854  {
855  errorCode = oC_ErrorCode_None;
856  }
857  else
858  {
859  break;
860  }
861  sentBytes += bytesToSend;
862  } while( sentBytes < Size);
863  }
864  else
865  {
866  errorCode = oC_Stream_Write(stream,Buffer,&Size,IoFlags);
867  }
868 
869  }
870  }
871 
872  return errorCode;
873 }
874 
875 //==========================================================================================================================================
876 //==========================================================================================================================================
877 oC_ErrorCode_t oC_KPrint_ReadFromStdIn( oC_IoFlags_t IoFlags , char * outBuffer , uint32_t Size )
878 {
879  oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;
880 
881  if(
882  oC_AssignErrorCodeIfFalse(&errorCode , ModuleEnabledFlag == true , oC_ErrorCode_ModuleNotStartedYet) &&
883  oC_AssignErrorCodeIfFalse(&errorCode , isram(outBuffer) , oC_ErrorCode_OutputAddressNotInRAM)
884  )
885  {
886  oC_Stream_t stream = NULL;
887  oC_Stream_t outStream = NULL;
888  char passwordChar= '*';
889 
890  if(
891  oC_AssignErrorCode(&errorCode , ReadInputStream(&stream))
892  && ( !( IoFlags & oC_IoFlags_EchoWhenRead ) || oC_AssignErrorCode(&errorCode , ReadOutputStream(&outStream)) )
893  && ( !( IoFlags & oC_IoFlags_ClearRxBeforeRead ) || oC_AssignErrorCode(&errorCode , oC_Stream_ClearReadBuffer(stream)) )
894  )
895  {
896  if(IoFlags & oC_IoFlags_EchoWhenRead)
897  {
898  uint32_t bytesToRead = Size;
899  uint32_t bytesToSend = 1;
900  uint32_t readBytes = 0;
901  uint32_t sentBytes = 0;
902  char backspace = 127;
903 
904  IoFlags &= ~oC_IoFlags_WaitForAllElements;
905  IoFlags |= oC_IoFlags_WaitForSomeElements;
906 
907  errorCode = oC_ErrorCode_None;
908 
909  while(readBytes < Size && !oC_ErrorOccur(errorCode))
910  {
911  if(oC_AssignErrorCode(&errorCode , oC_Stream_Read(stream,&outBuffer[readBytes],&bytesToRead,IoFlags)))
912  {
913  if(oC_Bits_AreBitsSetU32(IoFlags,oC_IoFlags_ReadOneLine) && (outBuffer[readBytes] == '\r'))
914  {
915  const char * newLine = "\n\r";
916  bytesToSend = 2;
917  outBuffer[readBytes] = 0;
918  errorCode = oC_Stream_Write(stream,newLine,&bytesToSend,oC_IoFlags_WaitForAllElements | oC_IoFlags_Default);
919  readBytes--;
920  break;
921  }
922  else if(outBuffer[readBytes] != '\033')
923  {
924  /* Removing characters according to backspaces */
925  while(readBytes >= 0 && outBuffer[readBytes + bytesToRead - 1] == backspace)
926  {
927  outBuffer[readBytes] = 0;
928 
929  if(readBytes > 0)
930  {
931  bytesToSend = 1;
932  errorCode = oC_Stream_Write(stream,&backspace,&bytesToSend,oC_IoFlags_WaitForAllElements | oC_IoFlags_Default);
933  readBytes--;
934  outBuffer[readBytes] = 0;
935  }
936  bytesToRead--;
937  }
938 
939  if(oC_Bits_AreBitsSetU32(IoFlags,oC_IoFlags_EchoAsPassword))
940  {
941  sentBytes = 0;
942 
943  while(sentBytes < bytesToRead && !oC_ErrorOccur(errorCode))
944  {
945  bytesToSend = 1;
946  errorCode = oC_Stream_Write(stream,&passwordChar,&bytesToSend,oC_IoFlags_WaitForAllElements | oC_IoFlags_Default);
947  sentBytes += bytesToSend;
948  }
949  }
950  else if(bytesToRead > 0)
951  {
952  bytesToSend = bytesToRead;
953  errorCode = oC_Stream_Write(stream,&outBuffer[readBytes],&bytesToSend,oC_IoFlags_WaitForAllElements | oC_IoFlags_Default);
954  }
955 
956  readBytes += bytesToRead;
957  bytesToRead = Size - readBytes;
958  }
959 
960  }
961  }
962  }
963  else
964  {
965  errorCode = oC_Stream_Read(stream,outBuffer,&Size,IoFlags);
966  }
967  }
968  }
969 
970  return errorCode;
971 }
972 
973 #undef _________________________________________INTERFACE_SECTION__________________________________________________________________________
974 
980 #define _________________________________________FUNCTIONS_SECTION__________________________________________________________________________
981 
982 //==========================================================================================================================================
983 //==========================================================================================================================================
984 static oC_ErrorCode_t ReadInputStream( oC_Stream_t * outStream )
985 {
986  oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;
987 
988  oC_Process_t currentProcess = oC_ProcessMan_GetCurrentProcess();
989 
990  if(oC_AssignErrorCodeIfFalse(&errorCode , oC_Process_IsCorrect(currentProcess) , oC_ErrorCode_ProcessNotCorrect))
991  {
992  errorCode = oC_ErrorCode_None;
993  *outStream = oC_Process_GetInputStream(currentProcess);
994  }
995 
996  return errorCode;
997 }
998 
999 //==========================================================================================================================================
1000 //==========================================================================================================================================
1001 static oC_ErrorCode_t ReadOutputStream( oC_Stream_t * outStream )
1002 {
1003  oC_ErrorCode_t errorCode = oC_ErrorCode_ImplementError;
1004 
1005  oC_Process_t currentProcess = oC_ProcessMan_GetCurrentProcess();
1006 
1007  if(oC_AssignErrorCodeIfFalse(&errorCode , oC_Process_IsCorrect(currentProcess) , oC_ErrorCode_ProcessNotCorrect))
1008  {
1009  errorCode = oC_ErrorCode_None;
1010  *outStream = oC_Process_GetOutputStream(currentProcess);
1011  }
1012 
1013  return errorCode;
1014 }
1015 
1016 //==========================================================================================================================================
1017 //==========================================================================================================================================
1018 static int SkipAToI(const char ** Format )
1019 {
1020  int index = 0;
1021 
1022  while(IsDigit(**Format))
1023  {
1024  index = index * 10 + *((*Format)++) - '0';
1025  }
1026 
1027  return index;
1028 }
1029 
1030 //==========================================================================================================================================
1031 //==========================================================================================================================================
1032 static bool PutcToBuffer( char ** outBuffer , char * EndPointer , char C )
1033 {
1034  bool sizeOk = false;
1035 
1036  if(*outBuffer < EndPointer)
1037  {
1038  *(*outBuffer) = C;
1039  (*outBuffer)++;
1040  sizeOk = true;
1041  }
1042 
1043  return sizeOk;
1044 }
1045 
1046 //==========================================================================================================================================
1047 //==========================================================================================================================================
1048 static oC_ErrorCode_t PutNumber( char ** outBuffer , char * EndPointer , long Number , int Base , int FieldWidth , int Precision, int Type )
1049 {
1050  oC_ErrorCode_t errorCode = oC_ErrorCode_None;
1051  char emptyChar = ' '; /* Character given before number */
1052  char sign = 0; /* Sign ('-'/'+'/' ') of the number */
1053  char digitBuffer[66];
1054  const char *digitPointer = Digits;
1055  int digitIndex = 0;
1056 
1057 #define _putc(c) if(PutcToBuffer(outBuffer,EndPointer,c)==false){ errorCode = oC_ErrorCode_OutputBufferTooSmall;}
1058 
1059  if(Type & LARGE)
1060  {
1061  digitPointer = UpperDigits;
1062  }
1063 
1064  if(Type & LEFT)
1065  {
1066  Type &= ~ZEROPAD;
1067  }
1068 
1069  if(oC_AssignErrorCodeIfFalse(&errorCode , (Base == 8) || (Base == 10) || (Base == 16) , oC_ErrorCode_DigitBaseNotCorrect))
1070  {
1071  emptyChar = (Type & ZEROPAD) ? '0' : ' ';
1072  sign = 0;
1073 
1074  // ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1075  /* Get a sign */
1076  if (Type & SIGN)
1077  {
1078  if(Number < 0)
1079  {
1080  sign = '-';
1081  Number = -Number;
1082  FieldWidth--;
1083  }
1084  else if(Type & PLUS)
1085  {
1086  sign = '+';
1087  FieldWidth--;
1088  }
1089  else if (Type & SPACE)
1090  {
1091  sign = ' ';
1092  FieldWidth--;
1093  }
1094  }
1095 
1096  // ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1097  /* Decrement field width for '0x' or for '0' in case of Hex/Octal bases */
1098  if (Type & SPECIAL)
1099  {
1100  if( Base == 16 )
1101  {
1102  FieldWidth -= 2;
1103  }
1104  else if( Base == 8 )
1105  {
1106  FieldWidth--;
1107  }
1108  }
1109 
1110  // ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1111  /* Print variable to temporary digit buffer */
1112  if( Number == 0 )
1113  {
1114  digitBuffer[digitIndex++] = '0';
1115  }
1116  else
1117  {
1118  while( Number != 0 )
1119  {
1120  digitBuffer[digitIndex++] = digitPointer[((unsigned long) Number) % (unsigned) Base];
1121  Number = ((unsigned long) Number) / (unsigned) Base;
1122  }
1123  }
1124 
1125  // ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1126  /* Update precision if it was too small */
1127  if( digitIndex > Precision )
1128  {
1129  Precision = digitIndex;
1130  }
1131 
1132  // ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1133  /* Decrement field width for digits */
1134  FieldWidth -= Precision;
1135 
1136  // ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1137  /* If there will be place, insert spaces */
1138  if (!(Type & (ZEROPAD | LEFT)))
1139  {
1140  while(FieldWidth-- > 0)
1141  {
1142  _putc(' ');
1143  }
1144  }
1145 
1146  // ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1147  /* Put sign after spaces */
1148  if(sign)
1149  {
1150  _putc(sign);
1151  }
1152 
1153  // ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1154  /* Put digit base */
1155  if(Type & SPECIAL)
1156  {
1157  if (Base == 8)
1158  {
1159  _putc('0');
1160  }
1161  else if (Base == 16)
1162  {
1163  _putc('0');
1164  _putc('x');
1165  }
1166  }
1167 
1168  // ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1169  /* If should not be padding to the left, insert special char */
1170  if(!(Type & LEFT))
1171  {
1172  while(FieldWidth-- > 0)
1173  {
1174  _putc(emptyChar);
1175  }
1176  }
1177 
1178  // ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1179  /* Insert zeros */
1180  while(digitIndex < Precision--)
1181  {
1182  _putc('0');
1183  }
1184 
1185  // ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1186  /* Insert digits */
1187  while(digitIndex-- > 0)
1188  {
1189  _putc(digitBuffer[digitIndex]);
1190  }
1191 
1192  // ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1193  /* Insert spaces for the end of the string */
1194  while(FieldWidth-- > 0)
1195  {
1196  _putc(' ');
1197  }
1198  }
1199 
1200 #undef _putc
1201  return errorCode;
1202 }
1203 
1204 //==========================================================================================================================================
1205 //==========================================================================================================================================
1206 static oC_ErrorCode_t PutLongFloatInHex( char ** outBuffer , char * EndPointer , unsigned char * Address, int FieldWidth, int Precision, int Type )
1207 {
1208 #define _putc(c) if(PutcToBuffer(outBuffer,EndPointer,c)==false){ errorCode = oC_ErrorCode_OutputBufferTooSmall; }
1209 
1210  oC_ErrorCode_t errorCode = oC_ErrorCode_None;
1211  char digitsBuffer[24];
1212  const char * digits = Digits;
1213  int digitIndex;
1214  int length;
1215 
1216  if( Type & LARGE )
1217  {
1218  digits = UpperDigits;
1219  }
1220 
1221  length = 0;
1222 
1223  for (digitIndex = 0; digitIndex < 6; digitIndex++)
1224  {
1225  if (digitIndex != 0)
1226  {
1227  digitsBuffer[length++] = ':';
1228  }
1229 
1230  digitsBuffer[length++] = digits[Address[digitIndex] >> 4];
1231  digitsBuffer[length++] = digits[Address[digitIndex] & 0x0F];
1232  }
1233 
1234  if (!(Type & LEFT))
1235  {
1236  while (length < FieldWidth--)
1237  {
1238  _putc(' ');
1239  }
1240  }
1241 
1242  for (digitIndex = 0; digitIndex < length; ++digitIndex)
1243  {
1244  _putc(digitsBuffer[digitIndex]);
1245  }
1246 
1247  while(length < FieldWidth--)
1248  {
1249  _putc(' ');
1250  }
1251 
1252  return errorCode;
1253 #undef _putc
1254 }
1255 
1256 //==========================================================================================================================================
1257 //==========================================================================================================================================
1258 static oC_ErrorCode_t PutFloatInHex( char ** outBuffer , char * EndPointer , unsigned char * Address, int FieldWidth, int Precision, int Type )
1259 {
1260 #define _putc(c) if(PutcToBuffer(outBuffer,EndPointer,c)==false){ errorCode = oC_ErrorCode_OutputBufferTooSmall; }
1261  oC_ErrorCode_t errorCode = oC_ErrorCode_None;
1262  char digitsBuffer[24];
1263  int digitIndex;
1264  int n;
1265  int length;
1266 
1267  length = 0;
1268 
1269  for( digitIndex = 0 ; digitIndex < 4 ; digitIndex++ )
1270  {
1271  if( digitIndex != 0 )
1272  {
1273  digitsBuffer[length++] = '.';
1274  }
1275 
1276  n = Address[digitIndex];
1277 
1278  if (n == 0)
1279  {
1280  digitsBuffer[length++] = Digits[0];
1281  }
1282  else
1283  {
1284  if (n >= 100)
1285  {
1286  digitsBuffer[length++] = Digits[n / 100];
1287  n = n % 100;
1288  digitsBuffer[length++] = Digits[n / 10];
1289  n = n % 10;
1290  }
1291  else if (n >= 10)
1292  {
1293  digitsBuffer[length++] = Digits[n / 10];
1294  n = n % 10;
1295  }
1296 
1297  digitsBuffer[length++] = Digits[n];
1298  }
1299  }
1300 
1301  if (!(Type & LEFT))
1302  {
1303  while( length < FieldWidth-- )
1304  {
1305  _putc(' ');
1306  }
1307  }
1308  for( digitIndex = 0 ; digitIndex < length ; ++digitIndex )
1309  {
1310  _putc(digitsBuffer[digitIndex]);
1311  }
1312 
1313  while( length < FieldWidth-- )
1314  {
1315  _putc(' ');
1316  }
1317 
1318  return errorCode;
1319 #undef _putc
1320 }
1321 
1322 //==========================================================================================================================================
1323 //==========================================================================================================================================
1324 static oC_ErrorCode_t PutFloat( char ** outBuffer , char * EndPointer , double Number , int FieldWidth, int Precision, char Format, int Flags )
1325 {
1326 #define _putc(c) if(PutcToBuffer(outBuffer,EndPointer,c)==false){ errorCode = oC_ErrorCode_OutputBufferTooSmall; }
1327  oC_ErrorCode_t errorCode = oC_ErrorCode_None;
1328  char emptyChar = 0;
1329  char sign = 0;
1330  int numberOfIntegerDigits = 1;
1331  int numberOfFractionalDigits = 0;
1332  int numberOfPointChars = 0;
1333  int numberOfSignChars = 0;
1334  int minimumBufferSize = 0;
1335  double integerPart = 0;
1336  double fractionalPart = 0;
1337  char integerDigits[16];
1338 
1339  /* Left align means no zeropadding */
1340  if( Flags & LEFT )
1341  {
1342  Flags &= ~ZEROPAD;
1343  }
1344 
1345  emptyChar = ( Flags & ZEROPAD ) ? '0' : ' ';
1346 
1347  sign = 0;
1348  if( Flags & SIGN )
1349  {
1350  if (Number < 0.0)
1351  {
1352  sign = '-';
1353  Number = -Number;
1354  FieldWidth--;
1355  }
1356  else if (Flags & PLUS)
1357  {
1358  sign = '+';
1359  FieldWidth--;
1360  }
1361  else if (Flags & SPACE)
1362  {
1363  sign = ' ';
1364  FieldWidth--;
1365  }
1366  }
1367 
1368  integerPart = floor(Number);
1369  fractionalPart = Number - integerPart;
1370 
1371  // Compute the precision value
1372  if( Precision < 0 )
1373  {
1374  Precision = 6; // Default precision: 6
1375  }
1376  else if( Precision == 0 && Format == 'g' )
1377  {
1378  Precision = 1; // ANSI specified
1379  }
1380 
1381  if(Precision == 0 && !(Flags & SPECIAL))
1382  {
1383  numberOfPointChars = 0;
1384  }
1385  else
1386  {
1387  numberOfPointChars = 1;
1388  }
1389 
1390  if(sign)
1391  {
1392  numberOfSignChars = 1;
1393  }
1394 
1395  /* Count number of integer part digits */
1396  for(double testNumber = 10 ; testNumber <= Number ; numberOfIntegerDigits++ , testNumber *= 10 );
1397 
1398  numberOfFractionalDigits = Precision;
1399 
1400  minimumBufferSize = numberOfFractionalDigits + numberOfIntegerDigits + numberOfPointChars + numberOfSignChars;
1401 
1402  while( !(Flags & LEFT) && FieldWidth > minimumBufferSize)
1403  {
1404  _putc(emptyChar);
1405  FieldWidth--;
1406  }
1407 
1408  if(sign)
1409  {
1410  _putc(sign);
1411  }
1412 
1413  for(int digitIndex = (numberOfIntegerDigits-1); digitIndex >= 0 ; digitIndex-- )
1414  {
1415  integerDigits[digitIndex] = Digits[((unsigned long) integerPart) % (unsigned) 10];
1416  integerPart /= 10;
1417  }
1418 
1419  for(int digitIndex = 0 ; digitIndex < numberOfIntegerDigits ; digitIndex++ )
1420  {
1421  _putc(integerDigits[digitIndex]);
1422  }
1423 
1424  if(numberOfPointChars)
1425  {
1426  _putc('.');
1427  }
1428 
1429  for(int digitIndex = 0; digitIndex < numberOfFractionalDigits ; digitIndex++ )
1430  {
1431  fractionalPart *= 10;
1432  char digit = Digits[((unsigned long) fractionalPart) % (unsigned) 10];
1433  _putc(digit);
1434  }
1435 
1436  while( (Flags & LEFT) && FieldWidth > minimumBufferSize)
1437  {
1438  _putc(' ');
1439  FieldWidth--;
1440  }
1441 
1442  return errorCode;
1443 #undef _putc
1444 }
1445 
1446 //==========================================================================================================================================
1447 //==========================================================================================================================================
1448 static oC_ErrorCode_t ReadNumber( const char ** Buffer , va_list * ArgumentList , int Base , ScanfFlags_t Flags , int FieldWidth , PointerType_t PointerType )
1449 {
1450  oC_ErrorCode_t errorCode = oC_ErrorCode_None;
1451  uint64_t value = 0;
1452  bool filled = false;
1453  bool negative = false;
1454  int realBase = 0;
1455  const char * buffer = *Buffer;
1456 
1457  //======================================================================================================================================
1458  /*
1459  * Read sign
1460  */
1461  //======================================================================================================================================
1462  if(*buffer == '-')
1463  {
1464  buffer++;
1465  negative = true;
1466  }
1467  else if(*buffer == '+')
1468  {
1469  buffer++;
1470  negative = false;
1471  }
1472 
1473  //======================================================================================================================================
1474  /*
1475  * Read base
1476  */
1477  //======================================================================================================================================
1478  if(*buffer == '0')
1479  {
1480  buffer++;
1481 
1482  if(*buffer == 'x')
1483  {
1484  buffer++;
1485  realBase = 16;
1486  }
1487  else if(*buffer == 'b')
1488  {
1489  buffer++;
1490  realBase = 2;
1491  }
1492  else if(IsDigit((int)buffer[0]))
1493  {
1494  realBase = 8;
1495  }
1496  else
1497  {
1498  /* This is only 0, so we have to decrement the pointer */
1499  buffer--;
1500  realBase = Base;
1501  }
1502  }
1503  else
1504  {
1505  realBase = Base;
1506  }
1507 
1508  //======================================================================================================================================
1509  /*
1510  * Check if base is correct
1511  */
1512  //======================================================================================================================================
1513  if(Base != 0 && realBase != Base)
1514  {
1515  errorCode = oC_ErrorCode_WrongNumberFormat;
1516  }
1517  else
1518  {
1519  //==================================================================================================================================
1520  /*
1521  * Read value
1522  */
1523  //==================================================================================================================================
1524  while(isaddresscorrect(buffer) && (*buffer != 0) && !oC_ErrorOccur(errorCode))
1525  {
1526  switch(realBase)
1527  {
1528  case 2:
1529  if(IsBinary(*buffer))
1530  {
1531  filled = true;
1532  value *= realBase;
1533  value += *buffer - '0';
1534  }
1535  else
1536  {
1537  errorCode = oC_ErrorCode_WrongNumberFormat;
1538  }
1539  break;
1540  case 8:
1541  if(IsOctal(*buffer))
1542  {
1543  filled = true;
1544  value *= realBase;
1545  value += *buffer - '0';
1546  }
1547  else
1548  {
1549  errorCode = oC_ErrorCode_WrongNumberFormat;
1550  }
1551  break;
1552  case 10:
1553  if(IsDigit(*buffer))
1554  {
1555  filled = true;
1556  value *= realBase;
1557  value += *buffer - '0';
1558  }
1559  else
1560  {
1561  errorCode = oC_ErrorCode_WrongNumberFormat;
1562  }
1563  break;
1564  case 16:
1565  if(IsHex(*buffer))
1566  {
1567  filled = true;
1568  value *= realBase;
1569  if(IsDigit(*buffer))
1570  {
1571  value += *buffer - '0';
1572  }
1573  else
1574  {
1575  value += (uint64_t)tolower((int)*buffer) - (uint64_t)('a') + 10;
1576  }
1577  }
1578  else
1579  {
1580  errorCode = oC_ErrorCode_WrongNumberFormat;
1581  }
1582  break;
1583  }
1584  if(!oC_ErrorOccur(errorCode))
1585  {
1586  buffer++;
1587  }
1588  }
1589 
1590  /*
1591  * Value is filled or buffer is not at the start, this means, that value is correct
1592  */
1593  if(filled || buffer > (*Buffer))
1594  {
1595  errorCode = oC_ErrorCode_None;
1596  }
1597  }
1598 
1599  //==================================================================================================================================
1600  /*
1601  * Save value to the pointer
1602  */
1603  //==================================================================================================================================
1604  if(!(Flags & ScanfFlags_Ignored))
1605  {
1606  void * address = va_arg(*ArgumentList, void *);
1607 
1608  if(isram(address) == false)
1609  {
1610  errorCode = oC_ErrorCode_OutputAddressNotInRAM;
1611  }
1612  else if((Flags & ScanfFlags_Unsigned) && negative == true)
1613  {
1614  errorCode = oC_ErrorCode_WrongNumberFormat;
1615  }
1616  else
1617  {
1618 #define SaveValueAsType(Type) *((Type*)address) = (negative) ? (-((Type)value)) : ((Type)value)
1619  if(Flags & ScanfFlags_Signed)
1620  {
1621  switch(PointerType)
1622  {
1623  case PointerType_Int:
1624  SaveValueAsType(int);
1625  break;
1626  case PointerType_SignedChar:
1627  SaveValueAsType(signed char);
1628  break;
1629  case PointerType_ShortInt:
1630  SaveValueAsType(short int);
1631  break;
1632  case PointerType_LongInt:
1633  SaveValueAsType(long int);
1634  break;
1635  case PointerType_LongLongInt:
1636  SaveValueAsType(long long int);
1637  break;
1638  case PointerType_IntMax:
1639  SaveValueAsType(intmax_t);
1640  break;
1641  case PointerType_Size:
1642  SaveValueAsType(size_t);
1643  break;
1644  case PointerType_PtrDiff:
1645  SaveValueAsType(ptrdiff_t);
1646  break;
1647  default:
1648  break;
1649  }
1650  }
1651  else
1652  {
1653  switch(PointerType)
1654  {
1655  case PointerType_Int:
1656  SaveValueAsType(unsigned int);
1657  break;
1658  case PointerType_SignedChar:
1659  SaveValueAsType(unsigned char);
1660  break;
1661  case PointerType_ShortInt:
1662  SaveValueAsType(unsigned short int);
1663  break;
1664  case PointerType_LongInt:
1665  SaveValueAsType(unsigned long int);
1666  break;
1667  case PointerType_LongLongInt:
1668  SaveValueAsType(unsigned long long int);
1669  break;
1670  case PointerType_IntMax:
1671  SaveValueAsType(uintmax_t);
1672  break;
1673  case PointerType_Size:
1674  SaveValueAsType(size_t);
1675  break;
1676  case PointerType_PtrDiff:
1677  SaveValueAsType(ptrdiff_t);
1678  break;
1679  default:
1680  break;
1681  }
1682  }
1683 #undef SaveValueAsType
1684  }
1685  }
1686 
1687  *Buffer = buffer;
1688 
1689  return errorCode;
1690 }
1691 
1692 //==========================================================================================================================================
1693 //==========================================================================================================================================
1694 static oC_ErrorCode_t ReadFloat( const char ** Buffer , va_list * ArgumentList , ScanfFlags_t Flags , int FieldWidth , PointerType_t PointerType )
1695 {
1696  oC_ErrorCode_t errorCode = oC_ErrorCode_None;
1697  long double value = 0;
1698  long double fractional= 0;
1699  int precision = 0;
1700  const char * buffer = *Buffer;
1701  bool negative = false;
1702 
1703  //======================================================================================================================================
1704  /*
1705  * Read sign
1706  */
1707  //======================================================================================================================================
1708  if(*buffer == '-')
1709  {
1710  buffer++;
1711  negative = true;
1712  }
1713  else if(*buffer == '+')
1714  {
1715  buffer++;
1716  negative = false;
1717  }
1718 
1719  //======================================================================================================================================
1720  /*
1721  * Read integer part
1722  */
1723  //======================================================================================================================================
1724  while(isaddresscorrect(buffer) && (*buffer != 0) && !oC_ErrorOccur(errorCode))
1725  {
1726 
1727  if(IsDigit(*buffer))
1728  {
1729  value *= 10;
1730  value += (long double)((*buffer) - '0');
1731  }
1732  else if(*buffer == '.')
1733  {
1734  buffer++;
1735  break;
1736  }
1737  else
1738  {
1739  break;
1740  }
1741 
1742  buffer++;
1743  }
1744 
1745  //======================================================================================================================================
1746  /*
1747  * Read fractional part
1748  */
1749  //======================================================================================================================================
1750  while(isaddresscorrect(buffer) && (*buffer != 0) && !oC_ErrorOccur(errorCode))
1751  {
1752 
1753  if(IsDigit(*buffer))
1754  {
1755  fractional *= 10;
1756  fractional += (long double)((*buffer) - '0');
1757  precision++;
1758  }
1759  else
1760  {
1761  break;
1762  }
1763 
1764  buffer++;
1765  }
1766 
1767  //======================================================================================================================================
1768  /*
1769  * Convert fractional to fractional part
1770  */
1771  //======================================================================================================================================
1772  while(precision > 0)
1773  {
1774  fractional /= 10;
1775  precision--;
1776  }
1777 
1778  //======================================================================================================================================
1779  /*
1780  * Add integer to fractional part
1781  */
1782  //======================================================================================================================================
1783  value += fractional;
1784 
1785  //======================================================================================================================================
1786  /*
1787  * Save value to the pointer
1788  */
1789  //======================================================================================================================================
1790  if(!(Flags & ScanfFlags_Ignored))
1791  {
1792  void * address = va_arg(*ArgumentList, void *);
1793 
1794  if(isram(address) == false)
1795  {
1796  errorCode = oC_ErrorCode_OutputAddressNotInRAM;
1797  }
1798  else
1799  {
1800 #define SaveValueAsType(Type) *((Type*)address) = (negative) ? (-(Type)value):((Type)value)
1801  switch(PointerType)
1802  {
1803  case PointerType_Float:
1804  SaveValueAsType(float);
1805  break;
1806  case PointerType_Double:
1807  SaveValueAsType(double);
1808  break;
1809  case PointerType_LongDouble:
1810  SaveValueAsType(long double);
1811  break;
1812  default:
1813  break;
1814  }
1815 #undef SaveValueAsType
1816  }
1817  }
1818 
1819  *Buffer = buffer;
1820 
1821 
1822  return errorCode;
1823 }
1824 
1825 //==========================================================================================================================================
1826 //==========================================================================================================================================
1827 static oC_ErrorCode_t ReadChar( const char ** Buffer , va_list * ArgumentList , ScanfFlags_t Flags , int FieldWidth )
1828 {
1829  oC_ErrorCode_t errorCode = oC_ErrorCode_None;
1830  const char * buffer = *Buffer;
1831  char * outPointer= NULL;
1832 
1833  //======================================================================================================================================
1834  /*
1835  * Set default values
1836  */
1837  //======================================================================================================================================
1838  if(FieldWidth == 0 )
1839  {
1840  FieldWidth = 1;
1841  }
1842 
1843  //======================================================================================================================================
1844  /*
1845  * Read and check pointer
1846  */
1847  //======================================================================================================================================
1848  if(!(Flags & ScanfFlags_Ignored))
1849  {
1850  outPointer = va_arg(*ArgumentList, char *);
1851  }
1852 
1853  //======================================================================================================================================
1854  /*
1855  * Read characters
1856  */
1857  //======================================================================================================================================
1858  while(isaddresscorrect(buffer) && (*buffer != 0) && !oC_ErrorOccur(errorCode) && (FieldWidth > 0))
1859  {
1860  if(isram(outPointer))
1861  {
1862  *outPointer = *buffer;
1863  outPointer++;
1864  }
1865  else if(outPointer != NULL)
1866  {
1867  errorCode = oC_ErrorCode_OutputAddressNotInRAM;
1868  }
1869  FieldWidth--;
1870  buffer++;
1871  }
1872 
1873  *Buffer = buffer;
1874  return errorCode;
1875 }
1876 
1877 //==========================================================================================================================================
1878 //==========================================================================================================================================
1879 static oC_ErrorCode_t ReadString( const char ** Buffer , va_list * ArgumentList , ScanfFlags_t Flags , int FieldWidth )
1880 {
1881  oC_ErrorCode_t errorCode = oC_ErrorCode_None;
1882  const char * buffer = *Buffer;
1883  char * outPointer= NULL;
1884  bool widthSet = FieldWidth != 0;
1885 
1886  //======================================================================================================================================
1887  /*
1888  * Read pointer
1889  */
1890  //======================================================================================================================================
1891  if(!(Flags & ScanfFlags_Ignored))
1892  {
1893  outPointer = va_arg(*ArgumentList, char *);
1894  }
1895 
1896  //======================================================================================================================================
1897  /*
1898  * Read string
1899  */
1900  //======================================================================================================================================
1901  while(isaddresscorrect(buffer) && (*buffer != 0) && !oC_ErrorOccur(errorCode) && (isspace((int)*buffer) == false))
1902  {
1903  if(isram(outPointer))
1904  {
1905  *outPointer = *buffer;
1906  outPointer++;
1907  }
1908  else if(outPointer != NULL)
1909  {
1910  errorCode = oC_ErrorCode_OutputAddressNotInRAM;
1911  }
1912 
1913  if(widthSet)
1914  {
1915  if(FieldWidth > 0)
1916  {
1917  FieldWidth--;
1918  }
1919  else
1920  {
1921  break;
1922  }
1923  }
1924  buffer++;
1925  }
1926 
1927  *Buffer = buffer;
1928  return errorCode;
1929 }
1930 
1931 //==========================================================================================================================================
1932 //==========================================================================================================================================
1933 static oC_ErrorCode_t ReadPointer( const char ** Buffer , va_list * ArgumentList , ScanfFlags_t Flags )
1934 {
1935  oC_ErrorCode_t errorCode = oC_ErrorCode_None;
1936  const char * buffer = *Buffer;
1937  void ** outPointer= NULL;
1938  oC_UInt_t value = 0;
1939 
1940  //======================================================================================================================================
1941  /*
1942  * Read pointer
1943  */
1944  //======================================================================================================================================
1945  if(!(Flags & ScanfFlags_Ignored))
1946  {
1947  outPointer = va_arg(*ArgumentList, void **);
1948  }
1949 
1950  //======================================================================================================================================
1951  /*
1952  * Read base
1953  */
1954  //======================================================================================================================================
1955  if(*buffer == '0')
1956  {
1957  buffer++;
1958 
1959  if(*buffer == 'x')
1960  {
1961  buffer++;
1962  }
1963  else
1964  {
1965  errorCode = oC_ErrorCode_WrongNumberFormat;
1966  }
1967  }
1968 
1969  //======================================================================================================================================
1970  /*
1971  * Read value
1972  */
1973  //======================================================================================================================================
1974  while(isaddresscorrect(buffer) && (*buffer != 0) && !oC_ErrorOccur(errorCode))
1975  {
1976  if(IsHex(*buffer))
1977  {
1978  value *= 16;
1979  if(IsDigit(*buffer))
1980  {
1981  value += *buffer - '0';
1982  }
1983  else
1984  {
1985  value += (oC_UInt_t)((oC_UInt_t)tolower((int)*buffer) - (oC_UInt_t)('a'));
1986  }
1987  }
1988  else
1989  {
1990  break;
1991  }
1992  buffer++;
1993  }
1994 
1995  if(isram(outPointer))
1996  {
1997  *outPointer = (void*)value;
1998  }
1999  else if(outPointer != NULL)
2000  {
2001  errorCode = oC_ErrorCode_OutputAddressNotInRAM;
2002  }
2003 
2004  *Buffer = buffer;
2005  return errorCode;
2006 }
2007 
2008 //==========================================================================================================================================
2009 //==========================================================================================================================================
2010 static oC_ErrorCode_t ReadScanset( const char ** Buffer , va_list * ArgumentList , ScanfFlags_t Flags , int FieldWidth , const char * ScansetBegin , const char * ScansetEnd , bool ScansetInverted )
2011 {
2012  oC_ErrorCode_t errorCode = oC_ErrorCode_None;
2013  const char * buffer = *Buffer;
2014  char * outPointer= NULL;
2015  bool widthSet = FieldWidth != 0;
2016 
2017  //======================================================================================================================================
2018  /*
2019  * Read pointer
2020  */
2021  //======================================================================================================================================
2022  if(!(Flags & ScanfFlags_Ignored))
2023  {
2024  outPointer = va_arg(*ArgumentList, char *);
2025  }
2026 
2027  //======================================================================================================================================
2028  /*
2029  * Read string
2030  */
2031  //======================================================================================================================================
2032  while(isaddresscorrect(buffer) && (*buffer != 0) && !oC_ErrorOccur(errorCode))
2033  {
2034  bool signIsInScanset = false;
2035  /* Searching if this character is one of ScansetBuffer buffer */
2036  for(const char * scanset = ScansetBegin ; scanset < ScansetEnd ; scanset++)
2037  {
2038  if(*scanset == *buffer)
2039  {
2040  signIsInScanset = true;
2041  break;
2042  }
2043  }
2044 
2045  /* Check if we are looking for characters or not */
2046  if(signIsInScanset == ScansetInverted)
2047  {
2048  break;
2049  }
2050 
2051  if(isram(outPointer))
2052  {
2053  *outPointer = *buffer;
2054  outPointer++;
2055  }
2056  else if(outPointer != NULL)
2057  {
2058  errorCode = oC_ErrorCode_OutputAddressNotInRAM;
2059  }
2060 
2061  if(widthSet)
2062  {
2063  if(FieldWidth > 0)
2064  {
2065  FieldWidth--;
2066  }
2067  else
2068  {
2069  break;
2070  }
2071  }
2072  buffer++;
2073  }
2074 
2075  *Buffer = buffer;
2076 
2077  return errorCode;
2078 }
2079 
2080 #undef _________________________________________FUNCTIONS_SECTION__________________________________________________________________________
2081 
2082 
oC_Bits_AreBitsSetU32
static bool oC_Bits_AreBitsSetU32(uint32_t BitMask, uint32_t BitsToCheck)
checks if all bits in field are set
Definition: oc_bits.h:884
ModuleEnabledFlag
static bool ModuleEnabledFlag
Definition: oc_memman.c:211
oc_processman.h
The file with interface for process manager.
Process_t
Definition: oc_process.c:54
oc_streamman.h
The file with interface for stream manager.
oc_kprint.h
The file with interface for kernel print operations.
Stream_t
Definition: oc_stream.c:38
oC_KPrint_Format
oC_ErrorCode_t oC_KPrint_Format(char *outBuffer, oC_UInt_t Size, const char *Format, va_list ArgumentList)
Definition: oc_kprint.c:196
NULL
#define NULL
pointer to a zero
Definition: oc_null.h:37