Advertisement
Guest User

Untitled

a guest
Dec 27th, 2016
124
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 7.48 KB | None | 0 0
  1. william@beaglebone:~/dev$ diff msp430-print.cpp cc3200-print.cpp > output.txt
  2.  
  3. 4c4
  4. <
  5. ---
  6. >
  7. 9c9
  8. <
  9. ---
  10. >
  11. 14c14
  12. <
  13. ---
  14. >
  15. 18c18
  16. <
  17. ---
  18. >
  19. 44,48c44,48
  20. < size_t n = 0;
  21. < for (uint16_t i = 0; i < s.length(); i++) {
  22. < n += write(s[i]);
  23. < }
  24. < return n;
  25. ---
  26. > size_t n = 0;
  27. > for (uint16_t i = 0; i < s.length(); i++) {
  28. > n += write(s[i]);
  29. > }
  30. > return n;
  31. 53c53
  32. < return write(str);
  33. ---
  34. > return write(str);
  35. 58c58
  36. < return write(c);
  37. ---
  38. > return write(c);
  39. 63c63
  40. < return print((unsigned long) b, base);
  41. ---
  42. > return print((unsigned long) b, base);
  43. 68c68
  44. < return print((long) n, base);
  45. ---
  46. > return print((long) n, base);
  47. 73c73
  48. < return print((unsigned long) n, base);
  49. ---
  50. > return print((unsigned long) n, base);
  51. 78,89c78,89
  52. < if (base == 0) {
  53. < return write(n);
  54. < } else if (base == 10) {
  55. < if (n < 0) {
  56. < int t = print('-');
  57. < n = -n;
  58. < return printNumber(n, 10) + t;
  59. < }
  60. < return printNumber(n, 10);
  61. < } else {
  62. < return printNumber(n, base);
  63. < }
  64. ---
  65. > if (base == 0) {
  66. > return write(n);
  67. > } else if (base == 10) {
  68. > if (n < 0) {
  69. > int t = print('-');
  70. > n = -n;
  71. > return printNumber(n, 10) + t;
  72. > }
  73. > return printNumber(n, 10);
  74. > } else {
  75. > return printNumber(n, base);
  76. > }
  77. 94,95c94,95
  78. < if (base == 0) return write(n);
  79. < else return printNumber(n, base);
  80. ---
  81. > if (base == 0) return write(n);
  82. > else return printNumber(n, base);
  83. 100c100,105
  84. < return printFloat(n, digits);
  85. ---
  86. > return printFloat(n, digits);
  87. > }
  88. >
  89. > size_t Print::print(float n, int digits)
  90. > {
  91. > return printFloat(n, digits);
  92. 112c117
  93. < return x.printTo(*this);
  94. ---
  95. > return x.printTo(*this);
  96. 117,119c122,124
  97. < size_t n = print('\r');
  98. < n += print('\n');
  99. < return n;
  100. ---
  101. > size_t n = print('\r');
  102. > n += print('\n');
  103. > return n;
  104. 124,126c129,131
  105. < size_t n = print(s);
  106. < n += println();
  107. < return n;
  108. ---
  109. > size_t n = print(s);
  110. > n += println();
  111. > return n;
  112. 131,133c136,138
  113. < size_t n = print(c);
  114. < n += println();
  115. < return n;
  116. ---
  117. > size_t n = print(c);
  118. > n += println();
  119. > return n;
  120. 138,140c143,145
  121. < size_t n = print(c);
  122. < n += println();
  123. < return n;
  124. ---
  125. > size_t n = print(c);
  126. > n += println();
  127. > return n;
  128. 145,147c150,152
  129. < size_t n = print(b, base);
  130. < n += println();
  131. < return n;
  132. ---
  133. > size_t n = print(b, base);
  134. > n += println();
  135. > return n;
  136. 152,154c157,159
  137. < size_t n = print(num, base);
  138. < n += println();
  139. < return n;
  140. ---
  141. > size_t n = print(num, base);
  142. > n += println();
  143. > return n;
  144. 159,161c164,166
  145. < size_t n = print(num, base);
  146. < n += println();
  147. < return n;
  148. ---
  149. > size_t n = print(num, base);
  150. > n += println();
  151. > return n;
  152. 166,168c171,173
  153. < size_t n = print(num, base);
  154. < n += println();
  155. < return n;
  156. ---
  157. > size_t n = print(num, base);
  158. > n += println();
  159. > return n;
  160. 173,175c178,180
  161. < size_t n = print(num, base);
  162. < n += println();
  163. < return n;
  164. ---
  165. > size_t n = print(num, base);
  166. > n += println();
  167. > return n;
  168. 180,182c185,194
  169. < size_t n = print(num, digits);
  170. < n += println();
  171. < return n;
  172. ---
  173. > size_t n = print(num, digits);
  174. > n += println();
  175. > return n;
  176. > }
  177. >
  178. > size_t Print::println(float num, int digits)
  179. > {
  180. > size_t n = print(num, digits);
  181. > n += println();
  182. > return n;
  183. 187,189c199,201
  184. < size_t n = print(x);
  185. < n += println();
  186. < return n;
  187. ---
  188. > size_t n = print(x);
  189. > n += println();
  190. > return n;
  191. 195,196c207,208
  192. < char buf[8 * sizeof(long) + 1]; // Assumes 8-bit chars plus zero byte.
  193. < char *str = &buf[sizeof(buf) - 1];
  194. ---
  195. > char buf[8 * sizeof(long) + 1]; // Assumes 8-bit chars plus zero byte.
  196. > char *str = &buf[sizeof(buf) - 1];
  197. 198c210
  198. < *str = '\0';
  199. ---
  200. > *str = '\0';
  201. 200,201c212,213
  202. < // prevent crash if called with base == 1
  203. < if (base < 2) base = 10;
  204. ---
  205. > // prevent crash if called with base == 1
  206. > if (base < 2) base = 10;
  207. 203,208c215,220
  208. < do {
  209. < unsigned long m = n;
  210. < n /= base;
  211. < char c = m - base * n;
  212. < *--str = c < 10 ? c + '0' : c + 'A' - 10;
  213. < } while(n);
  214. ---
  215. > do {
  216. > unsigned long m = n;
  217. > n /= base;
  218. > char c = m - base * n;
  219. > *--str = c < 10 ? c + '0' : c + 'A' - 10;
  220. > } while(n);
  221. 210c222
  222. < return write(str);
  223. ---
  224. > return write(str);
  225. 215,222c227
  226. < size_t n = 0;
  227. <
  228. < // Handle negative numbers
  229. < if (number < 0.0)
  230. < {
  231. < n += print('-');
  232. < number = -number;
  233. < }
  234. ---
  235. > size_t n = 0;
  236. 224,239c229,234
  237. < // Round correctly so that print(1.999, 2) prints as "2.00"
  238. < double rounding = 0.5;
  239. < for (uint8_t i=0; i<digits; ++i)
  240. < rounding /= 10.0;
  241. <
  242. < number += rounding;
  243. <
  244. < // Extract the integer part of the number and print it
  245. < unsigned long int_part = (unsigned long)number;
  246. < double remainder = number - (double)int_part;
  247. < n += print(int_part);
  248. <
  249. < // Print the decimal point, but only if there are digits beyond
  250. < if (digits > 0) {
  251. < n += print(".");
  252. < }
  253. ---
  254. > // Handle negative numbers
  255. > if (number < 0.0)
  256. > {
  257. > n += print('-');
  258. > number = -number;
  259. > }
  260. 241,250c236,302
  261. < // Extract digits from the remainder one at a time
  262. < while (digits-- > 0)
  263. < {
  264. < remainder *= 10.0;
  265. < int toPrint = int(remainder);
  266. < n += print(toPrint);
  267. < remainder -= toPrint;
  268. < }
  269. <
  270. < return n;
  271. ---
  272. > // Round correctly so that print(1.999, 2) prints as "2.00"
  273. > double rounding = 0.5;
  274. > for (uint8_t i=0; i<digits; ++i)
  275. > rounding /= 10.0;
  276. >
  277. > number += rounding;
  278. >
  279. > // Extract the integer part of the number and print it
  280. > unsigned long int_part = (unsigned long)number;
  281. > double remainder = number - (double)int_part;
  282. > n += print(int_part);
  283. >
  284. > // Print the decimal point, but only if there are digits beyond
  285. > if (digits > 0) {
  286. > n += print(".");
  287. > }
  288. >
  289. > // Extract digits from the remainder one at a time
  290. > while (digits-- > 0)
  291. > {
  292. > remainder *= 10.0;
  293. > int toPrint = int(remainder);
  294. > n += print(toPrint);
  295. > remainder -= toPrint;
  296. > }
  297. >
  298. > return n;
  299. > }
  300. >
  301. > size_t Print::printFloat(float number, uint8_t digits)
  302. > {
  303. > size_t n = 0;
  304. >
  305. > // Handle negative numbers
  306. > if (number < 0.0)
  307. > {
  308. > n += print('-');
  309. > number = -number;
  310. > }
  311. >
  312. > // Round correctly so that print(1.999, 2) prints as "2.00"
  313. > float rounding = 0.5;
  314. > for (uint8_t i=0; i<digits; ++i)
  315. > rounding /= 10.0;
  316. >
  317. > number += rounding;
  318. >
  319. > // Extract the integer part of the number and print it
  320. > unsigned long int_part = (unsigned long)number;
  321. > float remainder = number - (float)int_part;
  322. > n += print(int_part);
  323. >
  324. > // Print the decimal point, but only if there are digits beyond
  325. > if (digits > 0) {
  326. > n += print(".");
  327. > }
  328. >
  329. > // Extract digits from the remainder one at a time
  330. > while (digits-- > 0)
  331. > {
  332. > remainder *= 10.0;
  333. > int toPrint = int(remainder);
  334. > n += print(toPrint);
  335. > remainder -= toPrint;
  336. > }
  337. >
  338. > return n;
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement