像linux ls命令一样优雅地打印

 

 

#define _GNU_SOURCE

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <errno.h>
#include <unistd.h>

#define TEST_THIS_FILE (1)

#if TEST_THIS_FILE
#include <unistd.h>
#define MY_MAX(a, b) ((a > b) ? (a) : (b))
#define MY_CEIL(a, b) ((0 == (a % b)) ? (a / b) : ((a / b) + 1))
#define my_free(a) do{if(a) {free(a); (a) = NULL;}} while(0)
#define STR_SAFE(str) ((NULL == (str)) ? "" : (str))
// #define my_print_ln(fmt, arg...) do { printf("(%s|%d)"fmt"\r\n", __func__, __LINE__, ##arg); } while(0)
#define my_print_ln(fmt, arg...) do { ; } while(0)
#else
#include "my_platform_common.h"
#endif




#define SPAN_LEN  (2)   // 列间空格个数

typedef struct _last_max_len_of_line_t {
    unsigned int len;
    unsigned int col_total;
}last_max_len_of_line_t;

/****************************************
    计算第几列宽度

    参数 :
        names : 待打印的字符串数组
        names_count : 待打印的字符串数组长度
        col_total : 打印列数
        index_col : 第几列

    return : 非NULL 成功
               NULL 失败

****************************************/
static unsigned int col_len_max(char **names, unsigned int names_count, unsigned int col_total, int index_col)
{
    unsigned int curr_col_len_max = 0;
    unsigned int index_name = 0;
    int row_count = 0;

    if (NULL == names || 0 >= names_count || 0 >= col_total || 0 > index_col) {
        return -1;
    }
    
    row_count = MY_CEIL(names_count, col_total);

    // 输出每一行
    for (index_name = 0; index_name < MY_CEIL(names_count, col_total); index_name++)
    {
        if (names_count - 1 < index_name + index_col * row_count) {
            break;
        }

        curr_col_len_max = MY_MAX(curr_col_len_max, strlen(names[index_name + index_col * row_count]));
    }

    if (0 < curr_col_len_max) {
        curr_col_len_max += SPAN_LEN;
    }

    //my_print_ln("ret=%d", curr_col_len_max);

    return curr_col_len_max;
}

/****************************************
    获取第几行字符串

    参数 :
        names : 待打印的字符串数组
        names_count : 待打印的字符串数组长度
        col_total : 打印列数
        index_row : 第几行
        width_each : 每列宽度数组

    return : 非NULL 成功
               NULL 失败

****************************************/
static char *make_buf_of_row(char **names, unsigned int names_count, unsigned int col_total, int index_row, int *width_each)
{
    char *buf_row = NULL;
    char *buf_row_tmp = NULL;
    char *format = NULL;
    int row_count = 0;
    unsigned int i = 0;

    if (NULL == names || 0 >= names_count || 0 >= col_total || 0 > index_row || NULL == width_each ) {
        return NULL;
    }
    
    row_count = MY_CEIL(names_count, col_total);

    for (i = 0; i < col_total; i++, buf_row_tmp = buf_row) {
        if (names_count - 1 < index_row + i * row_count) {
            break;
        }

        asprintf(&format, "%%s%%-%ds", width_each[i]);
        if (NULL == format) {
            my_free(buf_row);
            my_free(buf_row_tmp);
            return NULL;
        }
        asprintf(&buf_row, format, STR_SAFE(buf_row_tmp), names[index_row + i * row_count]);
        if (NULL == buf_row) {
            my_free(format);
            my_free(buf_row_tmp);
            return NULL;
        }

        my_free(format);
        my_free(buf_row_tmp);
    }

    // my_print_ln("ret=%s", buf_row);
    return buf_row;
}

static ssize_t _write(int fd, const void *buf, size_t count) {
  size_t written = 0;
  ssize_t thisTime = 0;
  while (count != written) {
    thisTime = write(fd, (char *)buf + written, count - written);
    if (thisTime == -1) {
      if (errno == EINTR)
        continue;
      else
        return -1;
    }
    written += thisTime;
  }
  return written;
}

