paotin/plugins/lib/xtintin/string.tin

#nop vim: set filetype=tt:;

/*
本文件属于 PaoTin++ 的一部分。
PaoTin++ © 2020~2023 的所有版权均由担子炮(dzp <danzipao@gmail.com>) 享有并保留一切法律权利
你可以在遵照 GPLv3 协议的基础之上使用、修改及重新分发本程序。
*/

#nop 本文件是 xtintin 的一部分，实现了一些字符串处理函数;

///=== {
///// 字符串处理函数：
//
// #@ str.Len <字符串>
//    给出指定字符串的长度。
//    本函数也可以简写为 len，两个名称用途和用法完全相同。
//
// #@ str.Width <字符串>
//    给出指定字符串的屏幕显示宽度（忽略颜色等控制字符，每个汉字按两个字符宽度计算。
//    本函数也可以简写为 width，两个名称用途和用法完全相同。
// };
#func {str.Len}     {#format result {%L} {%0}};
#func {len}         {#return {@str.Len{%0}}};

#func {str.Width}   {#format result {%W} {%0}};
#func {width}       {#return {@str.Width{%0}}};

///=== {
// #@ str.Space <长度>
//    生成指定长度的空白字符串。
//    本函数也可以简写为 space，两个名称用途和用法完全相同。
//
// #@ str.Repeat <次数> <字符串>
//    将指定的字符串重复若干次。
//    本函数也可以简写为 repeat，两个名称用途和用法完全相同。
//
// #@ str.Reverse <字符串>
//    将字符串按照倒序重排每个字符并返回新的字符串。
// };
#func {str.Space}   {#return {@str.Repeat{{%0};{ }}}};
#func {space}       {#return {@str.Space{%0}}};

#func {str.Repeat}  {#var result {}; #loop 1 {%1} tmp {#cat result {%2}}};
#func {repeat}      {#return {@str.Repeat{%0}}};

#func {str.Reverse} {#var result {}; #parse {%0} {tmp} {#var result {$tmp$result}}};

///=== {
// #@ str.Trim <字符串>
//    去除给定字符串首尾的连续空白。
//    本函数也可以简写为 trim，两个名称用途和用法完全相同。
//
// #@ str.TrimAll <字符串>
//    去除字符串中全部的空白。
//    本函数也可以简写为 trimAll，两个名称用途和用法完全相同。
//
// #@ str.Plain <字符串>
//    去除字符串中的颜色代码和 ANSI 控制字符。
//
// #@ str.Color <字符串>
//    仅保留字符串中的颜色代码，去掉其余成分，方便比较颜色。
// };
#func {str.Trim}    {#format result {%p} {%0}};
#func {trim}        {#return {@str.Trim{%0}}};

#func {str.TrimAll} {#var result {%0}; #replace {result} {%+1..s} {}};
#func {trimAll}     {#return {@str.TrimAll{%0}}};

#func {str.Plain}   {#format result {%P} {%0}};

#func {str.Color} {
    #local str      {};
    #local state    {START};
    #local ch       {};

    #parse {%0} {ch} {
        #switch {"$state/$ch"} {
            #case {"START/\e"}  {#local state {ESCAPE}};
            #case {"START/%*"}  {#0};
            #case {"ESCAPE/["}  {#local state {INNER}};
            #case {"ESCAPE/%*"} {#local state {OUTER}};
            #case {"INNER/m"}   {#cat str {;}; #local state {OUTER}};
            #case {"INNER/%*"}  {#cat str {$ch}};
            #case {"OUTER/\e"}  {#local state {ESCAPE}};
        };
    };

    #replace {str} {;$} {};

    #return {$str};
};

///=== {
// #@ str.Replace <字符串> <正则表达式> <替换表达式>
//    在给定字符串中执行替换，凡是被正则表达式匹配的东西都会用替换表达式进行替换。
//
// #@ str.ToLower <字符串>
//    将给定字符串转换成小写。
//    本函数也可以简写为 toLower，两个名称用途和用法完全相同。
//
// #@ str.ToUpper <字符串>
//    将给定字符串转换成大写。
//    本函数也可以简写为 toUpper，两个名称用途和用法完全相同。
//
// #@ str.Capital <字符串>
//    将给定字符串转换成首字母大写。
// };
#func {str.Replace} {#var result {%1}; #replace result {%2} {%3}};

#func {str.ToLower} {#format result {%l} {%0}};
#func {toLower}     {#return {@str.ToLower{%0}}};

#func {str.ToUpper} {#format result {%u} {%0}};
#func {toUpper}     {#return {@str.ToUpper{%0}}};

#func {str.Capital} {#format result {%n} {%0}};

///=== {
// #@ str.FromCode <十进制代码>
//    将十进制代码转换成对应的 ASCII 或者 Unicode 字符。
//    本函数也可以简写为 char，两个名称用途和用法完全相同。
//
// #@ str.ToCode <字符>
//    获得该字符在 Unicode 编码中的码点，以十进制整数形式表示。
//    本函数也可以简写为 codepoint，两个名称用途和用法完全相同。
//
// #@ str.FromHexCode <十六进制代码>
//    将十六进制代码转换成对应的 ASCII 或者 Unicode 字符。
//    本函数也可以简写为 hex2char，两个名称用途和用法完全相同。
//
// #@ str.ToHexCode <字符>
//    获得该字符在 Unicode 编码中的码点，以十六进制整数形式表示。
//    本函数也可以简写为 char2hex，两个名称用途和用法完全相同。
//
// #@ str.HexToDec <十六进制串转十进制串>
//    数字字符串转换，十六进制串转十进制串。
//    本函数也可以简写为 hex2dec，两个名称用途和用法完全相同。
//
// #@ str.DecToHex <十进制串转十六进制串>
//    数字字符串转换，十进制串转十六进制串。
//    本函数也可以简写为 dec2hex，两个名称用途和用法完全相同。
// };
#func {str.FromCode}    {#format result {%X} {%0}; #format result {%x} {$result}};
#func {char}            {#return {@str.FromCode{%0}}};

#func {str.ToCode}      {#format result {%A} {%0}};
#func {codepoint}       {#return {@str.ToCode{%0}}};

#func {str.FromHexCode} {#format result {%x} {%0}};
#func {hex2char}        {#return {@str.FromHexCode{%0}}};

#func {str.ToHexCode}   {#format result {%A} {%0}; #return @str.DecToHex{$result}};
#func {char2hex}        {#return {@str.ToHexCode{%0}}};

#func {str.HexToDec}    {#format result {%D} {%0}};
#func {hex2dec}         {#return {@str.HexToDec{%0}}};

#func {str.DecToHex}    {#format result {00%X} {%0}; #format result {%.-2s} {$result}};
#func {dec2hex}         {#return {@str.DecToHex{%0}}};

///=== {
// #@ str.BinToHex <二进制数字串>
//    二进制转十六进制
//
//  EXAMPLE: \@str.BinToHex{0}
//  RESULT:  {0}
//
//  EXAMPLE: \@str.BinToHex{1}
//  RESULT:  {1}
//
//  EXAMPLE: \@str.BinToHex{10}
//  RESULT:  {2}
//
//  EXAMPLE: \@str.BinToHex{0111}
//  RESULT:  {7}
//
//  EXAMPLE: \@str.BinToHex{1000}
//  RESULT:  {8}
//
//  EXAMPLE: \@str.BinToHex{1111}
//  RESULT:  {F}
//
//  EXAMPLE: \@str.BinToHex{01011}
//  RESULT:  {0B}
//
//  EXAMPLE: \@str.BinToHex{0000010010001101001010101111001101}
//  RESULT:  {01234ABCD}
// };
#func {str.BinToHex} {
    #local bin {%1};
    #local hex {};

    #if { "$bin" == "" } {
        #return {};
    };

    #local len {@str.Len{$bin}};

    #switch {$len % 4} {
        #case {0}   {#0};
        #case {1}   {#local bin {000$bin}};
        #case {2}   {#local bin {00$bin}};
        #case {3}   {#local bin {0$bin}};
    };

    #math len {(($len - 1) % 4 + 1) * 4};

    #while {1} {
        #if { @str.Len{$bin} < 1 } {
            #return {$hex};
        };
        #local parts {$bin};
        #replace parts {^%+4S%*$} {
            {left}  {&1}
            {right} {&2}
        };
        #local parts {$parts};
        #switch {"$parts[left]"} {
            #case {"0000"} {#cat hex {0}};
            #case {"0001"} {#cat hex {1}};
            #case {"0010"} {#cat hex {2}};
            #case {"0011"} {#cat hex {3}};
            #case {"0100"} {#cat hex {4}};
            #case {"0101"} {#cat hex {5}};
            #case {"0110"} {#cat hex {6}};
            #case {"0111"} {#cat hex {7}};
            #case {"1000"} {#cat hex {8}};
            #case {"1001"} {#cat hex {9}};
            #case {"1010"} {#cat hex {A}};
            #case {"1011"} {#cat hex {B}};
            #case {"1100"} {#cat hex {C}};
            #case {"1101"} {#cat hex {D}};
            #case {"1110"} {#cat hex {E}};
            #case {"1111"} {#cat hex {F}};
        };
        #local bin {$parts[right]};
    };
};

