← Back to branch summary

~ubuntu-branches/debian/experimental/arduino/experimental

« back to all changes in this revision

Viewing changes to hardware/arduino/cores/arduino/Print.cpp

  • Committer: Package Import Robot
  • Author(s): Scott Howard
  • Date: 2012-03-11 18:19:42 UTC
  • mfrom: (1.1.5) (5.1.14 sid)
  • Revision ID: package-import@ubuntu.com-20120311181942-be2clnbz1gcehixb
Tags: 1:1.0.1~rc1+dfsg-1
New upstream release, experimental.

Show diffs side-by-side

added added

removed removed

Lines of Context:
hardware/arduino/cores/arduino/Print.cpp
30
30
// Public Methods //////////////////////////////////////////////////////////////
31
31
 
32
32
/* default implementation: may be overridden */
33
 
void Print::write(const char *str)
34
 
{
35
 
  while (*str)
36
 
    write(*str++);
37
 
}
38
 
 
39
 
/* default implementation: may be overridden */
40
 
void Print::write(const uint8_t *buffer, size_t size)
41
 
{
42
 
  while (size--)
43
 
    write(*buffer++);
44
 
}
45
 
 
46
 
void Print::print(const __FlashStringHelper *ifsh)
47
 
{
48
 
  const prog_char *p = (const prog_char *)ifsh;
 
33
size_t Print::write(const uint8_t *buffer, size_t size)
 
34
{
 
35
  size_t n = 0;
 
36
  while (size--) {
 
37
    n += write(*buffer++);
 
38
  }
 
39
  return n;
 
40
}
 
41
 
 
42
size_t Print::print(const __FlashStringHelper *ifsh)
 
43
{
 
44
  const char PROGMEM *p = (const char PROGMEM *)ifsh;
 
45
  size_t n = 0;
49
46
  while (1) {
50
47
    unsigned char c = pgm_read_byte(p++);
51
 
    if (c == 0) return;
52
 
    write(c);
53
 
  }
54
 
}
55
 
 
56
 
void Print::print(const String &s)
57
 
{
58
 
  for (int i = 0; i < s.length(); i++) {
59
 
    write(s[i]);
60
 
  }
61
 
}
62
 
 
63
 
void Print::print(const char str[])
64
 
{
65
 
  write(str);
66
 
}
67
 
 
68
 
void Print::print(char c)
69
 
{
70
 
  write(c);
71
 
}
72
 
 
73
 
void Print::print(unsigned char b, int base)
74
 
{
75
 
  print((unsigned long) b, base);
76
 
}
77
 
 
78
 
void Print::print(int n, int base)
79
 
{
80
 
  print((long) n, base);
81
 
}
82
 
 
83
 
void Print::print(unsigned int n, int base)
84
 
{
85
 
  print((unsigned long) n, base);
86
 
}
87
 
 
88
 
void Print::print(long n, int base)
 
48
    if (c == 0) break;
 
49
    n += write(c);
 
50
  }
 
51
  return n;
 
52
}
 
53
 
 
54
size_t Print::print(const String &s)
 
55
{
 
56
  size_t n = 0;
 
57
  for (uint16_t i = 0; i < s.length(); i++) {
 
58
    n += write(s[i]);
 
59
  }
 
60
  return n;
 
61
}
 
62
 
 
63
size_t Print::print(const char str[])
 
64
{
 
65
  return write(str);
 
66
}
 
67
 
 
68
size_t Print::print(char c)
 
69
{
 
70
  return write(c);
 
71
}
 
72
 
 
73
size_t Print::print(unsigned char b, int base)
 
74
{
 
75
  return print((unsigned long) b, base);
 
76
}
 
77
 
 
78
size_t Print::print(int n, int base)
 
79
{
 
80
  return print((long) n, base);
 
81
}
 
82
 
 
83
size_t Print::print(unsigned int n, int base)
 
84
{
 
85
  return print((unsigned long) n, base);
 
86
}
 
87
 
 
88
size_t Print::print(long n, int base)
89
89
{
90
90
  if (base == 0) {
91
 
    write(n);
 
91
    return write(n);
92
92
  } else if (base == 10) {
93
93
    if (n < 0) {
94
 
      print('-');
 
94
      int t = print('-');
95
95
      n = -n;
 
96
      return printNumber(n, 10) + t;
96
97
    }
97
 
    printNumber(n, 10);
 
98
    return printNumber(n, 10);
98
99
  } else {
99
 
    printNumber(n, base);
 
100
    return printNumber(n, base);
100
101
  }
101
102
}
102
103
 
103
 
void Print::print(unsigned long n, int base)
104
 
{
105
 
  if (base == 0) write(n);
106
 
  else printNumber(n, base);
107
 
}
108
 
 
109
 
void Print::print(double n, int digits)
110
 
{
111
 
  printFloat(n, digits);
112
 
}
113
 
 
114
 
void Print::println(const __FlashStringHelper *ifsh)
115
 
{
116
 
  print(ifsh);
117
 
  println();
118
 
}
119
 
 
120
 
void Print::println(void)
121
 
{
122
 
  print('\r');
123
 
  print('\n');
124
 
}
125
 
 
126
 
void Print::println(const String &s)
127
 
{
128
 
  print(s);
129
 
  println();
130
 
}
131
 
 
132
 
void Print::println(const char c[])
133
 
{
134
 
  print(c);
135
 
  println();
136
 
}
137
 
 
138
 
void Print::println(char c)
139
 
