[新手上路]批处理新手入门导读[视频教程]批处理基础视频教程[视频教程]VBS基础视频教程[批处理精品]批处理版照片整理器
[批处理精品]纯批处理备份&还原驱动[批处理精品]CMD命令50条不能说的秘密[在线下载]第三方命令行工具[在线帮助]VBScript / JScript 在线参考
返回列表 发帖
happy886rr

帖子
961 
积分
2350 
技术
334  
捐助
0  
注册时间
2016-3-7 
1楼 跳转到 » 倒序看帖
打印
tT
发表于 2017-8-25 21:55 | 只看该作者

跨平台printf工具pr

本帖最后由 happy886rr 于 2017-8-26 10:12 编辑
pr  与printf类似，但远超printf。可以对各类文本格式化输出，对各类命令的返回结果进行格式化整理。内嵌表达式计算核心，堪比小型计算器。
(图片为外部链接)


用法
  1. pr -e [格式化表达式] [参数1] [参数2] [参数3] ...
复制代码
由于windows的批处理对%号敏感，我用\代替百分号，因此有了如下的格式化类型字符串
  1. \d 数字

  2. \x 十六进制

  3. \c 字符 

  4. \s 字符串

  5. \f 浮点数

  6. \o 八进制

  7. \u 无符号数

  8. \e 科学计数法

  9. \g 科学计数精度

  10. \r 回车

  11. \n 换行

  12. \t tab

  13. \T 显示本地时间字符串

  14. \C 颜色格式化

  15. \, 千分位格式化
复制代码
示例：
显示本地时间
  1. > pr -e\T

  2. Sat, 25 Aug 2017 19:59:12
复制代码
彩色输出
  1. > pr -e"\CW\Cel\Cco\Cm\Ce to \CBat\CHom\Ce" "1|4|8" "1|2|8" "1|8" "2|8" "1|4|8" "1|2" "1|4|8" "1|2|8"

  2. Sat, 25 Aug 2017 19:59:12
复制代码
千分位格式化
  1. > pr -e\, 1234567

  2. 1,234,567
复制代码
用于科学计算输出
  1. > pr -e"Result: \3.6f" sin((pi)/3)

  2. Result: 0.866025
复制代码
用于字符串对齐、文本对齐
  1. > pr -e"\-10.10s" da5da5d12ad21a1d2a1d

  2. > pr -e"\10s" da5

  3. > pr -e"\ 7d"  666
复制代码
用于打印换行特殊字符
  1. > pr -eAafafa\r\nafa+56a\r\nfsaf565ad\r\n

  2. > pr -e\c 7
复制代码
辅助echo实现各类增强功能，用处广，跨平台。更是各类控制台手机终端的必备良器。

