Subversion Repositories Kolibri OS

Rev

Rev 647 | Go to most recent revision | Show entire file | Regard whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 647 Rev 6412
Line 412... Line 412...
412
                                        case 'U':
412
                                        case 'U':
413
                                        format_flag=1;
413
                                        format_flag=1;
414
                                        flag_unsigned=1;
414
                                        flag_unsigned=1;
415
                                        break;
415
                                        break;
416
                                        case 'x':
416
                                        case 'x':
-
 
417
                                        case 'p':
417
                                        format_flag=1;
418
                                        format_flag=1;
418
                                        break;
419
                                        break;
419
                                        case 'X':
420
                                        case 'X':
-
 
421
                                        case 'P':
420
                                        flag_register=1;
422
                                        flag_register=1;
421
                                        format_flag=1;
423
                                        format_flag=1;
422
                                        break;
424
                                        break;
423
                                        case 'z':
425
                                        case 'z':
424
                                        case 'Z':
426
                                        case 'Z':
Line 449... Line 451...
449
                                        fmt=fmtc+1;
451
                                        fmt=fmtc+1;
450
                                        switch(*fmtc)
452
                                        switch(*fmtc)
451
                                        {
453
                                        {
452
                                                case 'c':
454
                                                case 'c':
453
                                                case 'C':
455
                                                case 'C':
454
                                                if ((pos+1)
456
                                                if ((pos+1)<=maxlen)
455
                                                {
457
                                                {
456
                                                        //*s=(int)va_arg(argp,char*);
458
                                                        //*s=(int)va_arg(argp,char*);
457
                                                        *s=*((char *)argp);
459
                                                        *s=*((char *)argp);
458
                                                        argp=argp+4;
460
                                                        argp=argp+4;
459
                                                        *s++;pos++;
461
                                                        *s++;pos++;
Line 461... Line 463...
461
                                                break;
463
                                                break;
462
                                                case 's':
464
                                                case 's':
463
                                                case 'S':
465
                                                case 'S':
464
                                                str=va_arg(argp,char*);
466
                                                    str=va_arg(argp,char*);
465
                                                length=strlen(str);
467
                                                    length=strlen(str);
466
                                                if ((pos+length)
468
                                                    if (pos + length > maxlen)
467
                                                {
469
                                                        length = maxlen - pos;
468
                                                        memcpy(s,str,length);
470
                                                    memcpy(s,str,length);
469
                                                        s=s+length;pos=pos+length;
471
                                                    s=s+length;pos=pos+length;
470
                                                }
-
 
471
                                                break;
472
                                                    break;
472
                                                case 'd':
473
                                                case 'd':
473
                                                case 'D':
474
                                                case 'D':
474
                                                case 'i':
475
                                                case 'i':
475
                                                case 'I':
476
                                                case 'I':
476
                                                if (flag_long==0) {intdigit=va_arg(argp,int);}
477
                                                    if (flag_long==0) {intdigit=va_arg(argp,int);}
477
                                                if (flag_long==1) {intdigit=va_arg(argp,long);}
478
                                                    if (flag_long==1) {intdigit=va_arg(argp,long);}
478
                                                if (flag_long==2) {intdigit=va_arg(argp,long long);}
479
                                                    if (flag_long==2) {intdigit=va_arg(argp,long long);}
479
						//intdigit=*((long*)argp);
480
                                                    //intdigit=*((long*)argp);
480
                                                //argp=argp+4;
481
                                                    //argp=argp+4;
481
                                                if ((intdigit>0) && (flag_plus==1) && (pos+1
482
                                                    if ((intdigit>0) && (flag_plus==1) && (pos+1<=maxlen))
482
                                                {
483
                                                    {
483
                                                        *s='+';
484
                                                            *s='+';
484
                                                        s++;
485
                                                            s++;
485
                                                        pos++;
486
                                                            pos++;
486
                                                }
487
                                                    }
487
                                                length=formatted_long_to_string(intdigit,0,buf);
488
                                                    length=formatted_long_to_string(intdigit,0,buf);
488
                                                if ((pos+length)
489
                                                    if (pos + length > maxlen)
489
                                                {
490
                                                        length = maxlen - pos;
490
                                                        memcpy(s,buf,length);
491
                                                    memcpy(s,buf,length);
491
                                                        s=s+length;pos=pos+length;
492
                                                    s=s+length;pos=pos+length;
492
                                                }
-
 
493
						break;
493
                                                    break;
494
                                                case 'o':
494
                                                case 'o':
495
                                                if (flag_long==0) {intdigit=va_arg(argp,int);}
495
                                                    if (flag_long==0) {intdigit=va_arg(argp,int);}
496
                                                if (flag_long==1) {intdigit=va_arg(argp,long);}
496
                                                    if (flag_long==1) {intdigit=va_arg(argp,long);}
497
                                                if (flag_long==2) {intdigit=va_arg(argp,long long);}
497
                                                    if (flag_long==2) {intdigit=va_arg(argp,long long);}
498
                                                //intdigit=*((long int *)argp);
498
                                                    //intdigit=*((long int *)argp);
499
                                                //argp=argp+4;
499
                                                    //argp=argp+4;
Line 500... Line 500...
500
 
500
 
501
                                                length=formatted_octa_to_string(intdigit,0,flag_register,buf);
501
                                                    length=formatted_octa_to_string(intdigit,0,flag_register,buf);
502
                                                if ((pos+length)
502
                                                    if (pos + length > maxlen)
503
                                                {
503
                                                        length = maxlen - pos;
504
                                                        memcpy(s,buf,length);
504
                                                    memcpy(s,buf,length);
505
                                                        s=s+length;pos=pos+length;
-
 
506
                                                }
505
                                                    s=s+length;pos=pos+length;
507
                                                break;
506
                                                    break;
508
                                                case 'u':
507
                                                case 'u':
509
                                                case 'U':
508
                                                case 'U':
510
                                                if (flag_long==0) {intdigit=va_arg(argp,int);}
509
                                                    if (flag_long==0) {intdigit=va_arg(argp,int);}
Line 514... Line 513...
514
                                                if (flag_unsigned==1) {
513
                                                    if (flag_unsigned==1) {
515
                                                        if (intdigit<0) {intdigit=-intdigit;}
514
                                                            if (intdigit<0) {intdigit=-intdigit;}
516
                                                }
515
                                                    }
Line 517... Line 516...
517
 
516
 
518
                                                length=formatted_long_to_string(intdigit,0,buf);
517
                                                    length=formatted_long_to_string(intdigit,0,buf);
519
                                                if ((pos+length)
518
                                                    if (pos + length > maxlen)
520
                                                {
519
                                                        length = maxlen - pos;
521
                                                        memcpy(s,buf,length);
520
                                                    memcpy(s,buf,length);
522
                                                        s=s+length;pos=pos+length;
-
 
523
                                                }
521
                                                    s=s+length;pos=pos+length;
-
 
522
                                                    break;
-
 
523
                                                case 'p':
524
                                                break;
524
                                                case 'P':
525
                                                case 'x':
525
                                                case 'x':
526
                                                case 'X':
526
                                                case 'X':
527
                                                if (flag_long==0) {intdigit=va_arg(argp,int);}
527
                                                    if (flag_long==0) {intdigit=va_arg(argp,int);}
528
                                                if (flag_long==1) {intdigit=va_arg(argp,long);}
528
                                                    if (flag_long==1) {intdigit=va_arg(argp,long);}
529
                                                if (flag_long==2) {intdigit=va_arg(argp,long long);}
529
                                                    if (flag_long==2) {intdigit=va_arg(argp,long long);}
530
                                                //intdigit=*((long int *)argp);
530
                                                    //intdigit=*((long int *)argp);
Line 531... Line 531...
531
                                                //argp=argp+4;
531
                                                    //argp=argp+4;
532
 
532
 
533
                                                length=formatted_hex_to_string(intdigit,0,flag_register,buf);
533
                                                    length=formatted_hex_to_string(intdigit,0,flag_register,buf);
534
                                                if ((pos+length)
534
                                                    if (pos + length > maxlen)
535
                                                {
535
                                                        length = maxlen - pos;
536
                                                        memcpy(s,buf,length);
-
 
537
                                                        s=s+length;pos=pos+length;
536
                                                    memcpy(s,buf,length);
538
                                                }
537
                                                    s=s+length;pos=pos+length;
539
                                                break;
538
                                                    break;
540
                                                case 'z':
539
                                                case 'z':
Line 541... Line 540...
541
                                                case 'Z':
540
                                                case 'Z':
542
                                                intdigit=va_arg(argp,size_t);
541
                                                    intdigit=va_arg(argp,size_t);
543
 
542
 
Line 544... Line 543...
544
                                                if (flag_unsigned==1) {
543
                                                    if (flag_unsigned==1) {
545
                                                        if (intdigit<0) {intdigit=-intdigit;}
544
                                                            if (intdigit<0) {intdigit=-intdigit;}
546
                                                }
545
                                                    }
547
 
546
 
548
                                                length=formatted_long_to_string(intdigit,0,buf);
547
                                                    length=formatted_long_to_string(intdigit,0,buf);
549
                                                if ((pos+length)
-
 
550
                                                {
548
                                                    if (pos + length > maxlen)
551
                                                        memcpy(s,buf,length);
549
                                                        length = maxlen - pos;
Line 552... Line 550...
552
                                                        s=s+length;pos=pos+length;
550
                                                    memcpy(s,buf,length);
553
                                                }
551
                                                    s=s+length;pos=pos+length;
Line 715... Line 713...
715
                                }
713
                                }
716
                        }
714
                        }
717
                }
715
                }
718
                else
716
                else
719
                {
717
                {
720
                        if (*fmt=='\0') {break;}
718
                        if (!(*s++ = *fmt++)) break;
721
                        *s=*fmt;
-
 
722
                        fmt++;
-
 
723
                        s++;
-
 
724
                        pos++;
719
                        pos++;
725
                }
720
                }
726
                exit_check:;
721
                exit_check:;
727
        }
722
        }
728
        return(pos);
723
        return(pos);