/****************************************
    按n列打印字符串数组

    参数 :
        sockfd : 打印输出到文件描述符
        names : 待打印的字符串数组
        names_count : 待打印的字符串数组长度
        col_total : 打印列数

    return :  0 成功
             -1 失败

****************************************/
static int print_list(int sockfd, char **names, unsigned int names_count, unsigned int col_total)
{
    unsigned int index_col = 0;
    unsigned int index_row = 0;
    int *width_each_col = NULL;

    if (NULL == names || 0 >= names_count || 0 >= col_total) {
        return -1;
    }
    
    width_each_col = calloc(col_total, sizeof(int));
    if (NULL == width_each_col) {
        return -1;
    }

    // 计算每列的宽度
    for (index_col = 0; index_col < col_total; index_col++)
    {
        width_each_col[index_col] = col_len_max(names, names_count, col_total, index_col);
    }
    
    // 输出每一行
    for (index_row = 0; index_row < MY_CEIL(names_count, col_total); index_row++)
    {
        char *buf_each_line = NULL;
        
        buf_each_line = make_buf_of_row(names, names_count, col_total, index_row, width_each_col);
        if (NULL == buf_each_line) {
            continue;
        }

        _write(sockfd, buf_each_line, strlen(buf_each_line));
        _write(sockfd, "\r\n", 2);

        my_free(buf_each_line);
    }

    my_free(width_each_col);

    return 0;
}

/****************************************
    指定假设打印n列, 计算单行会输出的长度

    参数 :
        names : 待打印的字符串数组
        names_count : 待打印的字符串数组长度
        col_total : 打印列数

    return : >=0 单行输出的长度

****************************************/
static unsigned int cols_count_sum(char **names, unsigned int names_count, unsigned int col_total)
{
    unsigned int chars_count_per_line = 0;
    unsigned int index_col = 0;
    unsigned int width_each_col = 0;

    if (NULL == names || 0 >= names_count || 0 >= col_total) {
        return 0;
    }
    
    // 计算每列的宽度
    for (index_col = 0; index_col < col_total; index_col++)
    {
        width_each_col = col_len_max(names, names_count, col_total, index_col);
        chars_count_per_line += width_each_col;
        // my_print_ln("[col_total=%d]sum=%d,[%d]=%d", col_total, chars_count_per_line, index_col, width_each_col);
        if (0 >= width_each_col) {
            break;
        }
    }

    return chars_count_per_line;
}

/****************************************
    像ls命令那样优雅打印

    参数 :
        sockfd : 打印输出到文件描述符
        names : 待打印的字符串数组
        names_count : 待打印的字符串数组长度

    return : 成功返回0
             失败返回-1

****************************************/
int print_better(int sockfd, char **names, unsigned int names_count)
{
    last_max_len_of_line_t last = {0, 0};
    unsigned int chars_count_per_line = 0;
    int perfect_col_total = 0;  // 10 11 NOt-OK
    unsigned int col_total = 0;
    unsigned int width = 0;
    
    if (NULL == names || 0 >= names_count) {
        return -1;
    }

    // 0. 获取命令行宽度

    width = 205;
    // 1. 计算出最合适的列数
    for (col_total = 1; col_total < width; col_total++) 
    {
        chars_count_per_line = cols_count_sum(names, names_count, col_total);
        if (width < chars_count_per_line) {
            break;
        }

        if (chars_count_per_line > last.len) {
            last.len = chars_count_per_line;
            last.col_total = col_total;
        }

        // my_print_ln("==========");
    }

    perfect_col_total = (0 >= last.col_total ) ? 1 : last.col_total;

    // my_print_ln("perfect_col_total=%d", perfect_col_total);

    // 2. 打印
    print_list(sockfd, names, names_count, perfect_col_total);

    return 0;
}

#if TEST_THIS_FILE
char *names[] = {
".",
"..",
"AUTHORS",
"autom4te.cache",
"bootstrap",
"bootstrap.conf",
"build-aux",
"cfg.mk",
"configure.ac",
"COPYING",
"dist-check.mk",
"doc",
".git",
".gitattributes",
".github",
".gitignore",
".gitmodules",
"gl",
"gnulib",
"gnulib-tests",
"HACKING",
"init.cfg",
"lib",
"m4",

/*
".mailmap",
"Makefile.am",
"man",
"NEWS",
"po",
".prev-version",
"README",
"README-hacking",
"README-package-renamed-to-coreutils",
"README-prereq",
"README-release",
"README-valgrind",
"scripts",
"src",
"tests",
"thanks-gen",
"THANKS.in",
"THANKStt.in",
"TODO",
".vg-suppressions",
".x-update-copyright",
*/

};

int main(int argc, char const *argv[])
{
    print_better(STDIN_FILENO, names, sizeof(names) / sizeof(char *));

    return 0;
}
#endif

rm ./a.out -f ; gcc print_better.c ; ./a.out