Return to print.c CVS log

Up to [Qemu by Fabrice Bellard] / qemu / roms / ipxe / src / hci / mucurses

Annotation of qemu/roms/ipxe/src/hci/mucurses/print.c, revision 1.1

1.1     ! root        1: #include <curses.h>
        !             2: #include <stdio.h>
        !             3: #include <stddef.h>
        !             4: #include <ipxe/vsprintf.h>
        !             5: #include "mucurses.h"
        !             6: 
        !             7: /** @file
        !             8:  *
        !             9:  * MuCurses printing functions
        !            10:  *
        !            11:  */
        !            12: 
        !            13: FILE_LICENCE ( GPL2_OR_LATER );
        !            14: 
        !            15: /**
        !            16:  * Add a single-byte character and rendition to a window and advance
        !            17:  * the cursor
        !            18:  *
        !            19:  * @v *win     window to be rendered in
        !            20:  * @v ch       character to be added at cursor
        !            21:  * @ret rc     return status code
        !            22:  */
        !            23: int waddch ( WINDOW *win, const chtype ch ) {
        !            24:        _wputch( win, ch, WRAP );
        !            25:        return OK;
        !            26: }
        !            27: 
        !            28: /**
        !            29:  * Add string of single-byte characters to a window
        !            30:  *
        !            31:  * @v *win     window to be rendered in
        !            32:  * @v *str     standard c-style string
        !            33:  * @v n                max number of chars from string to render
        !            34:  * @ret rc     return status code
        !            35:  */
        !            36: int waddnstr ( WINDOW *win, const char *str, int n ) {
        !            37:        _wputstr( win, str, WRAP, n );
        !            38:        return OK;
        !            39: }
        !            40: 
        !            41: struct printw_context {
        !            42:        struct printf_context ctx;
        !            43:        WINDOW *win;
        !            44: };
        !            45: 
        !            46: static void _printw_handler ( struct printf_context *ctx, unsigned int c ) {
        !            47:        struct printw_context *wctx =
        !            48:                container_of ( ctx, struct printw_context, ctx );
        !            49: 
        !            50:        _wputch( wctx->win, c | wctx->win->attrs, WRAP );
        !            51: }
        !            52: 
        !            53: /**
        !            54:  * Print formatted output in a window
        !            55:  *
        !            56:  * @v *win     subject window
        !            57:  * @v *fmt     formatted string
        !            58:  * @v varglist argument list
        !            59:  * @ret rc     return status code
        !            60:  */
        !            61: int vw_printw ( WINDOW *win, const char *fmt, va_list varglist ) {
        !            62:        struct printw_context wctx;
        !            63: 
        !            64:        wctx.win = win;
        !            65:        wctx.ctx.handler = _printw_handler;
        !            66:        vcprintf ( &(wctx.ctx), fmt, varglist );
        !            67:        return OK;
        !            68: }
        !            69: 
        !            70: /**
        !            71:  * Print formatted output to a window
        !            72:  *
        !            73:  * @v *win     subject window
        !            74:  * @v *fmt     formatted string
        !            75:  * @v ...      string arguments
        !            76:  * @ret rc     return status code
        !            77:  */
        !            78: int wprintw ( WINDOW *win, const char *fmt, ... ) {
        !            79:        va_list args;
        !            80:        int i;
        !            81: 
        !            82:        va_start ( args, fmt );
        !            83:        i = vw_printw ( win, fmt, args );
        !            84:        va_end ( args );
        !            85:        return i;
        !            86: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.