Skip to content

Commit ac03348

Browse files
tenbahttenbaht
committed
Print now accepts a function pointer to the write function to be used
1 parent 89150ad commit ac03348

4 files changed

Lines changed: 76 additions & 163 deletions

File tree

‎.gitignore‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1,4 +1,5 @@
11
*~
2+
*.bak
23
.*.swp
34
*.o
45
*.bin

‎sduino/hardware/sduino/stm8/cores/sduino/HardwareSerial.h‎

Lines changed: 22 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -65,3 +65,25 @@ int HardwareSerial_write(uint8_t c);
6565
void HardwareSerial_flush(void);
6666

6767
void HardwareSerial_end(void);
68+
69+
70+
// variants of the standard Serial.print() function: Separate impementations
71+
// for string, char, unsigned, signed int
72+
#define Serial_print_s(S) printStr(HardwareSerial_write,S)
73+
#define Serial_print_c(C) printChr(HardwareSerial_write,C)
74+
75+
// print signed/unsigned integer values (char, short, int, long) as decimal values
76+
#define Serial_print_i(I) Print_print_i(HardwareSerial_write,I)
77+
#define Serial_print_u(U) Print_print_u(HardwareSerial_write,U)
78+
79+
// print signed/unsigned integer values (char, short, int, long) to base B
80+
#define Serial_print_ib(I,B) printInt(HardwareSerial_write,I,B)
81+
#define Serial_print_ub(U,B) printNumber(HardwareSerial_write,U,B)
82+
83+
84+
#define Serial_println_s(S) Print_println_s(HardwareSerial_write,S)
85+
#define Serial_println_u(U) Print_println_u(HardwareSerial_write,U)
86+
#define Serial_println_i(I) Print_println_i(HardwareSerial_write,I)
87+
88+
// float (not implemented yet)
89+
#define Serial_print_f(F,D) Print_printFloat(HardwareSerial_write,F,D)

‎sduino/hardware/sduino/stm8/cores/sduino/Print.c‎

Lines changed: 32 additions & 145 deletions
Original file line numberDiff line numberDiff line change
@@ -44,194 +44,81 @@ void printNL(void);
4444

4545
// Public Methods //////////////////////////////////////////////////////////////
4646

47-
size_t printBuf(const uint8_t *buffer, size_t size)
47+
size_t printBuf(writefunc_p writefunc, const uint8_t *buffer, size_t size)
4848
{
4949
size_t n = 0;
5050
while (size--) {
51-
if (printChr(*buffer++)) n++;
51+
if (writefunc(*buffer++)) n++;
5252
else break;
5353
}
5454
return n;
5555
}
5656

57-
size_t printStr(const char *str)
57+
size_t printStr(writefunc_p writefunc, const char *str)
5858
{
5959
size_t n = 0;
6060
char c;
6161

6262
if (!str) return 0;
6363

6464
while ( c=*str++ ) { // assignment intented
65-
if (printChr(c)) n++;
65+
if (writefunc(c)) n++;
6666
else break;
6767
}
6868
return n;
6969
}
7070

7171

72-
size_t Print_print_u(unsigned long n)
72+
size_t Print_print_u(writefunc_p writefunc, unsigned long n)
7373
{
74-
return printNumber(n,10);
74+
return printNumber(writefunc, n,10);
7575
}
7676

77-
size_t Print_print_i(long n)
77+
size_t Print_print_i(writefunc_p writefunc, long n)
7878
{
79-
return printInt(n,10);
79+
return printInt(writefunc, n,10);
8080
}
8181

82-
size_t Print_println_s(char *str)
82+
size_t Print_println_s(writefunc_p writefunc, char *str)
8383
{
8484
size_t r;
8585

86-
r = printStr(str);
87-
return r + println();
86+
r = printStr(writefunc, str);
87+
return r + println(writefunc);
8888
}
8989

9090

9191

92-
size_t Print_println_u(unsigned long n)
92+
size_t Print_println_u(writefunc_p writefunc, unsigned long n)
9393
{
9494
size_t r;
9595

96-
r = printNumber(n,10);
97-
return r + println();
96+
r = printNumber(writefunc, n,10);
97+
return r + println(writefunc);
9898
}
9999

100-
size_t Print_println_i(long n)
100+
size_t Print_println_i(writefunc_p writefunc, long n)
101101
{
102102
size_t r;
103103

104-
r = printInt(n,10);
105-
return r + println();
104+
r = printInt(writefunc, n,10);
105+
return r + println(writefunc);
106106
}
107107

108108

109-
/*
110-
size_t Print::print(long n, int base)
111-
{
112-
if (base == 0) {
113-
return write(n);
114-
} else if (base == 10) {
115-
if (n < 0) {
116-
int t = print('-');
117-
n = -n;
118-
return printNumber(n, 10) + t;
119-
}
120-
return printNumber(n, 10);
121-
} else {
122-
return printNumber(n, base);
123-
}
124-
}
125-
126-
size_t Print::print(unsigned long n, int base)
127-
{
128-
if (base == 0) return write(n);
129-
else return printNumber(n, base);
130-
}
131-
132-
size_t Print::print(double n, int digits)
133-
{
134-
return printFloat(n, digits);
135-
}
136-
137-
size_t Print::println(const __FlashStringHelper *ifsh)
138-
{
139-
size_t n = print(ifsh);
140-
n += println();
141-
return n;
142-
}
143-
144-
size_t Print::print(const Printable& x)
145-
{
146-
return x.printTo(*this);
147-
}
148-
149-
size_t Print::println(void)
150-
{
151-
return write("\r\n");
152-
}
153-
154-
size_t Print::println(const String &s)
155-
{
156-
size_t n = print(s);
157-
n += println();
158-
return n;
159-
}
160-
161-
size_t Print::println(const char c[])
162-
{
163-
size_t n = print(c);
164-
n += println();
165-
return n;
166-
}
167-
168-
size_t Print::println(char c)
169-
{
170-
size_t n = print(c);
171-
n += println();
172-
return n;
173-
}
174-
175-
size_t Print::println(unsigned char b, int base)
176-
{
177-
size_t n = print(b, base);
178-
n += println();
179-
return n;
180-
}
181-
182-
size_t Print::println(int num, int base)
183-
{
184-
size_t n = print(num, base);
185-
n += println();
186-
return n;
187-
}
188-
189-
size_t Print::println(unsigned int num, int base)
190-
{
191-
size_t n = print(num, base);
192-
n += println();
193-
return n;
194-
}
195-
196-
size_t Print::println(long num, int base)
197-
{
198-
size_t n = print(num, base);
199-
n += println();
200-
return n;
201-
}
202-
203-
size_t Print::println(unsigned long num, int base)
204-
{
205-
size_t n = print(num, base);
206-
n += println();
207-
return n;
208-
}
209-
210-
size_t Print::println(double num, int digits)
211-
{
212-
size_t n = print(num, digits);
213-
n += println();
214-
return n;
215-
}
216-
217-
size_t Print::println(const Printable& x)
218-
{
219-
size_t n = print(x);
220-
n += println();
221-
return n;
222-
}
223-
*/
224109
// Private Methods /////////////////////////////////////////////////////////////
225110

226-
size_t println(void)
111+
size_t println(writefunc_p writefunc)
227112
{
228-
printChr(13);
229-
printChr(10);
230-
return 2;
113+
size_t n;
114+
115+
n = writefunc(13);
116+
n += writefunc(10);
117+
return n;
231118
}
232119

233120

234-
size_t printNumber(unsigned long n, uint8_t base)
121+
size_t printNumber(writefunc_p writefunc, unsigned long n, uint8_t base)
235122
{
236123
char buf[8 * sizeof(long) + 1]; // Assumes 8-bit chars plus zero byte.
237124
char *str = &buf[sizeof(buf) - 1];
@@ -248,27 +135,27 @@ size_t printNumber(unsigned long n, uint8_t base)
248135
*--str = c < 10 ? c + '0' : c + 'A' - 10;
249136
} while(n);
250137

251-
return printStr(str);
138+
return printStr(writefunc, str);
252139
}
253140

