-
Notifications
You must be signed in to change notification settings - Fork 0
/
Copy pathformat.hpp
1333 lines (1164 loc) · 33.8 KB
/
format.hpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
#pragma once
//=============================================================================//
/*! @file
@brief utils::format クラス @n
・C++17 以降のコンパイラが必須 @n
・安全性を考慮した、[s]printf 表示に準じたクラス @n
・二進表記として、「%b」をサポート @n
・固定小数点表示「%N.M:Ly」形式をサポート @n
※ N：全桁数、M：小数部桁数、L：小数部のビット数 @n
※ N には、小数点、符号が含まれる @n
Ex: %3.2:8y ---> 256 で 1.00、128 で 0.50、384 で 1.50 @n
と表示される。 @n
・NO_FLOAT_FORM を有効にすると、float 関係の機能を無効にでき @n
メモリを節約出来る。 @n
+ 2017/06/11 20:00- 標準文字出力クラスの再定義、実装 @n
+ 2017/06/11 21:00- 固定文字列クラス向け chaout、実装 @n
+ 2017/06/12 14:50- memory_chaoutと、専用コンストラクター実装 @n
+ 2017/06/14 05:34- memory_chaout size() のバグ修正 @n
+ 2018/11/20 05:10- float を無効にするオプションを復活 @n
+ 2019/05/04 14:44- %c を指定した場合、整数を全て受け付け、範囲を検査 @n
+ 2019/05/04 15:33- %g、%G 末尾の桁に '0' がある場合除去する。 @n
+ 2019/12/02 10:50- write 関数の代わりに putchar へ切り替えるオプションを追加 @n
! 2019/12/03 20:00- %nd の場合に、表示が重複する不具合修正。 @n
+ 2019/12/03 21:54- インクルードファイルの修追加。 @n
+ 2019/12/09 03:21- memory_chaout で出力先が設定されていない場合の安全性確保。 @n
! 2019/12/14 11:44- 符号の表示不具合修正。 @n
+ 2020/01/02 11:05- ポインター表示機能「%p」追加。 @n
+ 2020/02/02 15:43- enum error など共有定義の継承。 @n
! 2019/02/02 19:42- 符号文字カウントの不具合修正。 @n
+ 2020/02/04 05:23- std::string 型追加。 @n
+ 2020/04/25 07:45- stdout_buffered_chaout に、操作位置を返すメソッド pos() を追加。 @n
! 2020/11/20 07:44- sformat 時の nega_ フラグの初期化漏れ @n
! 2020/11/20 07:44- nega_ 符号表示の順番、不具合 @n
! 2020/11/20 16:59- uint 型を削除 @n
! 2022/06/13 15:03- 'static const' を 'static constexpr' に変更 @n
! 2022/07/06 09:24- %6.0f の符号付きの場合に、スペースが足りなくなるバグ修正。(V95) @n
! 2022/07/07 20:52- %g の自動（有効桁６桁）フォーマットの対応。(v96) @n
! 2022/07/11 14:08- nan の識別と表示、及びテストの対応。(V97) @n
! 2022/07/13 14:45- %Ng の自動（Ｎの有効桁がある場合）フォーマットの対応。(V98) @n
! 2022/07/14 13:31- 内部処理で、’if’ 文 から 'switch' へ変更（速度改善？、見やすさに貢献）(V99) @n
! 2022/07/24 17:48- V99 で変更した処理の不具合、'%%' の処理 (V100) @n
! 2022/08/05 06:51- 出力ファンクタに対するフラッシュ要求 API (V101) @n
! 2023/03/03 22:44- ポインター値の１６進表示を大文字にする。 @n
! 2024/08/20 10:00- %0s の挙動を 'printf' に合わせる @n
! 2024/09/01 22:00- %q など、仕様外の文字に対する挙動 @n
+ 2024/12/27 13:35- (v120) 64 bits 整数の変換をサポート（２進、８進、１０進、１６進）
+ 2025/01/02 13:17- (v121) cleanup
@author 平松邦仁 ([email protected])
@copyright Copyright (C) 2013, 2024 Kunihito Hiramatsu @n
Released under the MIT license @n
https://github.com/hirakuni45/RX/blob/master/LICENSE
*/
//=============================================================================//
#include <type_traits>
#include <unistd.h>
#include <cstdint>
#include <cstring>
#include <string>
// 最終的な出力として putchar を使う場合有効にする（通常は write [stdout] 関数）
// #define USE_PUTCHAR
// float を無効にする場合（８ビット系マイコンでのメモリ節約用）
// #define NO_FLOAT_FORM
// ２進表示をサポートしない場合（メモリの節約）
// #define NO_BIN_FORM
// ８進表示をサポートしない場合（メモリの節約）
// #define NO_OCTAL_FORM
/*
e, E
double 引き数を丸めて [-]d.ddde±dd の形に変換する。 小数点の前には一桁の数字があり、
小数点以下の桁数は精度で指定された桁数 になる。精度は指定されなかった場合 6 とみなされる。
精度が 0 の場合には、 小数点以下は表示されない。E 変換では、指数を表現するときに
(e で はなく) E が使われる。指数部分は少なくとも 2桁表示される。つまり、 指数の値が 0
の場合には、00 と表示される。
f, F
double 引き数を丸めて [-]ddd.ddd の形の10進表現に変換する。 小数点の後の桁数は、精度で
指定された値となる。 精度が指定されていない場合には 6 として扱われる。 精度として明示的
に 0 が指定されたときには、小数点以下は表示されない。 小数点を表示する際には、小数点の
前に少なくとも一桁は数字が表示される。
(SUSv2 では、F は規定されておらず、無限や NaN に関する文字列表現を 行ってもよいことになっている。
C99 標準では、f 変換では、無限は "[-]inf" か "[-]infinity" と表示し、 NaN は文字列の先頭
に `nan をつけて表示するように規定されている。 F 変換の場合は
"[-]INF", "[-]INFINITY", "NAN*" と表示される。)
g, G
double 引き数を f か e (G 変換の場合は F か E) の形式に変換する。 精度は表示する桁数を
指定する。 精度が指定されない場合は、6桁とみなされる。 精度が 0 の場合は、1桁とみなされる。
変換される値の指数が、 -4 より小さいか、精度以上の場合に、 e 形式が使用される。
変換された結果の小数部分の末尾の 0 は削除される。小数点が表示されるのは、 小数点以下に
数字が少なくとも一つある場合にだけである。
*/
namespace utils {
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++//
/*!
@brief 無効出力ファンクタ @n
※全ての動作を無効にして、機能を取り除く。 @n
※最適化をしない場合、全てを取り除く事は出来ない。
*/
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++//
struct null_chaout {
typedef unsigned int uint; // 通常 8/16 ビットマイコンでは 16 ビットサイズ
void operator() (char ch) noexcept { }
void clear() noexcept { };
uint size() const noexcept { return 0; }
};
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++//
/*!
@brief サイズ出力ファンクタ @n
※出力サイズを調査する場合などに使う。
*/
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++//
struct size_chaout {
typedef unsigned int uint; // 通常 8/16 ビットマイコンでは 16 ビットサイズ
private:
uint size_;
public:
//-----------------------------------------------------------------//
/*!
@brief コンストラクター
*/
//-----------------------------------------------------------------//
size_chaout() noexcept : size_(0) { }
void operator() (char ch) noexcept {
++size_;
}
void clear() noexcept { size_ = 0; };
uint size() const noexcept { return size_; }
};
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++//
/*!
@brief 標準出力ファンクタ
*/
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++//
struct stdout_chaout {
typedef unsigned int uint; // 通常 8/16 ビットマイコンでは 16 ビットサイズ
private:
uint size_;
public:
//-----------------------------------------------------------------//
/*!
@brief コンストラクター
*/
//-----------------------------------------------------------------//
stdout_chaout() noexcept : size_(0) { }
void operator() (char ch) noexcept
{
#ifdef USE_PUTCHAR
putchar(ch);
#else
char tmp = ch;
write(STDOUT_FILENO, &tmp, 1);
#endif
++size_;
}
void clear() noexcept { size_ = 0; };
uint size() const noexcept { return size_; }
};
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++//
/*!
@brief 標準出力バッファリングファンクタ
@param[in] BFN バッファサイズ
*/
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++//
template <uint32_t BFN>
struct stdout_buffered_chaout {
typedef unsigned int uint; // 通常 8/16 ビットマイコンでは 16 ビットサイズ
private:
char buff_[BFN];
uint pos_;
uint size_;
public:
//-----------------------------------------------------------------//
/*!
@brief コンストラクター
*/
//-----------------------------------------------------------------//
stdout_buffered_chaout() noexcept : pos_(0), size_(0) { }
void operator() (char ch) noexcept {
buff_[pos_] = ch;
++pos_;
if(ch == '\n' || pos_ >= BFN) {
flush();
}
++size_;
}
void clear() noexcept { size_ = 0; };
auto size() const noexcept { return size_; }
auto pos() const noexcept { return pos_; }
void flush() noexcept
{
if(pos_ == 0) return;
#ifdef USE_PUTCHAR
for(uint i = 0; i < pos_; ++i) {
putchar(buff_[i]);
}
#else
write(STDOUT_FILENO, buff_, pos_);
#endif
pos_ = 0;
}
};
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++//
/*!
@brief 標準出力ターミネーター・ファンクタ
*/
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++//
struct stdout_term {
typedef unsigned int uint; // 通常 8/16 ビットマイコンでは 16 ビットサイズ
void operator() (const char* s, uint l) noexcept {
#ifdef USE_PUTCHAR
for(uint i = 0; i < l; ++i) {
putchar(s[i]);
}
#else
write(STDOUT_FILENO, s, l);
#endif
}
};
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++//
/*!
@brief 標準出力、無効ターミネーター・ファンクタ
*/
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++//
struct null_term {
typedef unsigned int uint; // 通常 8/16 ビットマイコンでは 16 ビットサイズ
void operator() (const char* s, uint l) { }
};
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++//
/*!
@brief 文字列クラス、出力ファンクタ
@param[in] STR 文字列クラス
@param[in] TERM ターミネーター・ファンクタ
*/
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++//
template <class STR, class TERM>
class string_chaout {
STR str_;
TERM term_;
public:
//-----------------------------------------------------------------//
/*!
@brief コンストラクター
*/
//-----------------------------------------------------------------//
string_chaout() noexcept : str_(), term_() { }
void clear() noexcept {
if(str_.size() > 0) {
term_(str_.c_str(), str_.size());
}
str_.clear();
}
auto size() const noexcept { return str_.size(); }
void flush() noexcept {
if(str_.size() > 0) {
term_(str_.c_str(), str_.size());
str_.clear();
}
}
STR& at_str() noexcept { return str_; }
TERM& at_term() noexcept { return term_; }
//-----------------------------------------------------------------//
/*!
@brief ファンクタ用オペレータ
@param[in] ch 出力文字
*/
//-----------------------------------------------------------------//
void operator () (char ch) noexcept {
str_ += ch;
if(str_.size() >= str_.capacity()) {
term_(str_.c_str(), str_.size());
str_.clear();
}
}
};
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++//
/*!
@brief メモリー出力文字列クラス
*/
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++//
struct memory_chaout {
typedef unsigned int uint; // 通常 8/16 ビットマイコンでは 16 ビットサイズ
private:
char* dst_;
uint limit_;
uint pos_;
public:
//-----------------------------------------------------------------//
/*!
@brief コンストラクター
*/
//-----------------------------------------------------------------//
memory_chaout() noexcept : dst_(nullptr), limit_(0), pos_(0) { }
bool set(char* dst, uint limit) noexcept
{
if(dst == nullptr || limit <= 1) {
return false;
}
limit--;
// ポインター、サイズ、どちらか異なる場合は常にリセット
if(dst_ != dst || limit_ != limit) {
pos_ = 0;
}
dst_ = dst;
limit_ = limit;
return true;
}
//-----------------------------------------------------------------//
/*!
@brief ファンクタ用オペレータ
@param[in] ch 出力文字
*/
//-----------------------------------------------------------------//
void operator () (char ch) noexcept {
if(pos_ < limit_) {
dst_[pos_] = ch;
++pos_;
dst_[pos_] = 0;
}
}
void clear() noexcept { pos_ = 0; }
auto size() const noexcept { return pos_; }
};
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++//
/*!
@brief format 基本クラス定義
*/
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++//
struct base_format {
static constexpr uint16_t VERSION = 121; ///< バージョン番号（整数）
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++//
/*!
@brief エラー種別
*/
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++//
enum class error : uint8_t {
none, ///< エラー無し
null, ///< 無効なポインター
unknown, ///< 不明な「型」
different, ///< 異なる「型」
over, ///< 数値の領域外（%c で char が扱える数値以外）
out_null, ///< 文字出力先が無効
out_overflow, ///< 文字出力先がオーバーフローした場合
};
};
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++//
/*!
@brief 簡易 format クラス
@param[in] CHAOUT 文字出力ファンクタ
*/
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++//
template <class CHAOUT>
class basic_format : public base_format {
enum class mode : uint8_t {
CHA, ///< 文字
STR, ///< 文字列
BINARY, ///< ２進
OCTAL, ///< ８進
DECIMAL, ///< １０進
U_DECIMAL, ///< １０進（符号無し）
HEX_CAPS, ///< １６進（大文字）
HEX, ///< １６進（小文字）
POINTER, ///< ポインター（１６進）
FIXED_REAL, ///< 固定小数点
REAL, ///< 浮動小数点
EXPONENT_CAPS, ///< 浮動小数点 exp 形式(E)
EXPONENT, ///< 浮動小数点 exp 形式(e)
REAL_AUTO_CAPS, ///< 浮動小数点自動(G)
REAL_AUTO, ///< 浮動小数点自動(g)
NONE ///< 不明
};
static CHAOUT chaout_;
const char* form_;
char buff_[64 + 2]; // uint64_t 型で二進表示に必要な大きさ
uint16_t num_;
uint8_t point_;
uint8_t bitlen_;
uint8_t udec_num_;
error error_;
mode mode_;
bool zerosupp_;
bool sign_;
bool nega_;
bool set_num_;
bool set_poi_;
bool auto_mode_;
bool exp_mode_;
void str_(const char* str) noexcept {
char ch;
while((ch = *str++) != 0) chaout_(ch);
}
void reset_() noexcept {
num_ = 0;
point_ = 0;
bitlen_ = 0;
udec_num_ = 0;
mode_ = mode::NONE;
zerosupp_ = false;
sign_ = false;
nega_ = false;
set_num_ = false;
set_poi_ = false;
auto_mode_ = false;
exp_mode_ = false;
}
void next_() noexcept {
enum class apmd : uint8_t {
none,
num, // 数字
point, // 小数点
bitlen // 固定小数点、ビット長さ
};
if(form_ == nullptr) {
error_ = error::null;
return;
}
auto md = apmd::none;
char ch;
while((ch = *form_++) != 0) {
if(md != apmd::none) {
switch(ch) {
case '+':
sign_ = true;
break;
case '-':
nega_ = true;
break;
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
ch -= '0';
if(md == apmd::num) {
if(num_ == 0 && ch == 0) {
zerosupp_ = true;
}
num_ *= 10;
num_ += static_cast<uint8_t>(ch);
set_num_ = true;
} else if(md == apmd::point) {
point_ *= 10;
point_ += static_cast<uint8_t>(ch);
set_poi_ = true;
} else if(md == apmd::bitlen) {
bitlen_ *= 10;
bitlen_ += static_cast<uint8_t>(ch);
}
break;
case '.':
md = apmd::point;
break;
case ':':
md = apmd::bitlen;
break;
case 's':
mode_ = mode::STR;
return;
case 'c':
mode_ = mode::CHA;
return;
#ifndef NO_BIN_FORM
case 'b':
mode_ = mode::BINARY;
return;
#endif
#ifndef NO_OCTAL_FORM
case 'o':
mode_ = mode::OCTAL;
return;
#endif
case 'd':
case 'i':
mode_ = mode::DECIMAL;
return;
case 'u':
mode_ = mode::U_DECIMAL;
return;
case 'x':
mode_ = mode::HEX;
return;
case 'X':
mode_ = mode::HEX_CAPS;
return;
case 'y':
mode_ = mode::FIXED_REAL;
return;
case 'f':
case 'F':
mode_ = mode::REAL;
return;
case 'e':
mode_ = mode::EXPONENT;
return;
case 'E':
mode_ = mode::EXPONENT_CAPS;
return;
case 'g':
mode_ = mode::REAL_AUTO;
return;
case 'G':
mode_ = mode::REAL_AUTO_CAPS;
return;
case 'p':
mode_ = mode::POINTER;
return;
case '%':
chaout_(ch);
md = apmd::none;
break;
default:
chaout_(ch);
md = apmd::none;
error_ = error::unknown;
break;
}
} else if(ch == '%') {
md = apmd::num;
} else {
chaout_(ch);
}
}
}
void out_str_(const char* str, char sign, uint16_t n) noexcept {
if(nega_) {
if(sign != 0) { chaout_(sign); }
str_(str);
}
auto num = num_;
if(sign != 0 && num > 0) { num--; }
if(n > 0 && n < num) {
auto spc = num - n;
if(zerosupp_) {
if(sign != 0) { chaout_(sign); }
while(spc) {
--spc;
chaout_('0');
}
} else {
auto spc = num - n;
while(spc) {
--spc;
chaout_(' ');
}
if(!nega_ && sign != 0) { chaout_(sign); }
}
} else {
if(!nega_ && sign != 0) { chaout_(sign); }
}
if(!nega_) { str_(str); }
}
#ifndef NO_BIN_FORM
template <typename T>
void out_bin_(T v) noexcept {
char* p = &buff_[sizeof(buff_) - 1];
*p = 0;
uint8_t n = 0;
do {
--p;
*p = (v & 1) + '0';
v >>= 1;
++n;
} while(v != 0) ;
out_str_(p, 0, n);
}
#endif
#ifndef NO_OCTAL_FORM
template <typename T>
void out_oct_(T v) noexcept {
char* p = &buff_[sizeof(buff_) - 1];
*p = 0;
uint8_t n = 0;
do {
--p;
*p = (v & 0b111) + '0';
v >>= 3;
++n;
} while(v != 0) ;
out_str_(p, 0, n);
}
#endif
template <typename T>
char* build_udec_(T v) noexcept {
char* p = &buff_[sizeof(buff_) - 1];
*p = 0;
udec_num_ = 0;
do {
--p;
*p = (v % 10) + '0';
v /= 10;
++udec_num_;
} while(v != 0) ;
return p;
}
template <typename T>
void out_dec_(T v) noexcept {
char sign = 0;
if(v < 0) { v = -v; sign = '-'; }
else if(sign_) { sign = '+'; }
char* tmp;
tmp = build_udec_<typename std::make_unsigned<T>::type>(v);
out_str_(tmp, sign, udec_num_);
}
template <typename T>
void out_hex_(T v, char top) noexcept {
char* p = &buff_[sizeof(buff_) - 1];
*p = 0;
uint8_t n = 0;
do {
--p;
char ch = v & 15;
if(ch >= 10) ch += top - 10;
else ch += '0';
*p = ch;
v >>= 4;
++n;
} while(v != 0) ;
out_str_(p, 0, n);
}
template <typename T>
void decimal_(T val, bool sign) noexcept {
switch(mode_) {
#ifndef NO_BIN_FORM
case mode::BINARY:
out_bin_<typename std::make_unsigned<T>::type>(val);
break;
#endif
#ifndef NO_OCTAL_FORM
case mode::OCTAL:
out_oct_<typename std::make_unsigned<T>::type>(val);
break;
#endif
case mode::DECIMAL:
out_dec_<typename std::make_signed<T>::type>(val);
break;
case mode::U_DECIMAL:
{
auto tmp = build_udec_<typename std::make_unsigned<T>::type>(val);
out_str_(tmp, sign_ ? '+' : 0, udec_num_);
}
break;
case mode::HEX:
case mode::HEX_CAPS:
{
char ch = 'a';
if(mode_ == mode::HEX_CAPS) ch = 'A';
out_hex_<typename std::make_unsigned<T>::type>(val, ch);
}
break;
case mode::FIXED_REAL:
if(num_ == 0) num_ = 6;
if(val < 0) {
sign = true;
val = -val;
}
out_fixed_point_<uint64_t>(val, bitlen_, sign);
break;
default:
error_ = error::different;
break;
}
}
static uint64_t build_mask_(uint8_t num) noexcept {
uint64_t m = 0;
while(num > 0) {
m += m;
++m;
--num;
}
return m;
}
template <typename VAL>
void out_fixed_point_(VAL v, uint8_t fixpoi, bool sign) noexcept
{
// 四捨五入処理用 0.5
VAL m = 0;
if(fixpoi < (sizeof(VAL) * 8 - 4)) {
m = static_cast<VAL>(5) << fixpoi;
auto n = point_ + 1;
while(n > 0) {
m /= 10;
--n;
}
}
char sch = 0;
if(sign) sch = '-';
else if(sign_) sch = '+';
v += m;
if(!auto_mode_) {
if(num_ >= point_) num_ -= point_;
if(num_ > 0 && point_ != 0) {
--num_;
}
}
char* rnb_org;
if(fixpoi < (sizeof(VAL) * 8 - 4)) {
rnb_org = build_udec_(v >> fixpoi);
} else {
rnb_org = build_udec_(0);
}
if(mode_ == mode::REAL_AUTO || mode_ == mode::REAL_AUTO_CAPS) {
// 指定が無い場合６桁を維持
if(udec_num_ < 6) {
point_ = 6 - udec_num_;
} else {
point_ = 0;
}
if(!set_num_) {
num_ = udec_num_;
}
}
if(point_ > 0) { // 小数点以下の構築
char* out = buff_;
*out++ = '.';
uint16_t l = 0;
if(fixpoi < (sizeof(VAL) * 8 - 4)) {
VAL dec = v & build_mask_(fixpoi);
while(dec > 0) {
dec *= 10;
VAL n = dec >> fixpoi;
*out++ = n + '0';
dec -= n << fixpoi;
++l;
if(l >= point_) break;
}
}
if(auto_mode_) { // 後ろの「０」を除去
while(out > &buff_[1]) {
if(*(out - 1) == '0') --out;
else break;
}
if(out == &buff_[1]) --out; // '.'
} else {
while(l < point_) {
*out++ = '0';
++l;
}
}
*out = 0;
if(auto_mode_) { // AUTO モード
if(set_num_) {
uint32_t unp = out - &buff_[0]; // 小数点以下の数（小数点を含む）
uint32_t all = unp + udec_num_;
if(exp_mode_) all += 4;
if(sch != 0) ++all;
if(num_ > all) {
num_ -= all; // 空白の数
num_ += udec_num_;
if(sch != 0) ++num_;
} else {
num_ = udec_num_;
}
if(unp == 0 && udec_num_ == 6) {
}
} else {
num_ = udec_num_;
}
}
}
out_str_(rnb_org, sch, udec_num_);
if(point_ > 0) {
str_(buff_);
}
}
#ifndef NO_FLOAT_FORM
void out_real_(float v, char e) noexcept
{
void* p = &v;
uint32_t fpv = *(uint32_t*)p;
bool sign = fpv >> 31;
int16_t exp = (fpv >> 22) & 0x1ff;
if(exp >= 0x1fe) { // inf, nan の検出
if(sign) chaout_('-');
if(exp & 1) {
out_str_("nan", 0, 3);
} else {
out_str_("inf", 0, 3);
}
return;
}
exp >>= 1;
exp -= 127; // bias (-127)
int32_t val = fpv & 0x7fffff; // 23 bits
int16_t shift = 23;
if(val == 0 && exp == -127) { // [0.0]
} else {
val |= 0x800000; // add offset 1.0
}
shift -= exp;
// 64 ビットに拡張
uint64_t v64 = static_cast<uint64_t>(val);
if(shift < 28) {
shift += 32;
v64 <<= 32;
}
// エキスポーネント表記の場合に乗数を求める。
int8_t decexp = 0;
if(e != 0) {
auto ref = static_cast<uint64_t>(1) << shift;
if(v64 < ref) { // 1.0 以下
ref -= ref / 10; // 0.99999 の場合を考慮する為、誤差分を引く
while(v64 < ref) {
v64 *= 10;
--decexp;
}
} else {
auto ref = static_cast<uint64_t>(2) << shift;
while(v64 >= ref) { // 1.9999... 以上の場合
v64 /= 10;
++decexp;
}
}
}
out_fixed_point_<uint64_t>(v64, shift, sign);
if(e != 0) {
chaout_(e);
zerosupp_ = true;
sign_ = true;
num_ = 3;
out_dec_(decexp);
}
}
static float abs_(float val) noexcept { if(val < 0.0f) return -val; else return val; }
static float pow10_(int n) noexcept
{
switch(n) {
case 4: return 1e4f;
case 5: return 1e5f;
case 6: return 1e6f;
case 7: return 1e7f;
case 8: return 1e8f;
case 9: return 1e9f;
case -4: return 1e-3f;
case -5: return 1e-5f;
case -6: return 1e-6f;
case -7: return 1e-7f;
case -8: return 1e-8f;
case -9: return 1e-9f;
default:
break;
}
float v = 1.0f;
if(n > 0) {
while(n > 0) { v *= 10.0f; --n; }
} else {
while(n < 0) { v /= 10.0f; ++n; }
}
return v;
}
void out_auto_real_(float v, char e) noexcept
{
if(abs_(v) >= pow10_(6)) {
exp_mode_ = true;
out_real_(v, e);
} else if(abs_(v) < pow10_(-(6 - 2))) {
exp_mode_ = true;
out_real_(v, e);
} else {
if(abs_(v) < 1.0f) { // 小数点以下の場合
// 小数点以下の有効桁を表示する為の全体の桁数を求める。
int n = point_;
if(n > 6) n = 6;
for(int i = 1; i < 9; ++i) {
if(abs_(v) >= pow10_(-i)) {
point_ = i + n - 1;
break;
}
}
if(!set_num_) {
num_ = point_ + 1;
}
mode_ = mode::REAL;