///=== {
// #@ str.HexToBin <十六进制数字串>
//    十六进制转二进制
//
//  EXAMPLE: \@str.HexToBin{0}
//  RESULT:  {0000}
//
//  EXAMPLE: \@str.HexToBin{1}
//  RESULT:  {0001}
//
//  EXAMPLE: \@str.HexToBin{2}
//  RESULT:  {0010}
//
//  EXAMPLE: \@str.HexToBin{7}
//  RESULT:  {0111}
//
//  EXAMPLE: \@str.HexToBin{8}
//  RESULT:  {1000}
//
//  EXAMPLE: \@str.HexToBin{F}
//  RESULT:  {1111}
//
//  EXAMPLE: \@str.HexToBin{f}
//  RESULT:  {1111}
//
//  EXAMPLE: \@str.HexToBin{0B}
//  RESULT:  {00001011}
//
//  EXAMPLE: \@str.HexToBin{01234ABCD}
//  RESULT:  {000000010010001101001010101111001101}
// };
#func {str.HexToBin} {
    #local hex {%1};
    #local bin {};

    #while {1} {
        #local parts {$hex};
        #if { @str.Len{$hex} < 1 } {
            #return {$bin};
        };
        #replace parts {^%+1S%*$} {
            {left}  {&1}
            {right} {&2}
        };
        #local parts {$parts};
        #local hex {$parts[right]};
        #switch {"$parts[left]"} {
            #case {"0"}     {#cat bin {0000}};
            #case {"1"}     {#cat bin {0001}};
            #case {"2"}     {#cat bin {0010}};
            #case {"3"}     {#cat bin {0011}};
            #case {"4"}     {#cat bin {0100}};
            #case {"5"}     {#cat bin {0101}};
            #case {"6"}     {#cat bin {0110}};
            #case {"7"}     {#cat bin {0111}};
            #case {"8"}     {#cat bin {1000}};
            #case {"9"}     {#cat bin {1001}};
            #case {"{A|a}"} {#cat bin {1010}};
            #case {"{B|b}"} {#cat bin {1011}};
            #case {"{C|c}"} {#cat bin {1100}};
            #case {"{D|d}"} {#cat bin {1101}};
            #case {"{E|e}"} {#cat bin {1110}};
            #case {"{F|f}"} {#cat bin {1111}};
        };
    };
};

#func {bin2hex} {#return {@str.BinToHex{%0}}};
#func {hex2bin} {#return {@str.HexToBin{%0}}};

///=== {
// #@ str.Format <格式> <参数>
//    执行 #format result <格式> <参数> 操作。
//    本函数也可以简写为 format，两个名称用途和用法完全相同。
// };
#func {str.Format}  {#format result {%1} {%2}};
#func {format}      {#return {@str.Format{%0}}};

