API tools faq
paste
Guest User

LAMP C STDIO

a guest
Sep 13th, 2013
32
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 14.13 KB | None | 0 0
raw download clone embed print report
  1. /*
  2.  *  This file is in the Public Domain.
  3.  *  This file has no warranties of any kind,
  4.  *  And can be distributed, modified or used freely.
  5.  *
  6.  *  Author: Vinyl Scratched
  7.  *  [email protected]
  8.  */
  9.  
  10. /*
  11.  *  This file uses the LAMP C syntax extensions Library.
  12.  *  The lamp header is required for this file to be compiled.
  13.  */
  14.  
  15. #include <ctype.h>
  16. #include <stdio.h>
  17. #include <string.h>
  18. #include <stdarg.h>
  19. #include <stdlib.h>
  20. #include <console.h>
  21.  
  22. DECL(pchar_t, putchar)(
  23.         DECL(pchar_t, character)
  24.         ) {
  25.     _FRET write_char(character);
  26. }
  27.  
  28. DECL(pchar_t, puts)(
  29.         DECL(CONST _STR, str)
  30.         ) {
  31.     _FRET write_str(str);
  32. }
  33.  
  34. _TD FUNC(pchar_t, out_t)(
  35.         DECL(_STR, buffer),
  36.         DECL(pchar_t, character)
  37. );
  38.  
  39. _TD FUNC(pchar_t, outbulk_t)(
  40.         DECL(_STR, buffer),
  41.         DECL(CONST _STR, str)
  42. );
  43.  
  44. ENUM {
  45.     LJUSTIFY    = 0,
  46.     FORCE_PLUS  = 1,
  47.     FORCE_SPACE = 2,
  48.     HASH_FLAG   = 3,
  49.     ZERO_FILL   = 4
  50. };
  51.  
  52. ENUM {
  53.     LMOD_NONE = ZERO,
  54.     LMOD_HH,
  55.     LMOD_H,
  56.     LMOD_L,
  57.     LMOD_LL,
  58.     LMOD_J,
  59.     LMOD_Z,
  60.     LMOD_T,
  61.     LMOD_LF
  62. };
  63.  
  64. HIDDEN INLINE
  65. DECL(byte_t, do_flags)(
  66.         DECL(CONST _STR, format),
  67.         DECL(value_t *, count)
  68.         ) {
  69.     DECL(byte_t, flags) = ZERO;
  70.     _IF(format[*count] == '-') {
  71.         SET_BIT(flags, LJUSTIFY);
  72.         *count += 1;
  73.     }
  74.     _IF(format[*count] == '+') {
  75.         SET_BIT(flags, FORCE_PLUS);
  76.         *count += 1;
  77.     }
  78.     _IF(format[*count] == ' ') {
  79.         SET_BIT(flags, FORCE_SPACE);
  80.         *count += 1;
  81.     }
  82.     _IF(format[*count] == '#') {
  83.         SET_BIT(flags, HASH_FLAG);
  84.         *count += 1;
  85.     }
  86.     _IF(format[*count] == ' ') {
  87.         SET_BIT(flags, FORCE_SPACE);
  88.         *count += 1;
  89.     }
  90.     _IF(format[*count] == '0') {
  91.         SET_BIT(flags, ZERO_FILL);
  92.         *count += 1;
  93.     }
  94.     _FRET flags;
  95. }
  96.  
  97. HIDDEN INLINE
  98. DECL(byte_t, do_width)(
  99.         DECL(CONST _STR, format),
  100.         DECL(value_t *, count)
  101.         ) {
  102.     DECL(byte_t, str)[9];
  103.     memset(str, ZERO, 9);
  104.     DECL(byte_t, pos) = ZERO;
  105.     DECL(byte_t, width) = ZERO;
  106.     _IF(isdigit(format[*count]) && format[*count] != '0') {
  107.         str[pos++] = format[*count]; *count += 1;
  108.         _WL(isdigit(format[*count])) {
  109.             _IF(pos >= 8) BREAK;
  110.             str[pos++] = format[*count];
  111.             *count += 1;
  112.         }
  113.         width = strtol((CONST _STR)str, ZERO, 10);
  114.     }
  115.     _FRET width;
  116. }
  117.  
  118. HIDDEN INLINE
  119. DECL(byte_t, do_lmod)(
  120.         DECL(CONST _STR, format),
  121.         DECL(value_t *, count)
  122.         ) {
  123.     DECL(byte_t, lmod);
  124.     _SW(format[*count]) {
  125.         /* End of Stream */
  126.         CASE ZERO: {   
  127.             _FRET ZERO;
  128.         }
  129.         /* short int */
  130.         CASE 'h': {
  131.             lmod = LMOD_H;
  132.             *count += 1;
  133.             /* short short int (char) */
  134.             _IF(format[*count] == 'h') {
  135.                 lmod = LMOD_HH;
  136.                 *count += 1;
  137.             }
  138.             BREAK;
  139.         }
  140.         /* long int */
  141.         CASE 'l': {
  142.             lmod = LMOD_L;
  143.             *count += 1;
  144.             /* long long int */
  145.             _IF(format[*count] == 'l') {
  146.                 lmod = LMOD_LL;
  147.                 *count += 1;
  148.             }
  149.             BREAK;
  150.         }
  151.         /* intmax_t */
  152.         CASE 'j': {
  153.             lmod = LMOD_J;
  154.             *count += 1;
  155.             BREAK;
  156.         }
  157.         /* size_t */
  158.         CASE 'z': {
  159.             lmod = LMOD_Z;
  160.             *count += 1;
  161.             BREAK;
  162.         }
  163.         /* ptrdiff_t */
  164.         CASE 't': {
  165.             lmod = LMOD_T;
  166.             *count += 1;
  167.             BREAK;
  168.         }
  169.         /* long double */
  170.         CASE 'L': {
  171.             lmod = LMOD_LF;
  172.             *count += 1;
  173.             BREAK;
  174.         }
  175.         /* None */
  176.         DEFT: {
  177.             lmod = LMOD_NONE;
  178.             BREAK;
  179.         }
  180.     }
  181.     _FRET lmod;
  182. }
  183.  
  184. HIDDEN INLINE
  185. DECL(_V, do_transform)(
  186.         DECL(out_t, out0),
  187.         DECL(outbulk_t, out1),
  188.         DECL(_STR, buffer),
  189.         DECL(length_t, length),
  190.         DECL(pchar_t *, total),
  191.         DECL(signed long long, value),
  192.         DECL(byte_t, flags),
  193.         DECL(byte_t, width),
  194.         DECL(byte_t, base),
  195.         DECL(_STR, tmp)
  196.         ) {
  197.     _IF(CHK_BIT(flags, FORCE_PLUS)) {
  198.         _IF(value >= ZERO && tmp[ZERO] != '-') {
  199.             *total += out0(buffer, '+');
  200.             _IF(*total >= (pchar_t)length) _FRET;
  201.         }
  202.     }
  203.     _IF(CHK_BIT(flags, HASH_FLAG)) {
  204.         _IF(base == 16) {
  205.             *total += out1(buffer, "0x");
  206.             _IF(*total >= (pchar_t)length) _FRET;
  207.         } _LS _IF(base == 8) {
  208.             *total += out1(buffer, "0o");
  209.             _IF(*total >= (pchar_t)length) _FRET;
  210.         } _LS _IF(base == 4) {
  211.             *total += out1(buffer, "0q");
  212.             _IF(*total >= (pchar_t)length) _FRET;
  213.         } _LS _IF(base == 2) {
  214.             *total += out1(buffer, "0b");
  215.             _IF(*total >= (pchar_t)length) _FRET;
  216.         }
  217.     }
  218.     _IF(CHK_BIT(flags, LJUSTIFY)) {
  219.         *total += out1(buffer, tmp);
  220.     }
  221.     _IF(CHK_BIT(flags, ZERO_FILL) ||
  222.             CHK_BIT(flags, FORCE_SPACE)) {
  223.         DECL(sdword_t, diff);
  224.         DECL(byte_t, ch) = CHK_BIT(flags, ZERO_FILL)
  225.                 ? '0' : ' ';
  226.         diff = width - strlen(tmp);
  227.         _WL(diff > ZERO) {
  228.             *total += out0(buffer, ch);
  229.             _IF(*total >= (pchar_t)length) _FRET;
  230.             diff--;
  231.         }
  232.     }
  233.     _IF(!CHK_BIT(flags, LJUSTIFY)) {
  234.         *total += out1(buffer, tmp);
  235.     }
  236. }
  237.  
  238. HIDDEN INLINE
  239. DECL(_V, handle_lhex)(
  240.         DECL(byte_t, lhex),
  241.         DECL(_STR, tmp)
  242.         ) {
  243.     _IF(lhex) {
  244.         _FI(dig, ZERO, 65) {
  245.             _IF(!tmp[dig]) BREAK;
  246.             tmp[dig] = tolower(tmp[dig]);
  247.         }
  248.     }
  249. }
  250.  
  251. HIDDEN
  252. DECL(pchar_t, do_printf)(
  253.         DECL(out_t, out0),
  254.         DECL(outbulk_t, out1),
  255.         DECL(_STR, buffer),
  256.         DECL(length_t, length),
  257.         DECL(CONST _STR, format),
  258.         DECL(va_list, args),
  259.         DECL(byte_t, term)
  260.         ) {
  261.     DECL(pchar_t, total) = ZERO;
  262.     _FI(count, ZERO, length) {
  263.         _IF(!format[count]) BREAK;
  264.         _IF(total > (pchar_t)length) BREAK;
  265.         _IF(format[count] == '%') {
  266.             DECL(byte_t, lhex) = ZERO;
  267.             DECL(byte_t, lmod) = ZERO;
  268.             DECL(byte_t, flags) = ZERO;
  269.             DECL(byte_t, width) = ZERO;
  270.             count += 1;
  271.             /* Modifier Flags */
  272.             flags = do_flags(format, &count);
  273.             /* Padding Width */
  274.             _IF(flags) {
  275.                 width = do_width(format, &count);
  276.             }
  277.             /* Length Modifier */
  278.             lmod = do_lmod(format, &count);
  279.             /* Specifier */
  280.             DECL(byte_t, base_val);
  281.             _SW(format[count]) {
  282.                 /* End of Stream */
  283.                 CASE ZERO: {
  284.                     BREAK;
  285.                 }
  286.                 /* Byte Count */
  287.                 CASE 'n': {
  288.                     DECL(pchar_t *, ptr);
  289.                     ptr = (pchar_t *)_VA(args, dword_t);
  290.                     ptr[ZERO] = total;
  291.                     BREAK;
  292.                 }
  293.                 /* Percent Sign */
  294.                 CASE '%': {
  295.                     total += out0(buffer, '%');
  296.                     BREAK;
  297.                 }
  298.                 /* Signed Integer */
  299.                 CASE 'd': CASE 'i':
  300.                     base_val = 10;
  301.                     _SW(lmod) {
  302.                         CASE LMOD_Z: {
  303.                             DECL(char, tmp)[33];
  304.                             DECL(size_t, value);
  305.                             value = _VA(args, size_t);
  306.                             ltoa(value, tmp, base_val);
  307.                             handle_lhex(lhex, tmp);
  308.                             do_transform(
  309.                                     out0, out1, buffer, length, &total,
  310.                                     (signed long long)value, flags,
  311.                                     width, base_val, tmp
  312.                             );
  313.                             BREAK;
  314.                         }
  315.                         CASE LMOD_J: {
  316.                             DECL(char, tmp)[65];
  317.                             DECL(intmax_t, value);
  318.                             value = _VA(args, intmax_t);
  319.                             lltoa(value, tmp, base_val);
  320.                             handle_lhex(lhex, tmp);
  321.                             do_transform(
  322.                                     out0, out1, buffer, length, &total,
  323.                                     (signed long long)value, flags,
  324.                                     width, base_val, tmp
  325.                             );
  326.                             BREAK;
  327.                         }
  328.                         CASE LMOD_HH: {
  329.                             DECL(char, tmp)[9];
  330.                             DECL(sbyte_t, value);
  331.                             value = (sbyte_t)_VA(args, sdword_t);
  332.                             ctoa(value, tmp, base_val);
  333.                             handle_lhex(lhex, tmp);
  334.                             do_transform(
  335.                                     out0, out1, buffer, length, &total,
  336.                                     (signed long long)value, flags,
  337.                                     width, base_val, tmp
  338.                             );
  339.                             BREAK;
  340.                         }
  341.                         CASE LMOD_H: {
  342.                             DECL(char, tmp)[17];
  343.                             DECL(sword_t, value);
  344.                             value = (sword_t)_VA(args, sdword_t);
  345.                             stoa(value, tmp, base_val);
  346.                             handle_lhex(lhex, tmp);
  347.                             do_transform(
  348.                                     out0, out1, buffer, length, &total,
  349.                                     (signed long long)value, flags,
  350.                                     width, base_val, tmp
  351.                             );
  352.                             BREAK;
  353.                         }
  354.                         CASE LMOD_L: {
  355.                             DECL(char, tmp)[33];
  356.                             DECL(sdword_t, value);
  357.                             value = _VA(args, sdword_t);
  358.                             ltoa(value, tmp, base_val);
  359.                             handle_lhex(lhex, tmp);
  360.                             do_transform(
  361.                                     out0, out1, buffer, length, &total,
  362.                                     (signed long long)value, flags,
  363.                                     width, base_val, tmp
  364.                             );
  365.                             BREAK;
  366.                         }
  367.                         CASE LMOD_LL: {
  368.                             DECL(char, tmp)[65];
  369.                             DECL(sqword_t, value);
  370.                             value = _VA(args, sqword_t);
  371.                             lltoa(value, tmp, base_val);
  372.                             handle_lhex(lhex, tmp);
  373.                             do_transform(
  374.                                     out0, out1, buffer, length, &total,
  375.                                     (signed long long)value, flags,
  376.                                     width, base_val, tmp
  377.                             );
  378.                             BREAK;
  379.                         }
  380.                         CASE LMOD_NONE: {
  381.                             DECL(char, tmp)[33];
  382.                             DECL(sdword_t, value);
  383.                             value = _VA(args, sdword_t);
  384.                             itoa(value, tmp, base_val);
  385.                             handle_lhex(lhex, tmp);
  386.                             do_transform(
  387.                                     out0, out1, buffer, length, &total,
  388.                                     (signed long long)value, flags,
  389.                                     width, base_val, tmp
  390.                             );
  391.                             BREAK;
  392.                         }
  393.                     }
  394.                     BREAK;
  395.                 /* Unsigned UInteger */
  396.                 CASE 'u': CASE 'o': CASE 'b':
  397.                 CASE 'x': CASE 'X': CASE 'q':
  398.                     _IF(format[count] == 'u') {
  399.                         base_val = 10;
  400.                     } _LS _IF(format[count] == 'o') {
  401.                         base_val = 8;
  402.                     } _LS _IF(format[count] == 'b') {
  403.                         base_val = 2;
  404.                     } _LS _IF(format[count] == 'q') {
  405.                         base_val = 4;
  406.                     } _LS {
  407.                         _IF(format[count] == 'x') lhex = 1;
  408.                         base_val = 16;
  409.                     }
  410.                     _SW(lmod) {
  411.                         CASE LMOD_Z: {
  412.                             DECL(char, tmp)[33];
  413.                             DECL(size_t, value);
  414.                             value = _VA(args, size_t);
  415.                             ltoa(value, tmp, base_val);
  416.                             handle_lhex(lhex, tmp);
  417.                             do_transform(
  418.                                     out0, out1, buffer, length, &total,
  419.                                     (signed long long)value, flags,
  420.                                     width, base_val, tmp
  421.                             );
  422.                             BREAK;
  423.                         }
  424.                         CASE LMOD_J: {
  425.                             DECL(char, tmp)[65];
  426.                             DECL(uintmax_t, value);
  427.                             value = _VA(args, uintmax_t);
  428.                             lltoa(value, tmp, base_val);
  429.                             handle_lhex(lhex, tmp);
  430.                             do_transform(
  431.                                     out0, out1, buffer, length, &total,
  432.                                     (signed long long)value, flags,
  433.                                     width, base_val, tmp
  434.                             );
  435.                             BREAK;
  436.                         }
  437.                         CASE LMOD_HH: {
  438.                             DECL(char, tmp)[9];
  439.                             DECL(byte_t, value);
  440.                             value = (byte_t)_VA(args, dword_t);
  441.                             ctoa(value, tmp, base_val);
  442.                             handle_lhex(lhex, tmp);
  443.                             do_transform(
  444.                                     out0, out1, buffer, length, &total,
  445.                                     (signed long long)value, flags,
  446.                                     width, base_val, tmp
  447.                             );
  448.                             BREAK;
  449.                         }
  450.                         CASE LMOD_H: {
  451.                             DECL(char, tmp)[17];
  452.                             DECL(word_t, value);
  453.                             value = (word_t)_VA(args, dword_t);
  454.                             stoa(value, tmp, base_val);
  455.                             handle_lhex(lhex, tmp);
  456.                             do_transform(
  457.                                     out0, out1, buffer, length, &total,
  458.                                     (signed long long)value, flags,
  459.                                     width, base_val, tmp
  460.                             );
  461.                             BREAK;
  462.                         }
  463.                         CASE LMOD_L: {
  464.                             DECL(char, tmp)[33];
  465.                             DECL(dword_t, value);
  466.                             value = _VA(args, dword_t);
  467.                             ltoa(value, tmp, base_val);
  468.                             handle_lhex(lhex, tmp);
  469.                             do_transform(
  470.                                     out0, out1, buffer, length, &total,
  471.                                     (signed long long)value, flags,
  472.                                     width, base_val, tmp
  473.                             );
  474.                             BREAK;
  475.                         }
  476.                         CASE LMOD_LL: {
  477.                             DECL(char, tmp)[65];
  478.                             DECL(qword_t, value);
  479.                             value = _VA(args, qword_t);
  480.                             lltoa(value, tmp, base_val);
  481.                             handle_lhex(lhex, tmp);
  482.                             do_transform(
  483.                                     out0, out1, buffer, length, &total,
  484.                                     (signed long long)value, flags,
  485.                                     width, base_val, tmp
  486.                             );
  487.                             BREAK;
  488.                         }
  489.                         CASE LMOD_NONE: {
  490.                             DECL(char, tmp)[33];
  491.                             DECL(dword_t, value);
  492.                             value = _VA(args, dword_t);
  493.                             itoa(value, tmp, base_val);
  494.                             handle_lhex(lhex, tmp);
  495.                             do_transform(
  496.                                     out0, out1, buffer, length, &total,
  497.                                     (signed long long)value, flags,
  498.                                     width, base_val, tmp
  499.                             );
  500.                             BREAK;
  501.                         }
  502.                     }
  503.                     BREAK;
  504.                 /* Single Character */
  505.                 CASE 'c': {
  506.                     DECL(byte_t, value);
  507.                     value = (byte_t)_VA(args, dword_t);
  508.                     total += out0(buffer, value);
  509.                     BREAK;
  510.                 }
  511.                 /* String of Chars */
  512.                 CASE 's': {
  513.                     DECL(_STR, value) = _VA(args, _STR);
  514.                     //DECL(value_t, remain) = total - length;
  515.                     //_IF(remain >= strlen(value)) value[remain] = ZERO;
  516.                     total += out1(buffer, value);
  517.                     BREAK;
  518.                 }
  519.                 /* Pointer Address */
  520.                 CASE 'p': {
  521.                     DECL(char, tmp)[33];
  522.                     DECL(dword_t, pvalue);
  523.                     pvalue = (dword_t)_VA(args, _G);
  524.                     pvalue = pvalue;
  525.                     ltoa(pvalue, tmp, 16);
  526.                     handle_lhex(lhex, tmp);
  527.                     total += out1(buffer, tmp);
  528.                     BREAK;
  529.                 }
  530.                 /* Default Fallback */
  531.                 DEFT: {
  532.                     DECL(byte_t, value);
  533.                     value = (byte_t)_VA(args, dword_t);
  534.                     total += out0(buffer, value);
  535.                     BREAK;
  536.                 }
  537.             }
  538.         } _LS {
  539.             total += out0(buffer, format[count]);
  540.         }
  541.     }
  542.     _IF(term) total += out0(buffer, ZERO);
  543.     _FRET total;
  544. }
  545.  
  546. DECL(pchar_t, printf)(
  547.         DECL(CONST _STR, format),
  548.         VARGS
  549.         ) {
  550.     DECL(pchar_t, val);
  551.     DECL(va_list, list);
  552.     _VS(list, format);
  553.     val = vprintf(format, list);
  554.     _VE(list);
  555.     _FRET val;
  556. }
  557.  
  558. DECL(pchar_t, sprintf)(
  559.         DECL(_STR, str),
  560.         DECL(CONST _STR, format),
  561.         VARGS
  562.         ) {
  563.     DECL(pchar_t, val);
  564.     DECL(va_list, list);
  565.     _VS(list, format);
  566.     val = vsprintf(str, format, list);
  567.     _VE(list);
  568.     _FRET val;
  569. }
  570.  
  571. DECL(pchar_t, snprintf)(
  572.         DECL(_STR, str),
  573.         DECL(length_t, ct),
  574.         DECL(CONST _STR, format),
  575.         VARGS
  576.         ) {
  577.     DECL(pchar_t, val);
  578.     DECL(va_list, list);
  579.     _VS(list, format);
  580.     val = vsnprintf(str, ct, format, list);
  581.     _VE(list);
  582.     _FRET val;
  583. }
  584.  
  585. HIDDEN
  586. DECL(pchar_t, vwrite0)(
  587.         DECL(_STR, buffer),
  588.         DECL(pchar_t, character)
  589.         ) {
  590.     buffer = buffer;
  591.     _FRET putchar(character);
  592. }
  593.  
  594. HIDDEN
  595. DECL(pchar_t, vwrite1)(
  596.         DECL(_STR, buffer),
  597.         DECL(CONST _STR, str)
  598.         ) {
  599.     buffer = buffer;
  600.     _FRET puts(str);
  601. }
  602.  
  603. DECL(pchar_t, vprintf)(
  604.         DECL(CONST _STR, format),
  605.         DECL(va_list, args)
  606.         ) {
  607.     _FRET do_printf(
  608.             vwrite0, vwrite1,
  609.             ZERO, INT32_MAX,
  610.             format, args,
  611.             ZERO
  612.     );
  613. }
  614.  
  615. HIDDEN
  616. DECL(pchar_t, vswrite0)(
  617.         DECL(_STR, buffer),
  618.         DECL(pchar_t, character)
  619.         ) {
  620.     *(byte_t *)buffer = (byte_t)character;
  621.     _FRET 1;
  622. }
  623.  
  624. HIDDEN
  625. DECL(pchar_t, vswrite1)(
  626.         DECL(_STR, buffer),
  627.         DECL(CONST _STR, str)
  628.         ) {
  629.     _FI(count, ZERO, UINT32_MAX) {
  630.         _IF(!str[count]) _FRET count;
  631.         vswrite0(&buffer[count], str[count]);
  632.     }
  633.     _FRET ZERO;
  634. }
  635.  
  636. DECL(pchar_t, vsprintf)(
  637.         DECL(_STR, str),
  638.         DECL(CONST _STR, format),
  639.         DECL(va_list, args)
  640.         ) {
  641.     _FRET do_printf(
  642.             vswrite0, vswrite1,
  643.             str, INT32_MAX,
  644.             format, args,
  645.             !ZERO
  646.     );
  647. }
  648.  
  649. DECL(pchar_t, vsnprintf)(
  650.         DECL(_STR, str),
  651.         DECL(length_t, ct),
  652.         DECL(CONST _STR, format),
  653.         DECL(va_list, args)
  654.         ) {
  655.     _FRET do_printf(
  656.             vswrite0, vswrite1,
  657.             str, ct, format, args,
  658.             !ZERO
  659.     );
  660. }
Advertisement
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!