254-
size_t printInt(long n, uint8_t base)
141+
size_t printInt(writefunc_p writefunc, long n, uint8_t base)
255142
{
256143
if (base == 0) {
257-
return printChr((unsigned char) n);
144+
return writefunc((unsigned char) n);
258145
} else if (base == 10) {
259146
if (n < 0) {
260-
int t = printChr('-');
147+
int t = writefunc('-');
261148
n = -n;
262-
return printNumber(n, 10) + t;
149+
return printNumber(writefunc, n, 10) + t;
263150
}
264-
return printNumber(n, 10);
151+
return printNumber(writefunc, n, 10);
265152
} else {
266-
return printNumber(n, base);
153+
return printNumber(writefunc, n, base);
267154
}
268155
}
269156

270157
/*
271-
size_t Print_printFloat(double number, uint8_t digits)
158+
size_t Print_printFloat(writefunc_p writefunc, double number, uint8_t digits)
272159
{
273160
size_t n = 0;
274161
uint8_t i;

‎sduino/hardware/sduino/stm8/cores/sduino/Print.h‎

Lines changed: 21 additions & 18 deletions
Original file line numberDiff line numberDiff line change
@@ -33,38 +33,41 @@
3333
#define BIN 2
3434

3535

36+
// for the function pointer to the actual write function
37+
typedef size_t (*writefunc_p)(char c);
38+
3639
// this function is used for the actual output:
37-
int HardwareSerial_write(uint8_t c); // FIXME: this prototype should not be here
38-
#define printChr(C) HardwareSerial_write(C)
40+
//int HardwareSerial_write(uint8_t c); // FIXME: this prototype should not be here
41+
//#define printChr(C) HardwareSerial_write(C)
3942

4043
// the actual used functions, mostly for internal use
41-
size_t printBuf(const uint8_t *buffer, size_t size);
42-
size_t printStr(const char *str);
43-
size_t printNumber(unsigned long n, uint8_t base);
44-
size_t printInt(long n, uint8_t base);
45-
size_t println(void);
44+
size_t printBuf(writefunc_p writefunc, const uint8_t *buffer, size_t size);
45+
size_t printStr(writefunc_p writefunc, const char *str);
46+
size_t printNumber(writefunc_p writefunc, unsigned long n, uint8_t base);
47+
size_t printInt(writefunc_p writefunc, long n, uint8_t base);
48+
size_t println(writefunc_p writefunc);
4649

4750
// the more sophisticated Arduino-Style functions:
4851

49-
#define Print_write(B,N) printBuf(B,N)
52+
//#define Print_write(B,N) printBuf(B,N)
5053

5154
// variants of the standard Serial.print() function: Separate impementations
5255
// for string, char, unsigned, signed int
53-
#define Print_print_s(S) printStr(S)
54-
#define Print_print_c(C) printChr(C)
56+
//#define Print_print_s(S) printStr(S)
57+
//#define Print_print_c(C) printChr(C)
5558
// print unsigned integer values (char, short, int, long) as decimal values
56-
size_t Print_print_u(unsigned long n);
59+
size_t Print_print_u(writefunc_p writefunc, unsigned long n);
5760
// print signed integer values (char, short, int, long) as decimal value
58-
size_t Print_print_i(long n);
61+
size_t Print_print_i(writefunc_p writefunc, long n);
5962
// print unsigned integer values (char, short, int, long) to base B
60-
#define Print_print_ub(U,B) printNumber(U,B)
63+
//#define Print_print_ub(U,B) printNumber(U,B)
6164
// print signed integer values (char, short, int, long) to base B
62-
#define Print_print_ib(I,B) printInt(I,B)
65+
//#define Print_print_ib(I,B) printInt(I,B)
6366

64-
size_t Print_println_s(char *str);
65-
size_t Print_println_u(unsigned long n);
66-
size_t Print_println_i(long n);
67+
size_t Print_println_s(writefunc_p writefunc, char *str);
68+
size_t Print_println_u(writefunc_p writefunc, unsigned long n);
69+
size_t Print_println_i(writefunc_p writefunc, long n);
6770

68-
size_t Print_printFloat(double number, uint8_t digits);
71+
size_t Print_printFloat(writefunc_p writefunc, double number, uint8_t digits);
6972

7073
#endif

0 commit comments

Comments
 (0)