///=== {
// #@ str.Left <字符串> <截取宽度>
//    按照屏幕宽度标准，截取字符串左边的若干字符。
//    本函数也可以简写为 left，两个名称用途和用法完全相同。
//
// #@ str.Right <字符串> <截取宽度>
//    按照屏幕宽度标准，截取字符串右边的若干字符。
//    本函数也可以简写为 right，两个名称用途和用法完全相同。
//
// #@ str.Sub <字符串> <开始宽度> <截取宽度>
//    按照屏幕宽度标准，从字符串开始的某个宽度，截取连续的若干字符。
//    本函数也可以简写为 substr，两个名称用途和用法完全相同。
// };
#func {str.Left}    {#local width {%2}; #if {$width<=0} {#return {}} {#format result {%.${width}s} {%1}}};
#func {left}        {#return {@str.Left{%0}}};

#func {str.Right}   {#local width {%2}; #if {$width<=0} {#return {}} {#format result {%.-${width}s} {%1}}};
#func {right}       {#return {@str.Right{%0}}};

#func {str.Sub}     {#return {@str.Left{{@str.Right{{%1}; @math.Eval{@str.Width{%1} - %2}}}; %3}}};
#func {substr}      {#return {@str.Sub{%0}}};

///=== {
// #@ str.AlignLeft <字符串> <宽度>
//    按照屏幕宽度标准，在字符串后面补空白，延长至指定宽度并使之居左对齐。
//
// #@ str.AlignRight <字符串> <宽度>
//    按照屏幕宽度标准，在字符串前面补空白，延长至指定宽度并使之居右对齐。
// };
#func {str.AlignLeft}   {#format result {%-%2s} {%1}};
#func {str.AlignRight}  {#format result {%+%2s} {%1}};

///=== {
// #@ str.AlignCenter <字符串> <宽度>
//    按照屏幕宽度标准，在字符串前后补空白，延长至指定宽度并使之居中对齐。
// };
#func {str.AlignCenter}  {
    #local str  {%1};
    #local max  {@default{%2;80}};

    #local width {@str.Width{$str}};

    #local left {};
    #local right {};

    #math left {($max - $width) / 2 + $width};
    #math right {$max - $left};

    #format result {%+${left}s%${right}s} {%1} {};
    #return {$result};
};

///=== {
// #@ str.Split <字符串> <分隔符>
//    将字符串按照分隔符拆分成多个子串，并作为字符串列表返回。
//    这里的分隔符可以通过正则表达式来指定。
//    本函数也可以简写为 split，两个名称用途和用法完全相同。
// };
#func {str.Split} {
    #local str {%1};
    #local sep {%2};
    #replace str {$sep} {;};
    #return {$str};
};

#func {split} {#return {@str.Split{%0}}};

///=== {
// #@ str.Chars <字符串>
//    把字符串拆成一系列单个的字符，结果是由组成它的每个字符构成的字符串列表。
//    本函数也可以简写为 chars，两个名称用途和用法完全相同。
// };
#func {str.Chars} {
    #local str {%0};
    #list str {tokenize} {$str};
    #return {@slist.FromList{$str}};
};

#func {chars} {#return {@str.Chars{%0}}};

///=== {
// #@ util.ColorBar <字符串> <颜色1> <权重1> <颜色2> <权重2> [...]
//    将字符串按照颜色及其对应的权重占比，渲染成彩色字符串。注意颜色参数须按顺序排列。
// };
#func {util.ColorBar} {
    #local str {%1};

    #local args {};
    #list args create {%0};
    #list args delete {1} {1};

    #local parts {};
    #list parts create {};
    #local count {0};
    #local sum {0};
    #while { $count < &args[] } {
        #local color    {$args[@math.Eval{$count + 1}]};
        #local weight   {@defaultNum{$args[@math.Eval{$count + 2}];0}};
        #list parts {add} {{
            {color}{$color}
            {weight}{$weight}
        }};
        #math count {$count + 2};
        #math sum {$sum + $weight};
    };

    #local elem {};
    #local len {@str.Len{$str}};
    #local leftLen {0};
    #local leftWeight {0};
    #local colorStr {};
    #foreach {$parts[%*]} {elem} {
        #local elemLen {@math.Eval{($elem[weight] + $leftWeight) * $len / $sum - $leftLen}};
        #local text {@str.Sub{{$str};$leftLen;$elemLen}};
        #cat colorStr {$elem[color]$text<299>};
        #math leftLen {$leftLen + $elemLen};
        #math leftWeight {$leftWeight + $elem[weight]};
    };

    #return {$colorStr};
};