源码发行，推荐gcc编译。不提供任何附件下载，请自行编译。
  1. /*

  2.     CONSOLE PRINT TOOL, PR.EXE COPYRIGHT@2017~2019 BY HAPPY

  3.     VERSION 1.0

  4. */

  5. #include   <stdio.h>

  6. #include  <stdlib.h>

  7. #include  <string.h>

  8. #include  <unistd.h>

  9. #include    <math.h>

  10. 

  11. #if defined(WIN32) || defined(_WIN32) || defined(__MINGW32__) || defined(_MSC_VER)

  12. #include <windows.h>

  13. #endif

  14. 

  15. #define HELPINFORMATION "\

  16. Console print tool, Copyright@2017~2019, Version 1.0\n\

  17. pr -e[expression] {args...}\n\

  18. \n\

  19. Options:\n\

  20.     -e print expression\n\

  21.     -h help information\n\

  22. \n\

  23. Support math functions:\n\

  24.      pi, e, torad, sin, cos, tan, sinh, cosh, tanh\n\

  25.      arcsin, arccos, arctan, arcsinh, arccosh, arctanh\n\

  26.      sqrt, abs, lg, ln, exp, gamma, rand, round, int, ceil, floor\n"

  27. 

  28. #define STACK_SIZE 4096

  29. static const char* KEY_WORDS[]= {"e", "pi", "sqrt", "lg", "ln", "sin", "cos", "tan", "arcsin", "arccos", "arctan", "torad", "abs", "round", "floor", "ceil", "exp", "sinh", "cosh", "tanh", "arcsinh", "arccosh", "arctanh", "int", "gamma", "rand", NULL};

  30. char   STACK1[STACK_SIZE]= {0};

  31. char   STACK2[STACK_SIZE]= {0};

  32. double STACK3[STACK_SIZE]= {0};

  33. 

  34. int prThousandsformatted(char* oStr)

  35. {

  36.     int len = strlen(oStr), rl = len%3, i;

  37.     for(i=0; i<rl; i++)

  38.     {

  39.         putc(oStr[i], stdout);

  40.     }

  41.     if(rl)

  42.         putc(',', stdout);

  43.     for(; i<len; i++)

  44.     {

  45.         putc(oStr[i], stdout);

  46.         if(!((i-rl+1)%3) && i!=len-1)

  47.             putc(',', stdout);

  48.     }

  49.     return 0;

  50. }

  51. 

  52. long long fact(long long n)

  53. {

  54.     return (n<2) ?1 :n*(fact(n-1));

  55. }

  56. 

  57. double RevPolishCore(const char* expression)

  58. {

  59.     char   *op=(char*)expression, *S1=STACK1, *S2=STACK2, **key, *cp, *kp;

  60.     double *S3=STACK3, di, ni;

  61.     int    brackets=0;

  62.     STACK3[0]=0;

  63. 

  64.     while(*op!='\0')

  65.     {

  66.         switch(*op)

  67.         {

  68.         case ' ' :

  69.         case '\t':

  70.         case '\r':

  71.         case '\n':

  72.             op++;

  73.             continue;

  74. 

  75.         case '(':

  76.             brackets++;

  77.             *(++S1)=*op;

  78.             if(*(op+1)=='-' || *(op+1)=='+')

  79.             {

  80.                 *(S2++)='0', *(S2++)=' ';

  81.             }

  82.             break;

  83. 

  84.         case ')':

  85.             if(brackets ==0)

  86.             {

  87.                 fputs("The brackets or ')' are not need", stderr);

  88.                 exit(1);

  89.             }

  90.             brackets--;

  91.             while(*S1!='(')

  92.             {

  93.                 *(S2++)=*(S1--);

  94.             }

  95.             S1--;

  96.             break;

  97. 

  98.         case '+':

  99.         case '-':

  100.             while(S1!=STACK1 && *S1!='(')

  101.             {

  102.                 *(S2++)=*(S1--);

  103.             }

  104.             *(++S1)=*op;

  105.             break;

  106. 

  107.         case '&':

  108.         case '|':

  109.         case '^':

  110.             while('A'<=(*S1) && (*S1)<='Z')

  111.             {

  112.                 *(S2++)=*(S1--);

  113.             }

  114.             *(++S1)=*op;

  115.             break;

  116. 

  117.         case '!':

  118.             *(S2++)=*op;

  119.             break;

  120. 

  121.         case '%':

  122.         case '*':

  123.         case '/':

  124.             while(('A'<=(*S1) && (*S1)<='Z') ||*S1=='%' ||*S1=='*' ||*S1=='/' ||*S1=='^')

  125.             {

  126.                 *(S2++)=*(S1--);

  127.             }

  128.             *(++S1)=*op;

  129.             break;

  130. 

  131.         default :

  132.             if('a'<=*op && *op<='z')

  133.             {

  134.                 key=(char**)KEY_WORDS;

  135.                 while(*key !=NULL)

  136.                 {

  137.                     cp=op, kp=*key;

  138.                     while((*cp==*kp || *cp+32==*kp) && *kp!='\0')

  139.                     {

  140.                         cp++, kp++;

  141.                     }

  142.                     if(!('a'<=*cp && *cp<='z')  && (*kp=='\0'))

  143.                     {

  144.                         op=cp;

  145.                         break;

  146.                     }

  147.                     key++;

  148.                 }

  149.                 if(*key !=0)

  150.                 {

  151.                     *(S2++)='.';

  152.                     *(S2++)=' ';

  153.                     while('A'<=(*S1) && (*S1)<='Z')

  154.                     {

  155.                         *(S2++)=*(S1--);

  156.                     }

  157.                     *(++S1)=key-(char**)KEY_WORDS+65;

  158.                     continue;

  159.                 }

  160.                 else

  161.                 {

  162.                     fputs("Unrecognized math function\n", stderr);

  163.                     exit(1);

  164.                 }

  165. 

  166.             }

  167.             else if(('0'<=*op && *op<='9') || (*op=='.'))

  168.             {

  169.                 while(('0'<=*op && *op<='9') || (*op=='.'))

  170.                 {

  171.                     *(S2++)=*(op++);

  172.                 }

  173.                 if('a'<=*op && *op<='z')

  174.                 {

  175.                     fputs("Missing required operator\n", stderr);

  176.                     exit(1);

  177.                 }

  178.                 op--;

  179.                 *(S2++)=' ';

  180. 

  181.             }

  182.             else

  183.             {

  184.                 fputs("Unrecognized operator\n", stderr);

  185.                 exit(1);

  186.             }

  187.             break;

  188.         }

  189.         op++;

  190.     }

  191. 

  192.     if(brackets !=0)

  193.     {

  194.         fputs("The brackets '(' are not closed", stderr);

  195.         exit(1);

  196.     }

  197. 

  198.     while(S1 !=STACK1)

  199.     {

  200.         *(S2++)=*(S1--);

  201.     }

  202.     *S2=' ';

  203. 

  204.     op=STACK2;

  205.     while(*op!=' ')

  206.     {

  207.         switch(*op)

  208.         {

  209.         case 'A':

  210.             *S3=2.7182818284590452;

  211.             break;

  212.         case 'B':

  213.             *S3=3.1415926535897932;

  214.             break;

  215.         case 'C':

  216.             if(*S3 <0)

  217.             {

  218.                 fputs("Negative numbers have no square root\n", stderr);

  219.                 exit(1);

  220.             }

  221.             *(S3-1)=sqrt(*S3);

  222.             S3--;

  223.             break;

  224.         case 'D':

  225.             if(*S3 <0)

  226.             {

  227.                 fputs("Negative numbers are not logarithmic\n", stderr);

  228.                 exit(1);

  229.             }

  230.             *(S3-1)=log10(*S3);

  231.             S3--;

  232.             break;

  233.         case 'E':

  234.             if(*S3 <0)

  235.             {

  236.                 fputs("Negative numbers have no natural logarithms\n", stderr);

  237.                 exit(1);

  238.             }

  239.             *(S3-1)=log(*S3);

  240.             S3--;

  241.             break;

  242.         case 'F':

  243.             *(S3-1)=sin(*S3);

  244.             S3--;

  245.             break;

  246.         case 'G':

  247.             *(S3-1)=cos(*S3);

  248.             S3--;

  249.             break;

  250.         case 'H':

  251.             if(*S3==3.1415926535897932/2)

  252.             {

  253.                 fputs("The pi/2 has no tangent\n", stderr);

  254.                 exit(1);

  255.             }

  256.             *(S3-1)=tan(*S3);

  257.             S3--;

  258.             break;

  259.         case 'I':

  260.             *(S3-1)=asin(*S3);

  261.             S3--;

  262.             break;

  263.         case 'J':

  264.             *(S3-1)=acos(*S3);

  265.             S3--;

  266.             break;

  267.         case 'K':

  268.             *(S3-1)=atan(*S3);

  269.             S3--;

  270.             break;

  271.         case 'L':

  272.             *(S3-1)=(*S3)*3.1415926535897932/180.0;

  273.             S3--;

  274.             break;

  275.         case 'M':

  276.             *(S3-1)=fabs(*S3);

  277.             S3--;

  278.             break;

  279.         case 'N':

  280.             *(S3-1)=round(*S3);

  281.             S3--;

  282.             break;

  283.         case 'O':

  284.             *(S3-1)=floor(*S3);

  285.             S3--;

  286.             break;

  287.         case 'P':

  288.             *(S3-1)=ceil(*S3);

  289.             S3--;

  290.             break;

  291.         case 'Q':

  292.             *(S3-1)=exp(*S3);

  293.             S3--;

  294.             break;

  295.         case 'R':

  296.             *(S3-1)=sinh(*S3);

  297.             S3--;

  298.             break;

  299.         case 'S':

  300.             *(S3-1)=cosh(*S3);

  301.             S3--;

  302.             break;

  303.         case 'T':

  304.             *(S3-1)=tanh(*S3);

  305.             S3--;

  306.             break;

  307.         case 'U':

  308.             *(S3-1)=asinh(*S3);

  309.             S3--;

  310.             break;

  311.         case 'V':

  312.             *(S3-1)=acosh(*S3);

  313.             S3--;

  314.             break;

  315.         case 'W':

  316.             *(S3-1)=atanh(*S3);

  317.             S3--;

  318.             break;

  319.         case 'X':

  320.             *(S3-1)=(int)(*S3);

  321.             S3--;

  322.             break;

  323.         case 'Y':

  324.             if(*S3 <0)

  325.             {

  326.                 fputs("Negative numbers have no factorial", stderr);

  327.                 exit(1);

  328.             }

  329.             *(S3-1)=tgamma(*S3);

  330.             S3--;

  331.             break;

  332.         case 'Z':

  333.             if(*S3 <0)

  334.             {

  335.                 fputs("A negative number can not be used as a random upper bound", stderr);

  336.                 exit(1);

  337.             }

  338.             else if(*S3 <2)

  339.             {

  340.                 *(S3-1)=rand() % 8192 /8192.0;

  341.             }

  342.             else

  343.             {

  344.                 *(S3-1)=rand() % (int)(*S3);

  345.             }

  346.             S3--;

  347.             break;

  348.         case '+':

  349.             *(S3-1)+=*S3;

  350.             S3--;

  351.             break;

  352.         case '-':

  353.             *(S3-1)-=*S3;

  354.             S3--;

  355.             break;

  356.         case '*':

  357.             *(S3-1)*=*S3;

  358.             S3--;

  359.             break;

  360.         case '%':

  361.         case '/':

  362.             if(*S3 !=0)

  363.             {

  364.                 if(*op=='%')

  365.                 {

  366.                     *(S3-1)=(int)*(S3-1) % (int)*S3;

  367.                 }

  368.                 else

  369.                 {

  370.                     *(S3-1)/=*S3;

  371.                 }

  372. 

  373.             }

  374.             else

  375.             {

  376.                 fputs("Divisor is zero error\n", stderr);

  377.                 exit(1);

  378.             }

  379.             S3--;

  380.             break;

  381.         case '|':

  382.             *(S3-1) =(int)(*(S3-1)) | (int)(*S3);

  383.             S3--;

  384.             break;

  385.         case '&':

  386.         	*(S3-1) =(int)(*(S3-1)) & (int)(*S3);

  387.             S3--;

  388.             break;

  389.         case '^':

  390.             if(*(S3-1)==0 && *S3<0)

  391.             {

  392.                 fputs("Function pow's divisor is zero error\n", stderr);

  393.                 exit(1);

  394.             }

  395.             *(S3-1)=pow(*(S3-1), *S3);

  396.             S3--;

  397.             break;

  398.         case '!':

  399.             if(*S3 <0)

  400.             {

  401.                 fputs("Negative numbers have no factorial\n", stderr);

  402.                 exit(1);

  403.             }

  404.             *S3=fact((long long)(*S3));

  405.             break;

  406.         default :

  407.             di=0, ni=1;

  408.             while('0'<=*op && *op<='9')

  409.             {

  410.                 di=10*di+(*op)-'0';

  411.                 op++;

  412.             }

  413.             if(*op=='.')

  414.             {

  415.                 op++;

  416.                 while('0'<=*op && *op<='9')

  417.                 {

  418.                     di=10*di+(*op)-'0';

  419.                     op++, ni*=10;

  420.                 }

  421.             }

  422.             *(++S3)=di/ni;

  423.             break;

  424.         }

  425.         op++;

  426.     }

  427. 

  428.     if (isinf(*S3)||isnan(*S3))

  429.     {

  430.         fputs("Overflow or illegal operation is calculated", stderr);

  431.         exit(1);

  432.     }

  433.     return *S3;

  434. }

  435. 

  436. //MAIN主函数入口

  437. int main(int argc, char** argv)

  438. {

  439.     if ((argc==1) || (argc==2 && !strcasecmp(argv[1], "-h")))

  440.     {

  441.         fprintf(stderr, HELPINFORMATION);

  442.         return 0;

  443.     }

  444. 

  445.     int i = 2;

  446.     char* prExp = NULL;

  447.     if ((argc > 1) && (argv[1][0]=='-' && (argv[1][1]=='e' || argv[1][1]=='E')))

  448.     {

  449.         prExp = (argv[1][2] != '\0') ?(argv[1]+2) :((argc > 2)?(argv[i++]):NULL);

  450.     }

  451. 

  452.     if (prExp == NULL)

  453.     {

  454.         fprintf(stderr, HELPINFORMATION);

  455.         return 1;

  456.     }

  457. 

  458.     srand((int)getpid());

  459.     char prBuf[STACK_SIZE], *t=prBuf, *p=prExp;

  460.     static char nowTime[128];

  461.     static const char* timeFormatGMT = "%a, %d %b %Y %H:%M:%S";

  462. 

  463. #if defined(WIN32) || defined(_WIN32) || defined(__MINGW32__) || defined(_MSC_VER)

  464. 	HANDLE handle_out=GetStdHandle(STD_OUTPUT_HANDLE);

  465. 	WORD orgCOLOR;

  466. 	CONSOLE_SCREEN_BUFFER_INFO buffINFO;

  467. 	GetConsoleScreenBufferInfo(handle_out, &buffINFO);

  468. 	orgCOLOR=buffINFO.wAttributes;

  469. #endif

  470. 

  471. 

  472.     while(*p)

  473.     {

  474.         if (*p == '\\')

  475.         {

  476.             t=prBuf;

  477.             *t++ = '%';

  478.             p++;

  479.             while(*p=='+' || *p=='-' || *p=='0' || *p==' ' || *p=='#' || ('0'<=*p && *p<='9') || *p=='.')

  480.                 *t++ = *p++;

  481. 

  482.             switch (*p)

  483.             {

  484.             case 'n':

  485.                 printf("\n");

  486.                 break;

  487. 

  488.             case 'r':

  489.                 printf("\r");

  490.                 break;

  491. 

  492.             case 't':

  493.                 printf("\t");

  494.                 break;

  495. 

  496.             case 'T':

  497.             	{

  498. 	                time_t timeNow = time((time_t*)0);

  499. 	                strftime(nowTime, sizeof(nowTime), timeFormatGMT, (const struct tm*)localtime(&timeNow));

  500. 	                printf("%s", nowTime);

  501.             	}

  502.             	break;

  503.             	

  504. #if defined(WIN32) || defined(_WIN32) || defined(__MINGW32__) || defined(_MSC_VER)

  505.             case 'C':

  506.                 if(i >= argc)

  507.                     break;

  508.                 SetConsoleTextAttribute(handle_out, (int)RevPolishCore(argv[i++]));

  509.             	break;

  510. #endif

  511. 

  512.             case '\\':

  513.                 printf("\\");

  514.                 break;

  515. 

  516.             case ',':

  517.                 if(i >= argc)

  518.                     break;

  519.                 prThousandsformatted(argv[i++]);

  520.                 break;

  521. 

  522.             case 's':

  523.                 *t++ = *p;

  524.                 *t='\0';

  525.                 if(i >= argc)

  526.                     break;

  527.                 printf(prBuf, (char*)argv[i++]);

  528.                 break;

  529. 

  530.             case 'c':

  531.                 *t++ = 'c';

  532.                 *t='\0';

  533.                 if(i >= argc)

  534.                     break;

  535.                 printf(prBuf, (char)(int)RevPolishCore(argv[i++]));

  536.                 break;

  537. 

  538.             case 'd':

  539.                 *t++ = 'd';

  540.                 *t='\0';

  541.                 if(i >= argc)

  542.                     break;

  543.                 printf(prBuf, (int)RevPolishCore(argv[i++]));

  544.                 break;

  545. 

  546.             case 'o':

  547.                 *t++ = 'o';

  548.                 *t='\0';

  549.                 if(i >= argc)

  550.                     break;

  551.                 printf(prBuf, (int)RevPolishCore(argv[i++]));

  552.                 break;

  553. 

  554.             case 'e':

  555.             case 'E':

  556.                 *t++ = *p;

  557.                 *t='\0';

  558.                 if(i >= argc)

  559.                     break;

  560.                 printf(prBuf, RevPolishCore(argv[i++]));

  561.                 break;

  562. 

  563.             case 'g':

  564.             case 'G':

  565.                 *t++ = *p;

  566.                 *t='\0';

  567.                 if(i >= argc)

  568.                     break;

  569.                 printf(prBuf, RevPolishCore(argv[i++]));

  570.                 break;

  571. 

  572.             case 'x':

  573.             case 'X':

  574.                 *t++ = *p;

  575.                 *t='\0';

  576.                 if(i >= argc)

  577.                     break;

  578.                 printf(prBuf, (int)RevPolishCore(argv[i++]));

  579.                 break;

  580. 

  581.             case 'u':

  582.                 *t++ = 'u';

  583.                 *t='\0';

  584.                 if(i >= argc)

  585.                     break;

  586.                 printf(prBuf, (unsigned int)RevPolishCore(argv[i++]));

  587.                 break;

  588. 

  589.             case 'f':

  590.                 *t++ = 'f';

  591.                 *t='\0';

  592.                 if(i >= argc)

  593.                     break;

  594.                 printf(prBuf, RevPolishCore(argv[i++]));

  595.                 break;

  596. 

  597.             default:

  598.                 fprintf(stderr, "Unknow flag '%c'", *p);

  599.                 return 1;

  600.             }

  601.             p++;

  602.         }

  603. 

  604.         t=prBuf;

  605.         while(*p && *p != '\\')

  606.             *t++ = *p++;

  607. 

  608.         *t='\0';

  609.         printf("%s", prBuf);

  610. 

  611.         if(i >= argc && argc!=2)

  612.             break;

  613. 

  614.     }

  615.     

  616. #if defined(WIN32) || defined(_WIN32) || defined(__MINGW32__) || defined(_MSC_VER)   

  617. 	SetConsoleTextAttribute(handle_out, orgCOLOR);

  618. #endif

  619. 

  620.     return 0;

  621. }
复制代码
1

评分人数

收藏 分享

返回列表