{
140
 
  print(c);
141
 
  println();
142
 
}
143
 
 
144
 
void Print::println(unsigned char b, int base)
145
 
{
146
 
  print(b, base);
147
 
  println();
148
 
}
149
 
 
150
 
void Print::println(int n, int base)
151
 
{
152
 
  print(n, base);
153
 
  println();
154
 
}
155
 
 
156
 
void Print::println(unsigned int n, int base)
157
 
{
158
 
  print(n, base);
159
 
  println();
160
 
}
161
 
 
162
 
void Print::println(long n, int base)
163
 
{
164
 
  print(n, base);
165
 
  println();
166
 
}
167
 
 
168
 
void Print::println(unsigned long n, int base)
169
 
{
170
 
  print(n, base);
171
 
  println();
172
 
}
173
 
 
174
 
void Print::println(double n, int digits)
175
 
{
176
 
  print(n, digits);
177
 
  println();
 
104
size_t Print::print(unsigned long n, int base)
 
105
{
 
106
  if (base == 0) return write(n);
 
107
  else return printNumber(n, base);
 
108
}
 
109
 
 
110
size_t Print::print(double n, int digits)
 
111
{
 
112
  return printFloat(n, digits);
 
113
}
 
114
 
 
115
size_t Print::println(const __FlashStringHelper *ifsh)
 
116
{
 
117
  size_t n = print(ifsh);
 
118
  n += println();
 
119
  return n;
 
120
}
 
121
 
 
122
size_t Print::print(const Printable& x)
 
123
{
 
124
  return x.printTo(*this);
 
125
}
 
126
 
 
127
size_t Print::println(void)
 
128
{
 
129
  size_t n = print('\r');
 
130
  n += print('\n');
 
131
  return n;
 
132
}
 
133
 
 
134
size_t Print::println(const String &s)
 
135
{
 
136
  size_t n = print(s);
 
137
  n += println();
 
138
  return n;
 
139
}
 
140
 
 
141
size_t Print::println(const char c[])
 
142
{
 
143
  size_t n = print(c);
 
144
  n += println();
 
145
  return n;
 
146
}
 
147
 
 
148
size_t Print::println(char c)
 
149
{
 
150
  size_t n = print(c);
 
151
  n += println();
 
152
  return n;
 
153
}
 
154
 
 
155
size_t Print::println(unsigned char b, int base)
 
156
{
 
157
  size_t n = print(b, base);
 
158
  n += println();
 
159
  return n;
 
160
}
 
161
 
 
162
size_t Print::println(int num, int base)
 
163
{
 
164
  size_t n = print(num, base);
 
165
  n += println();
 
166
  return n;
 
167
}
 
168
 
 
169
size_t Print::println(unsigned int num, int base)
 
170
{
 
171
  size_t n = print(num, base);
 
172
  n += println();
 
173
  return n;
 
174
}
 
175
 
 
176
size_t Print::println(long num, int base)
 
177
{
 
178
  size_t n = print(num, base);
 
179
  n += println();
 
180
  return n;
 
181
}
 
182
 
 
183
size_t Print::println(unsigned long num, int base)
 
184
{
 
185
  size_t n = print(num, base);
 
186
  n += println();
 
187
  return n;
 
188
}
 
189
 
 
190
size_t Print::println(double num, int digits)
 
191
{
 
192
  size_t n = print(num, digits);
 
193
  n += println();
 
194
  return n;
 
195
}
 
196
 
 
197
size_t Print::println(const Printable& x)
 
198
{
 
199
  size_t n = print(x);
 
200
  n += println();
 
201
  return n;
178
202
}
179
203
 
180
204
// Private Methods /////////////////////////////////////////////////////////////
181
205
 
182
 
void Print::printNumber(unsigned long n, uint8_t base) {
 
206
size_t Print::printNumber(unsigned long n, uint8_t base) {
183
207
  char buf[8 * sizeof(long) + 1]; // Assumes 8-bit chars plus zero byte.
184
208
  char *str = &buf[sizeof(buf) - 1];
185
209
 
195
219
    *--str = c < 10 ? c + '0' : c + 'A' - 10;
196
220
  } while(n);
197
221
 
198
 
  write(str);
 
222
  return write(str);
199
223
}
200
224
 
201
 
void Print::printFloat(double number, uint8_t digits) 
 
225
size_t Print::printFloat(double number, uint8_t digits) 
202
226
{ 
 
227
  size_t n = 0;
 
228
  
203
229
  // Handle negative numbers
204
230
  if (number < 0.0)
205
231
  {
206
 
     print('-');
 
232
     n += print('-');
207
233
     number = -number;
208
234
  }
209
235
 
217
243
  // Extract the integer part of the number and print it
218
244
  unsigned long int_part = (unsigned long)number;
219
245
  double remainder = number - (double)int_part;
220
 
  print(int_part);
 
246
  n += print(int_part);
221
247
 
222
248
  // Print the decimal point, but only if there are digits beyond
223
 
  if (digits > 0)
224
 
    print("."); 
 
249
  if (digits > 0) {
 
250
    n += print("."); 
 
251
  }
225
252
 
226
253
  // Extract digits from the remainder one at a time
227
254
  while (digits-- > 0)
228
255
  {
229
256
    remainder *= 10.0;
230
257
    int toPrint = int(remainder);
231
 
    print(toPrint);
 
258
    n += print(toPrint);
232
259
    remainder -= toPrint; 
233
260
  } 
 
261
  
 
262
  return n;
234
263
}