diff options
Diffstat (limited to 'runtime/autoload')
| -rw-r--r-- | runtime/autoload/msgpack.vim | 820 | ||||
| -rw-r--r-- | runtime/autoload/shada.vim | 694 |
2 files changed, 1514 insertions, 0 deletions
diff --git a/runtime/autoload/msgpack.vim b/runtime/autoload/msgpack.vim new file mode 100644 index 0000000000..e6022922fe --- /dev/null +++ b/runtime/autoload/msgpack.vim @@ -0,0 +1,820 @@ +if exists('g:loaded_msgpack_autoload') + finish +endif +let g:loaded_msgpack_autoload = 1 + +"" +" Check that given value is an integer. Respects |msgpack-special-dict|. +function msgpack#is_int(v) abort + return type(a:v) == type(0) || ( + \type(a:v) == type({}) && get(a:v, '_TYPE') is# v:msgpack_types.integer) +endfunction + +"" +" Check that given value is an unsigned integer. Respects +" |msgpack-special-dict|. +function msgpack#is_uint(v) abort + return msgpack#is_int(a:v) && (type(a:v) == type(0) + \? a:v >= 0 + \: a:v._VAL[0] > 0) +endfunction + +"" +" True if s:msgpack_init_python() function was already run. +let s:msgpack_python_initialized = 0 + +"" +" Cached return of s:msgpack_init_python() used when +" s:msgpack_python_initialized is true. +let s:msgpack_python_type = 0 + +"" +" Create Python functions that are necessary for work. Also defines functions +" s:msgpack_dict_strftime(format, timestamp) and s:msgpack_dict_strptime(format, +" string). +" +" @return Zero in case no Python is available, empty string if Python-2 is +" available and string `"3"` if Python-3 is available. +function s:msgpack_init_python() abort + if s:msgpack_python_initialized + return s:msgpack_python_type + endif + let s:msgpack_python_initialized = 1 + for suf in ['', '3'] + try + execute 'python' . suf + \. "def shada_dict_strftime():\n" + \. " import datetime\n" + \. " import vim\n" + \. " fmt = vim.eval('a:format')\n" + \. " timestamp = vim.eval('a:timestamp')\n" + \. " timestamp = [int(v) for v in timestamp['_VAL']]\n" + \. " timestamp = timestamp[0] * (timestamp[1] << 62\n" + \. " | timestamp[2] << 31\n" + \. " | timestamp[3])\n" + \. " time = datetime.datetime.fromtimestamp(timestamp)\n" + \. " return time.strftime(fmt)\n" + \. "def shada_dict_strptime():\n" + \. " import datetime\n" + \. " import vim\n" + \. " fmt = vim.eval('a:format')\n" + \. " timestr = vim.eval('a:string')\n" + \. " timestamp = datetime.datetime.strptime(timestr, fmt)\n" + \. " timestamp = int(timestamp.timestamp())\n" + \. " if timestamp > 2 ** 31:\n" + \. " tsabs = abs(timestamp)" + \. " return ('{\"_TYPE\": v:msgpack_types.integer,'\n" + \. " + '\"_VAL\": [{sign},{v1},{v2},{v3}]}').format(\n" + \. " sign=1 if timestamp >= 0 else -1,\n" + \. " v1=((tsabs >> 62) & 0x3),\n" + \. " v2=((tsabs >> 31) & (2 ** 31 - 1)),\n" + \. " v3=(tsabs & (2 ** 31 - 1)))\n" + \. " else:\n" + \. " return str(timestamp)\n" + execute "function s:msgpack_dict_strftime(format, timestamp) abort\n" + \. " return py" . suf . "eval('shada_dict_strftime()')\n" + \. "endfunction\n" + \. "function s:msgpack_dict_strptime(format, string)\n" + \. " return eval(py" . suf . "eval('shada_dict_strptime()'))\n" + \. "endfunction\n" + let s:msgpack_python_type = suf + return suf + catch + continue + endtry + endfor + + "" + " strftime() function for |msgpack-special-dict| values. + " + " @param[in] format String according to which time should be formatted. + " @param[in] timestamp Timestamp (seconds since epoch) to format. + " + " @return Formatted timestamp. + " + " @warning Without +python or +python3 this function does not work correctly. + " The VimL code contains “reference” implementation which does not + " really work because of precision loss. + function s:msgpack_dict_strftime(format, timestamp) + return msgpack#strftime(a:format, +msgpack#int_dict_to_str(a:timestamp)) + endfunction + + "" + " Function that parses given string according to given format. + " + " @param[in] format String according to which string was formatted. + " @param[in] string Time formatted according to format. + " + " @return Timestamp. + " + " @warning Without +python or +python3 this function is able to work only with + " 31-bit (32-bit signed) timestamps that have format + " `%Y-%m-%dT%H:%M:%S`. + function s:msgpack_dict_strptime(format, string) + let fmt = '%Y-%m-%dT%H:%M:%S' + if a:format isnot# fmt + throw 'notimplemented-format:Only ' . fmt . ' format is supported' + endif + let match = matchlist(a:string, + \'\v\C^(\d+)\-(\d+)\-(\d+)T(\d+)\:(\d+)\:(\d+)$') + if empty(match) + throw 'invalid-string:Given string does not match format ' . a:format + endif + call map(match, 'str2nr(v:val, 10)') + let [year, month, day, hour, minute, second] = match[1:6] + " Bisection start and end: + " + " Start: 365 days in year, 28 days in month, -12 hours tz offset. + let bisect_ts_start = (((((year - 1970) * 365 + \+ (month - 1) * 28 + \+ (day - 1)) * 24 + \+ hour - 12) * 60 + \+ minute) * 60 + \+ second) + if bisect_ts_start < 0 + let bisect_ts_start = 0 + endif + let start_string = strftime(fmt, bisect_ts_start) + if start_string is# a:string + return bisect_ts_start + endif + " End: 366 days in year, 31 day in month, +14 hours tz offset. + let bisect_ts_end = (((((year - 1970) * 366 + \+ (month - 1) * 31 + \+ (day - 1)) * 24 + \+ hour + 14) * 60 + \+ minute) * 60 + \+ second) + let end_string = strftime(fmt, bisect_ts_end) + if end_string is# a:string + return bisect_ts_end + endif + if start_string ># end_string + throw 'internal-start-gt:Internal error: start > end' + endif + if start_string is# end_string + throw printf('internal-start-eq:Internal error: ' + \. 'start(%u)==end(%u), but start(%s)!=string(%s)', + \bisect_ts_start, bisect_ts_end, + \string(start_string), string(a:string)) + endif + if start_string ># a:string + throw 'internal-start-string:Internal error: start > string' + endif + if end_string <# a:string + throw 'internal-end-string:Internal error: end < string' + endif + while 1 + let bisect_ts_middle = (bisect_ts_start/2) + (bisect_ts_end/2) + let middle_string = strftime(fmt, bisect_ts_middle) + if a:string is# middle_string + return bisect_ts_middle + elseif a:string ># middle_string + if bisect_ts_middle == bisect_ts_start + let bisect_ts_start += 1 + else + let bisect_ts_start = bisect_ts_middle + endif + else + if bisect_ts_middle == bisect_ts_end + let bisect_ts_end -= 1 + else + let bisect_ts_end = bisect_ts_middle + endif + endif + if bisect_ts_start >= bisect_ts_end + throw 'not-found:Unable to find timestamp' + endif + endwhile + endfunction + + return 0 +endfunction + +"" +" Wrapper for strftime() that respects |msgpack-special-dict|. May actually use +" non-standard strftime() implementations for |msgpack-special-dict| values. +" +" @param[in] format Format string. +" @param[in] timestamp Formatted timestamp. +function msgpack#strftime(format, timestamp) abort + if type(a:timestamp) == type({}) + call s:msgpack_init_python() + return s:msgpack_dict_strftime(a:format, a:timestamp) + else + return strftime(a:format, a:timestamp) + endif +endfunction + +"" +" Parse string according to the format. +" +" Requires +python available. If it is not then only supported format is +" `%Y-%m-%dT%H:%M:%S` because this is the format used by ShaDa plugin. Also in +" this case bisection will be used (timestamps tried with strftime() up until +" result matches the string) and only 31-bit (signed 32-bit: with negative +" timestamps being useless this leaves 31 bits) timestamps will be supported. +" +" @param[in] format Time format. +" @param[in] string Parsed time string. Must match given format. +" +" @return Timestamp. Possibly as |msgpack-special-dict|. +function msgpack#strptime(format, string) abort + call s:msgpack_init_python() + return s:msgpack_dict_strptime(a:format, a:string) +endfunction + +let s:MSGPACK_HIGHEST_BIT = 1 +let s:MSGPACK_HIGHEST_BIT_NR = 0 +while s:MSGPACK_HIGHEST_BIT * 2 > 0 + let s:MSGPACK_HIGHEST_BIT = s:MSGPACK_HIGHEST_BIT * 2 + let s:MSGPACK_HIGHEST_BIT_NR += 1 +endwhile + +"" +" Shift given number by given amount of bits +function s:shift(n, s) abort + if a:s == 0 + return a:n + elseif a:s < 0 + let ret = a:n + for _ in range(-a:s) + let ret = ret / 2 + endfor + return ret + else + let ret = a:n + for i in range(a:s) + let new_ret = ret * 2 + if new_ret < ret + " Overflow: remove highest bit + let ret = xor(s:MSGPACK_HIGHEST_BIT, ret) * 2 + endif + let ret = new_ret + endfor + return ret + endif +endfunction + +let s:msgpack_mask_cache = { + \s:MSGPACK_HIGHEST_BIT_NR : s:MSGPACK_HIGHEST_BIT - 1} + +"" +" Apply a mask where first m bits are ones and other are zeroes to a given +" number +function s:mask1(n, m) abort + if a:m > s:MSGPACK_HIGHEST_BIT_NR + 1 + let m = s:MSGPACK_HIGHEST_BIT_NR + 1 + else + let m = a:m + endif + if !has_key(s:msgpack_mask_cache, m) + let p = 0 + for _ in range(m) + let p = p * 2 + 1 + endfor + let s:msgpack_mask_cache[m] = p + endif + return and(a:n, s:msgpack_mask_cache[m]) +endfunction + +"" +" Convert |msgpack-special-dict| that represents integer value to a string. Uses +" hexadecimal representation starting with 0x because it is the easiest to +" convert to. +function msgpack#int_dict_to_str(v) abort + let v = a:v._VAL + " 64-bit number: + " 0000000001111111111222222222233333333334444444444555555555566666 + " 1234567890123456789012345678901234567890123456789012345678901234 + " Split in _VAL: + " 0000000001111111111222222222233 3333333344444444445555555555666 66 + " 1234567890123456789012345678901 2345678901234567890123456789012 34 + " Split by hex digits: + " 0000 0000 0111 1111 1112 2222 2222 2333 3333 3334 4444 4444 4555 5555 5556 6666 + " 1234 5678 9012 3456 7890 1234 5678 9012 3456 7890 1234 5678 9012 3456 7890 1234 + " + " Total split: + " _VAL[3] _VAL[2] _VAL[1] + " ______________________________________ _______________________________________ __ + " 0000 0000 0111 1111 1112 2222 2222 233 3 3333 3334 4444 4444 4555 5555 5556 66 66 + " 1234 5678 9012 3456 7890 1234 5678 901 2 3456 7890 1234 5678 9012 3456 7890 12 34 + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^ + " g4 g3 g2 g1 + " ********************************** *** * ********************************** ** ** + " 1 2 3 4 5 6 + " 1: s:mask1(v[3], 28): first 28 bits of _VAL[3] + " 2: s:shift(v[3], -28): last 3 bits of _VAL[3] + " 3: s:mask1(v[2], 1): first bit of _VAL[2] + " 4: s:mask1(s:shift(v[2], -1), 28): bits 2 .. 29 of _VAL[2] + " 5: s:shift(v[2], -29): last 2 bits of _VAL[2] + " 6: s:shift(v[1], 2): _VAL[1] + let g4 = printf('%07x', s:mask1(v[3], 28)) + let g3 = printf('%01x', or(s:shift(v[3], -28), s:shift(s:mask1(v[2], 1), 3))) + let g2 = printf('%07x', s:mask1(s:shift(v[2], -1), 28)) + let g1 = printf('%01x', or(s:shift(v[2], -29), s:shift(v[1], 2))) + return ((v[0] < 0 ? '-' : '') . '0x' . g1 . g2 . g3 . g4) +endfunction + +"" +" True boolean value. +let g:msgpack#true = {'_TYPE': v:msgpack_types.boolean, '_VAL': 1} +lockvar! g:msgpack#true + +"" +" False boolean value. +let g:msgpack#false = {'_TYPE': v:msgpack_types.boolean, '_VAL': 0} +lockvar! g:msgpack#false + +"" +" NIL value. +let g:msgpack#nil = {'_TYPE': v:msgpack_types.nil, '_VAL': 0} +lockvar! g:msgpack#nil + +"" +" Deduce type of |msgpack-special-dict|. +" +" @return zero if given dictionary is not special or name of the key in +" v:msgpack_types dictionary. +function msgpack#special_type(v) abort + if type(a:v) != type({}) || !has_key(a:v, '_TYPE') + return 0 + endif + for [k, v] in items(v:msgpack_types) + if a:v._TYPE is v + return k + endif + endfor + return 0 +endfunction + +"" +" Mapping that maps type() output to type names. +let s:MSGPACK_STANDARD_TYPES = { + \type(0): 'integer', + \type(0.0): 'float', + \type(''): 'binary', + \type([]): 'array', + \type({}): 'map', +\} + +"" +" Deduce type of one of items returned by msgpackparse(). +" +" @return Name of a key in v:msgpack_types. +function msgpack#type(v) abort + let special_type = msgpack#special_type(a:v) + if special_type is 0 + return s:MSGPACK_STANDARD_TYPES[type(a:v)] + endif + return special_type +endfunction + +"" +" Dump nil value. +function s:msgpack_dump_nil(v) abort + return 'NIL' +endfunction + +"" +" Dump boolean value. +function s:msgpack_dump_boolean(v) abort + return a:v._VAL ? 'TRUE' : 'FALSE' +endfunction + +"" +" Dump integer msgpack value. +function s:msgpack_dump_integer(v) abort + if type(a:v) == type({}) + return msgpack#int_dict_to_str(a:v) + else + return string(a:v) + endif +endfunction + +"" +" Dump floating-point value. +function s:msgpack_dump_float(v) abort + return string(type(a:v) == type({}) ? a:v._VAL : a:v) +endfunction + +"" +" Dump |msgpack-special-dict| that represents a string. If any additional +" parameter is given then it dumps binary string. +function s:msgpack_dump_string(v, ...) abort + let ret = [a:0 ? '"' : '="'] + for v in a:v._VAL + call add( + \ret, + \substitute( + \substitute(v, '["\\]', '\\\0', 'g'), + \'\n', '\\0', 'g')) + call add(ret, '\n') + endfor + let ret[-1] = '"' + return join(ret, '') +endfunction + +"" +" Dump binary string. +function s:msgpack_dump_binary(v) abort + if type(a:v) == type({}) + return s:msgpack_dump_string(a:v, 1) + else + return s:msgpack_dump_string({'_VAL': split(a:v, "\n", 1)}, 1) + endif +endfunction + +"" +" Dump array value. +function s:msgpack_dump_array(v) abort + let val = type(a:v) == type({}) ? a:v._VAL : a:v + return '[' . join(map(val[:], 'msgpack#string(v:val)'), ', ') . ']' +endfunction + +"" +" Dump dictionary value. +function s:msgpack_dump_map(v) abort + let ret = ['{'] + if msgpack#special_type(a:v) is 0 + for [k, v] in items(a:v) + let ret += [s:msgpack_dump_string({'_VAL': split(k, "\n", 1)}), + \': ', + \msgpack#string(v), + \', '] + unlet v + endfor + if !empty(a:v) + call remove(ret, -1) + endif + else + for [k, v] in sort(copy(a:v._VAL)) + let ret += [msgpack#string(k), + \': ', + \msgpack#string(v), + \', '] + unlet k + unlet v + endfor + if !empty(a:v._VAL) + call remove(ret, -1) + endif + endif + let ret += ['}'] + return join(ret, '') +endfunction + +"" +" Dump extension value. +function s:msgpack_dump_ext(v) abort + return printf('+(%i)%s', a:v._VAL[0], + \s:msgpack_dump_string({'_VAL': a:v._VAL[1]}, 1)) +endfunction + +"" +" Convert msgpack object to a string, like string() function does. Result of the +" conversion may be passed to msgpack#eval(). +function msgpack#string(v) abort + if type(a:v) == type({}) + let type = msgpack#special_type(a:v) + if type is 0 + let type = 'map' + endif + else + let type = get(s:MSGPACK_STANDARD_TYPES, type(a:v), 0) + if type is 0 + throw printf('msgpack:invtype: Unable to convert value %s', string(a:v)) + endif + endif + return s:msgpack_dump_{type}(a:v) +endfunction + +"" +" Copy msgpack object like deepcopy() does, but leave types intact +function msgpack#deepcopy(obj) abort + if type(a:obj) == type([]) + return map(copy(a:obj), 'msgpack#deepcopy(v:val)') + elseif type(a:obj) == type({}) + let special_type = msgpack#special_type(a:obj) + if special_type is 0 + return map(copy(a:obj), 'msgpack#deepcopy(v:val)') + else + return { + \'_TYPE': v:msgpack_types[special_type], + \'_VAL': msgpack#deepcopy(a:obj._VAL) + \} + endif + else + return copy(a:obj) + endif +endfunction + +"" +" Convert an escaped character to needed value +function s:msgpack_eval_str_sub(ch) abort + if a:ch is# 'n' + return '", "' + elseif a:ch is# '0' + return '\n' + else + return '\' . a:ch + endif +endfunction + +let s:MSGPACK_SPECIAL_OBJECTS = { + \'NIL': '{''_TYPE'': v:msgpack_types.nil, ''_VAL'': 0}', + \'TRUE': '{''_TYPE'': v:msgpack_types.boolean, ''_VAL'': 1}', + \'FALSE': '{''_TYPE'': v:msgpack_types.boolean, ''_VAL'': 0}', + \'nan': '(-(1.0/0.0-1.0/0.0))', + \'inf': '(1.0/0.0)', +\} + +"" +" Convert msgpack object dumped by msgpack#string() to a VimL object suitable +" for msgpackdump(). +" +" @param[in] s String to evaluate. +" @param[in] special_objs Additional special objects, in the same format as +" s:MSGPACK_SPECIAL_OBJECTS. +" +" @return Any value that msgpackparse() may return. +function msgpack#eval(s, special_objs) abort + let s = a:s + let expr = [] + let context = [] + while !empty(s) + let s = substitute(s, '^\s*', '', '') + if s[0] =~# '\v^\h$' + let name = matchstr(s, '\v\C^\w+') + if has_key(s:MSGPACK_SPECIAL_OBJECTS, name) + call add(expr, s:MSGPACK_SPECIAL_OBJECTS[name]) + elseif has_key(a:special_objs, name) + call add(expr, a:special_objs[name]) + else + throw 'name-unknown:Unknown name ' . name . ': ' . s + endif + let s = s[len(name):] + elseif (s[0] is# '-' && s[1] =~# '\v^\d$') || s[0] =~# '\v^\d$' + let sign = 1 + if s[0] is# '-' + let s = s[1:] + let sign = -1 + endif + if s[0:1] is# '0x' + " See comment in msgpack#int_dict_to_str(). + let s = s[2:] + let hexnum = matchstr(s, '\v\C^\x+') + if empty(hexnum) + throw '0x-empty:Must have number after 0x: ' . s + elseif len(hexnum) > 16 + throw '0x-long:Must have at most 16 hex digits: ' . s + endif + let s = s[len(hexnum):] + let hexnum = repeat('0', 16 - len(hexnum)) . hexnum + let g1 = str2nr(hexnum[0], 16) + let g2 = str2nr(hexnum[1:7], 16) + let g3 = str2nr(hexnum[8], 16) + let g4 = str2nr(hexnum[9:15], 16) + let v1 = s:shift(g1, -2) + let v2 = or(or(s:shift(s:mask1(g1, 2), 29), s:shift(g2, 1)), + \s:mask1(s:shift(g3, -3), 1)) + let v3 = or(s:shift(s:mask1(g3, 3), 28), g4) + call add(expr, printf('{''_TYPE'': v:msgpack_types.integer, '. + \'''_VAL'': [%i, %u, %u, %u]}', + \sign, v1, v2, v3)) + else + let num = matchstr(s, '\v\C^\d+') + let s = s[len(num):] + if sign == -1 + call add(expr, '-') + endif + call add(expr, num) + if s[0] is# '.' + let dec = matchstr(s, '\v\C^\.\d+%(e[+-]?\d+)?') + if empty(dec) + throw '0.-nodigits:Decimal dot must be followed by digit(s): ' . s + endif + let s = s[len(dec):] + call add(expr, dec) + endif + endif + elseif s =~# '-\?\%(inf\|nan\)' + if s[0] is# '-' + call add(expr, '-') + let s = s[1:] + endif + call add(expr, s:MSGPACK_SPECIAL_OBJECTS[s[0:2]]) + let s = s[3:] + elseif stridx('="+', s[0]) != -1 + let match = matchlist(s, '\v\C^(\=|\+\((\-?\d+)\)|)(\"%(\\.|[^\\"]+)*\")') + if empty(match) + throw '"-invalid:Invalid string: ' . s + endif + call add(expr, '{''_TYPE'': v:msgpack_types.') + if empty(match[1]) + call add(expr, 'binary') + elseif match[1] is# '=' + call add(expr, 'string') + else + call add(expr, 'ext') + endif + call add(expr, ', ''_VAL'': [') + if match[1][0] is# '+' + call add(expr, match[2] . ', [') + endif + call add(expr, substitute(match[3], '\v\C\\(.)', + \'\=s:msgpack_eval_str_sub(submatch(1))', 'g')) + if match[1][0] is# '+' + call add(expr, ']') + endif + call add(expr, ']}') + let s = s[len(match[0]):] + elseif s[0] is# '{' + call add(context, 'map') + call add(expr, '{''_TYPE'': v:msgpack_types.map, ''_VAL'': [') + call add(expr, '[') + let s = s[1:] + elseif s[0] is# '[' + call add(context, 'array') + call add(expr, '[') + let s = s[1:] + elseif s[0] is# ':' + call add(expr, ',') + let s = s[1:] + elseif s[0] is# ',' + if context[-1] is# 'array' + call add(expr, ',') + else + call add(expr, '], [') + endif + let s = s[1:] + elseif s[0] is# ']' + call remove(context, -1) + call add(expr, ']') + let s = s[1:] + elseif s[0] is# '}' + call remove(context, -1) + if expr[-1] is# "\x5B" + call remove(expr, -1) + else + call add(expr, ']') + endif + call add(expr, ']}') + let s = s[1:] + elseif s[0] is# '''' + let char = matchstr(s, '\m\C^''\zs.\ze''') + if empty(char) + throw 'char-invalid:Invalid integer character literal format: ' . s + endif + call add(expr, char2nr(char)) + let s = s[len(char) + 2:] + else + throw 'unknown:Invalid non-space character: ' . s + endif + endwhile + if empty(expr) + throw 'empty:Parsed string is empty' + endif + return eval(join(expr, '')) +endfunction + +"" +" Check whether two msgpack values are equal +function msgpack#equal(a, b) + let atype = msgpack#type(a:a) + let btype = msgpack#type(a:b) + if atype isnot# btype + return 0 + endif + let aspecial = msgpack#special_type(a:a) + let bspecial = msgpack#special_type(a:b) + if aspecial is# bspecial + if aspecial is# 0 + if type(a:a) == type({}) + if len(a:a) != len(a:b) + return 0 + endif + if !empty(filter(keys(a:a), '!has_key(a:b, v:val)')) + return 0 + endif + for [k, v] in items(a:a) + if !msgpack#equal(v, a:b[k]) + return 0 + endif + unlet v + endfor + return 1 + elseif type(a:a) == type([]) + if len(a:a) != len(a:b) + return 0 + endif + let i = 0 + for asubval in a:a + if !msgpack#equal(asubval, a:b[i]) + return 0 + endif + let i += 1 + unlet asubval + endfor + return 1 + elseif type(a:a) == type(0.0) + return (a:a == a:a ? a:a == a:b : string(a:a) ==# string(a:b)) + else + return a:a ==# a:b + endif + elseif aspecial is# 'map' || aspecial is# 'array' + if len(a:a._VAL) != len(a:b._VAL) + return 0 + endif + let alist = aspecial is# 'map' ? sort(copy(a:a._VAL)) : a:a._VAL + let blist = bspecial is# 'map' ? sort(copy(a:b._VAL)) : a:b._VAL + let i = 0 + for asubval in alist + let bsubval = blist[i] + if aspecial is# 'map' + if !(msgpack#equal(asubval[0], bsubval[0]) + \&& msgpack#equal(asubval[1], bsubval[1])) + return 0 + endif + else + if !msgpack#equal(asubval, bsubval) + return 0 + endif + endif + let i += 1 + unlet asubval + unlet bsubval + endfor + return 1 + elseif aspecial is# 'nil' + return 1 + elseif aspecial is# 'float' + return (a:a._VAL == a:a._VAL + \? (a:a._VAL == a:b._VAL) + \: (string(a:a._VAL) ==# string(a:b._VAL))) + else + return a:a._VAL ==# a:b._VAL + endif + else + if atype is# 'array' + let a = aspecial is 0 ? a:a : a:a._VAL + let b = bspecial is 0 ? a:b : a:b._VAL + return msgpack#equal(a, b) + elseif atype is# 'binary' + let a = (aspecial is 0 ? split(a:a, "\n", 1) : a:a._VAL) + let b = (bspecial is 0 ? split(a:b, "\n", 1) : a:b._VAL) + return a ==# b + elseif atype is# 'map' + if aspecial is 0 + let akeys = copy(a:a) + if len(a:b._VAL) != len(akeys) + return 0 + endif + for [k, v] in a:b._VAL + if msgpack#type(k) isnot# 'string' + " Non-special mapping cannot have non-string keys + return 0 + endif + if (empty(k._VAL) + \|| k._VAL ==# [""] + \|| !empty(filter(copy(k._VAL), 'stridx(v:val, "\n") != -1'))) + " Non-special mapping cannot have zero byte in key or an empty key + return 0 + endif + let kstr = join(k._VAL, "\n") + if !has_key(akeys, kstr) + " Protects from both missing and duplicate keys + return 0 + endif + if !msgpack#equal(akeys[kstr], v) + return 0 + endif + call remove(akeys, kstr) + unlet k + unlet v + endfor + return 1 + else + return msgpack#equal(a:b, a:a) + endif + elseif atype is# 'float' + let a = aspecial is 0 ? a:a : a:a._VAL + let b = bspecial is 0 ? a:b : a:b._VAL + return (a == a ? a == b : string(a) ==# string(b)) + elseif atype is# 'integer' + if aspecial is 0 + let sign = a:a >= 0 ? 1 : -1 + let a = sign * a:a + let v1 = s:mask1(s:shift(a, -62), 2) + let v2 = s:mask1(s:shift(a, -31), 31) + let v3 = s:mask1(a, 31) + return [sign, v1, v2, v3] == a:b._VAL + else + return msgpack#equal(a:b, a:a) + endif + else + throw printf('internal-invalid-type: %s == %s, but special %s /= %s', + \atype, btype, aspecial, bspecial) + endif + endif +endfunction diff --git a/runtime/autoload/shada.vim b/runtime/autoload/shada.vim new file mode 100644 index 0000000000..234f35398b --- /dev/null +++ b/runtime/autoload/shada.vim @@ -0,0 +1,694 @@ +if exists('g:loaded_shada_autoload') + finish +endif +let g:loaded_shada_autoload = 1 + +"" +" If true keep the old header entry when editing existing ShaDa file. +" +" Old header entry will be kept only if it is listed in the opened file. To +" remove old header entry despite of the setting just remove it from the +" listing. Setting it to false makes plugin ignore all header entries. Defaults +" to 1. +let g:shada#keep_old_header = get(g:, 'shada#keep_old_header', 1) + +"" +" If true then first entry will be plugin’s own header entry. +let g:shada#add_own_header = get(g:, 'shada#add_own_header', 1) + +"" +" Dictionary that maps ShaDa types to their names. +let s:SHADA_ENTRY_NAMES = { + \1: 'header', + \2: 'search_pattern', + \3: 'replacement_string', + \4: 'history_entry', + \5: 'register', + \6: 'variable', + \7: 'global_mark', + \8: 'jump', + \9: 'buffer_list', + \10: 'local_mark', + \11: 'change', +\} + +"" +" Dictionary that maps ShaDa names to corresponding types +let s:SHADA_ENTRY_TYPES = {} +call map(copy(s:SHADA_ENTRY_NAMES), + \'extend(s:SHADA_ENTRY_TYPES, {v:val : +v:key})') + +"" +" Map that maps entry names to lists of keys that can be used by this entry. +" Only contains data for entries which are represented as mappings, except for +" the header. +let s:SHADA_MAP_ENTRIES = { + \'search_pattern': ['sp', 'sh', 'ss', 'sm', 'sc', 'sl', 'se', 'so', 'su'], + \'register': ['n', 'rc', 'rw', 'rt'], + \'global_mark': ['n', 'f', 'l', 'c'], + \'local_mark': ['f', 'n', 'l', 'c'], + \'jump': ['f', 'l', 'c'], + \'change': ['f', 'l', 'c'], + \'header': [], +\} + +"" +" Like one of the values from s:SHADA_MAP_ENTRIES, but for a single buffer in +" buffer list entry. +let s:SHADA_BUFFER_LIST_KEYS = ['f', 'l', 'c'] + +"" +" List of possible history types. Maps integer values that represent history +" types to human-readable names. +let s:SHADA_HISTORY_TYPES = ['command', 'search', 'expression', 'input', 'debug'] + +"" +" Map that maps entry names to their descriptions. Only for entries which have +" list as a data type. Description is a list of lists where each entry has item +" description and item type. +let s:SHADA_FIXED_ARRAY_ENTRIES = { + \'replacement_string': [[':s replacement string', 'bin']], + \'history_entry': [ + \['history type', 'histtype'], + \['contents', 'bin'], + \['separator', 'intchar'], + \], + \'variable': [['name', 'bin'], ['value', 'any']], +\} + +"" +" Dictionary that maps enum names to dictionary with enum values. Dictionary +" with enum values maps enum human-readable names to corresponding values. Enums +" are used as type names in s:SHADA_FIXED_ARRAY_ENTRIES and +" s:SHADA_STANDARD_KEYS. +let s:SHADA_ENUMS = { + \'histtype': { + \'CMD': 0, + \'SEARCH': 1, + \'EXPR': 2, + \'INPUT': 3, + \'DEBUG': 4, + \}, + \'regtype': { + \'CHARACTERWISE': 0, + \'LINEWISE': 1, + \'BLOCKWISE': 2, + \} +\} + +"" +" Second argument to msgpack#eval. +let s:SHADA_SPECIAL_OBJS = {} +call map(values(s:SHADA_ENUMS), + \'extend(s:SHADA_SPECIAL_OBJS, map(copy(v:val), "string(v:val)"))') + +"" +" Like s:SHADA_ENUMS, but inner dictionary maps values to names and not names to +" values. +let s:SHADA_REV_ENUMS = map(copy(s:SHADA_ENUMS), '{}') +call map(copy(s:SHADA_ENUMS), + \'map(copy(v:val), ' + \. '"extend(s:SHADA_REV_ENUMS[" . string(v:key) . "], ' + \. '{v:val : v:key})")') + +"" +" Maximum length of ShaDa entry name. Used to arrange entries to the table. +let s:SHADA_MAX_ENTRY_LENGTH = max( + \map(values(s:SHADA_ENTRY_NAMES), 'len(v:val)') + \+ [len('unknown (0x)') + 16]) + +"" +" Object that marks required value. +let s:SHADA_REQUIRED = [] + +"" +" Dictionary that maps default key names to their description. Description is +" a list that contains human-readable hint, key type and default value. +let s:SHADA_STANDARD_KEYS = { + \'sm': ['magic value', 'boolean', g:msgpack#true], + \'sc': ['smartcase value', 'boolean', g:msgpack#false], + \'sl': ['has line offset', 'boolean', g:msgpack#false], + \'se': ['place cursor at end', 'boolean', g:msgpack#false], + \'so': ['offset value', 'integer', 0], + \'su': ['is last used', 'boolean', g:msgpack#true], + \'ss': ['is :s pattern', 'boolean', g:msgpack#false], + \'sh': ['v:hlsearch value', 'boolean', g:msgpack#false], + \'sp': ['pattern', 'bin', s:SHADA_REQUIRED], + \'rt': ['type', 'regtype', s:SHADA_ENUMS.regtype.CHARACTERWISE], + \'rw': ['block width', 'uint', 0], + \'rc': ['contents', 'binarray', s:SHADA_REQUIRED], + \'n': ['name', 'intchar', char2nr('"')], + \'l': ['line number', 'uint', 1], + \'c': ['column', 'uint', 0], + \'f': ['file name', 'bin', s:SHADA_REQUIRED], +\} + +"" +" Set of entry types containing entries which require `n` key. +let s:SHADA_REQUIRES_NAME = {'local_mark': 1, 'global_mark': 1, 'register': 1} + +"" +" Maximum width of human-readable hint. Used to arrange data in table. +let s:SHADA_MAX_HINT_WIDTH = max(map(values(s:SHADA_STANDARD_KEYS), + \'len(v:val[0])')) + +"" +" Default mark name for the cases when it makes sense (i.e. for local marks). +let s:SHADA_DEFAULT_MARK_NAME = '"' + +"" +" Mapping that maps timestamps represented using msgpack#string to strftime +" output. Used by s:shada_strftime. +let s:shada_strftime_cache = {} + +"" +" Mapping that maps strftime output from s:shada_strftime to timestamps. +let s:shada_strptime_cache = {} + +"" +" Time format used for displaying ShaDa files. +let s:SHADA_TIME_FORMAT = '%Y-%m-%dT%H:%M:%S' + +"" +" Wrapper around msgpack#strftime that caches its output. +" +" Format is hardcoded to s:SHADA_TIME_FORMAT. +function s:shada_strftime(timestamp) abort + let key = msgpack#string(a:timestamp) + if has_key(s:shada_strftime_cache, key) + return s:shada_strftime_cache[key] + endif + let val = msgpack#strftime(s:SHADA_TIME_FORMAT, a:timestamp) + let s:shada_strftime_cache[key] = val + let s:shada_strptime_cache[val] = a:timestamp + return val +endfunction + +"" +" Wrapper around msgpack#strftime that uses cache created by s:shada_strftime(). +" +" Also caches its own results. Format is hardcoded to s:SHADA_TIME_FORMAT. +function s:shada_strptime(string) abort + if has_key(s:shada_strptime_cache, a:string) + return s:shada_strptime_cache[a:string] + endif + let ts = msgpack#strptime(s:SHADA_TIME_FORMAT, a:string) + let s:shada_strptime_cache[a:string] = ts + return ts +endfunction + +"" +" Check whether given value matches given type. +" +" @return Zero if value matches, error message string if it does not. +function s:shada_check_type(type, val) abort + let type = msgpack#type(a:val) + if type is# a:type + return 0 + endif + if has_key(s:SHADA_ENUMS, a:type) + let msg = s:shada_check_type('uint', a:val) + if msg isnot 0 + return msg + endif + if !has_key(s:SHADA_REV_ENUMS[a:type], a:val) + let evals_msg = join(map(sort(items(s:SHADA_REV_ENUMS[a:type])), + \'v:val[0] . " (" . v:val[1] . ")"'), ', ') + return 'Unexpected enum value: expected one of ' . evals_msg + endif + return 0 + elseif a:type is# 'uint' + if type isnot# 'integer' + return 'Expected integer' + endif + if !(type(a:val) == type({}) ? a:val._VAL[0] == 1 : a:val >= 0) + return 'Value is negative' + endif + return 0 + elseif a:type is# 'bin' + " Binary string without zero bytes + if type isnot# 'binary' + return 'Expected binary string' + elseif (type(a:val) == type({}) + \&& !empty(filter(copy(a:val._VAL), 'stridx(v:val, "\n") != -1'))) + return 'Expected no NUL bytes' + endif + return 0 + elseif a:type is# 'intchar' + let msg = s:shada_check_type('uint', a:val) + if msg isnot# 0 + return msg + endif + if a:val > 0 || a:val < 1 + endif + return 0 + elseif a:type is# 'binarray' + if type isnot# 'array' + return 'Expected array value' + elseif !empty(filter(copy(type(a:val) == type({}) ? a:val._VAL : a:val), + \'msgpack#type(v:val) isnot# "binary"')) + return 'Expected array of binary strings' + else + for element in (type(a:val) == type({}) ? a:val._VAL : a:val) + if (type(element) == type({}) + \&& !empty(filter(copy(element._VAL), 'stridx(v:val, "\n") != -1'))) + return 'Expected no NUL bytes' + endif + unlet element + endfor + endif + return 0 + elseif a:type is# 'boolean' + return 'Expected boolean' + elseif a:type is# 'integer' + return 'Expected integer' + elseif a:type is# 'any' + return 0 + endif + return 'Internal error: unknown type ' . a:type +endfunction + +"" +" Convert msgpack mapping object to a list of strings for +" s:shada_convert_entry(). +" +" @param[in] map Mapping to convert. +" @param[in] default_keys List of keys which have default value in this +" mapping. +" @param[in] name Name of the converted entry. +function s:shada_convert_map(map, default_keys, name) abort + let ret = [] + let keys = copy(a:default_keys) + call map(sort(keys(a:map)), 'index(keys, v:val) == -1 ? add(keys, v:val) : 0') + let descriptions = map(copy(keys), + \'get(s:SHADA_STANDARD_KEYS, v:val, ["", 0, 0])') + let max_key_len = max(map(copy(keys), 'len(v:val)')) + let max_desc_len = max(map(copy(descriptions), + \'v:val[0] is 0 ? 0 : len(v:val[0])')) + if max_key_len < len('Key') + let max_key_len = len('Key') + endif + let key_header = 'Key' . repeat('_', max_key_len - len('Key')) + if max_desc_len == 0 + call add(ret, printf(' %% %s %s', key_header, 'Value')) + else + if max_desc_len < len('Description') + let max_desc_len = len('Description') + endif + let desc_header = ('Description' + \. repeat('_', max_desc_len - len('Description'))) + call add(ret, printf(' %% %s %s %s', key_header, desc_header, 'Value')) + endif + let i = 0 + for key in keys + let [description, type, default] = descriptions[i] + if a:name isnot# 'local_mark' && key is# 'n' + unlet default + let default = s:SHADA_REQUIRED + endif + let value = get(a:map, key, default) + if (key is# 'n' && !has_key(s:SHADA_REQUIRES_NAME, a:name) + \&& value is# s:SHADA_REQUIRED) + " Do nothing + elseif value is s:SHADA_REQUIRED + call add(ret, ' # Required key missing: ' . key) + elseif max_desc_len == 0 + call add(ret, printf(' + %-*s %s', + \max_key_len, key, + \msgpack#string(value))) + else + if type isnot 0 && value isnot# default + let msg = s:shada_check_type(type, value) + if msg isnot 0 + call add(ret, ' # ' . msg) + endif + endif + let strval = s:shada_string(type, value) + if msgpack#type(value) is# 'array' && msg is 0 + let shift = 2 + 2 + max_key_len + 2 + max_desc_len + 2 + " Value: 1 2 3 4 5 6: + " " + Key Description Value" + " 1122333445555555555566 + if shift + strdisplaywidth(strval, shift) > 80 + let strval = '@' + endif + endif + call add(ret, printf(' + %-*s %-*s %s', + \max_key_len, key, + \max_desc_len, description, + \strval)) + if strval is '@' + for v in value + call add(ret, printf(' | - %s', msgpack#string(v))) + unlet v + endfor + endif + endif + let i += 1 + unlet value + unlet default + endfor + return ret +endfunction + +"" +" Wrapper around msgpack#string() which may return string from s:SHADA_REV_ENUMS +function s:shada_string(type, v) abort + if (has_key(s:SHADA_ENUMS, a:type) && type(a:v) == type(0) + \&& has_key(s:SHADA_REV_ENUMS[a:type], a:v)) + return s:SHADA_REV_ENUMS[a:type][a:v] + elseif (a:type is# 'intchar' && type(a:v) == type(0) + \&& strtrans(nr2char(a:v)) is# nr2char(a:v)) + return "'" . nr2char(a:v) . "'" + else + return msgpack#string(a:v) + endif +endfunction + +"" +" Evaluate string obtained by s:shada_string(). +function s:shada_eval(s) abort + return msgpack#eval(a:s, s:SHADA_SPECIAL_OBJS) +endfunction + +"" +" Convert one ShaDa entry to a list of strings suitable for setline(). +" +" Returned format looks like this: +" +" TODO +function s:shada_convert_entry(entry) abort + if type(a:entry.type) == type({}) + " |msgpack-special-dict| may only be used if value does not fit into the + " default integer type. All known entry types do fit, so it is definitely + " unknown entry. + let name = 'unknown_(' . msgpack#int_dict_to_str(a:entry.type) . ')' + else + let name = get(s:SHADA_ENTRY_NAMES, a:entry.type, 0) + if name is 0 + let name = printf('unknown_(0x%x)', a:entry.type) + endif + endif + let title = toupper(name[0]) . tr(name[1:], '_', ' ') + let header = printf('%s with timestamp %s:', title, + \s:shada_strftime(a:entry.timestamp)) + let ret = [header] + if name[:8] is# 'unknown_(' && name[-1:] is# ')' + call add(ret, ' = ' . msgpack#string(a:entry.data)) + elseif has_key(s:SHADA_FIXED_ARRAY_ENTRIES, name) + if type(a:entry.data) != type([]) + call add(ret, printf(' # Unexpected type: %s instead of array', + \msgpack#type(a:entry.data))) + call add(ret, ' = ' . msgpack#string(a:entry.data)) + return ret + endif + let i = 0 + let max_desc_len = max(map(copy(s:SHADA_FIXED_ARRAY_ENTRIES[name]), + \'len(v:val[0])')) + if max_desc_len < len('Description') + let max_desc_len = len('Description') + endif + let desc_header = ('Description' + \. repeat('_', max_desc_len - len('Description'))) + call add(ret, printf(' @ %s %s', desc_header, 'Value')) + for value in a:entry.data + let [desc, type] = get(s:SHADA_FIXED_ARRAY_ENTRIES[name], i, ['', 0]) + if (i == 2 && name is# 'history_entry' + \&& a:entry.data[0] isnot# s:SHADA_ENUMS.histtype.SEARCH) + let [desc, type] = ['', 0] + endif + if type isnot 0 + let msg = s:shada_check_type(type, value) + if msg isnot 0 + call add(ret, ' # ' . msg) + endif + endif + call add(ret, printf(' - %-*s %s', max_desc_len, desc, + \s:shada_string(type, value))) + let i += 1 + unlet value + endfor + if (len(a:entry.data) < len(s:SHADA_FIXED_ARRAY_ENTRIES[name]) + \&& !(name is# 'history_entry' + \&& len(a:entry.data) == 2 + \&& a:entry.data[0] isnot# s:SHADA_ENUMS.histtype.SEARCH)) + call add(ret, ' # Expected more elements in list') + endif + elseif has_key(s:SHADA_MAP_ENTRIES, name) + if type(a:entry.data) != type({}) + call add(ret, printf(' # Unexpected type: %s instead of map', + \msgpack#type(a:entry.data))) + call add(ret, ' = ' . msgpack#string(a:entry.data)) + return ret + endif + if msgpack#special_type(a:entry.data) isnot 0 + call add(ret, ' # Entry is a special dict which is unexpected') + call add(ret, ' = ' . msgpack#string(a:entry.data)) + return ret + endif + let ret += s:shada_convert_map(a:entry.data, s:SHADA_MAP_ENTRIES[name], + \name) + elseif name is# 'buffer_list' + if type(a:entry.data) != type([]) + call add(ret, printf(' # Unexpected type: %s instead of array', + \msgpack#type(a:entry.data))) + call add(ret, ' = ' . msgpack#string(a:entry.data)) + return ret + elseif !empty(filter(copy(a:entry.data), + \'type(v:val) != type({}) ' + \. '|| msgpack#special_type(v:val) isnot 0')) + call add(ret, ' # Expected array of maps') + call add(ret, ' = ' . msgpack#string(a:entry.data)) + return ret + endif + for bufdef in a:entry.data + if bufdef isnot a:entry.data[0] + call add(ret, '') + endif + let ret += s:shada_convert_map(bufdef, s:SHADA_BUFFER_LIST_KEYS, name) + endfor + else + throw 'internal-unknown-type:Internal error: unknown type name: ' . name + endif + return ret +endfunction + +"" +" Order of msgpack objects in one ShaDa entry. Each item in the list is name of +" the key in dictionaries returned by shada#read(). +let s:SHADA_ENTRY_OBJECT_SEQUENCE = ['type', 'timestamp', 'length', 'data'] + +"" +" Convert list returned by msgpackparse() to a list of ShaDa objects +" +" @param[in] mpack List of VimL objects returned by msgpackparse(). +" +" @return List of dictionaries with keys type, timestamp, length and data. Each +" dictionary describes one ShaDa entry. +function shada#mpack_to_sd(mpack) abort + let ret = [] + let i = 0 + for element in a:mpack + let key = s:SHADA_ENTRY_OBJECT_SEQUENCE[ + \i % len(s:SHADA_ENTRY_OBJECT_SEQUENCE)] + if key is# 'type' + call add(ret, {}) + endif + let ret[-1][key] = element + if key isnot# 'data' + if !msgpack#is_uint(element) + throw printf('not-uint:Entry %i has %s element '. + \'which is not an unsigned integer', + \len(ret), key) + endif + if key is# 'type' && msgpack#equal(element, 0) + throw printf('zero-uint:Entry %i has %s element '. + \'which is zero', + \len(ret), key) + endif + endif + let i += 1 + unlet element + endfor + return ret +endfunction + +"" +" Convert read ShaDa file to a list of lines suitable for setline() +" +" @param[in] shada List of ShaDa entries like returned by shada#mpack_to_sd(). +" +" @return List of strings suitable for setline()-like functions. +function shada#sd_to_strings(shada) abort + let ret = [] + for entry in a:shada + let ret += s:shada_convert_entry(entry) + endfor + return ret +endfunction + +"" +" Convert a readfile()-like list of strings to a list of lines suitable for +" setline(). +" +" @param[in] binstrings List of strings to convert. +" +" @return List of lines. +function shada#get_strings(binstrings) abort + return shada#sd_to_strings(shada#mpack_to_sd(msgpackparse(a:binstrings))) +endfunction + +"" +" Convert s:shada_convert_entry() output to original entry. +function s:shada_convert_strings(strings) abort + let strings = copy(a:strings) + let match = matchlist( + \strings[0], + \'\v\C^(.{-})\m with timestamp \(\d\{4}-\d\d-\d\dT\d\d:\d\d:\d\d\):$') + if empty(match) + throw 'invalid-header:Header has invalid format: ' . strings[0] + endif + call remove(strings, 0) + let title = match[1] + let name = tolower(title[0]) . tr(title[1:], ' ', '_') + let ret = {} + let empty_default = g:msgpack#nil + if name[:8] is# 'unknown_(' && name[-1:] is# ')' + let ret.type = +name[9:-2] + elseif has_key(s:SHADA_ENTRY_TYPES, name) + let ret.type = s:SHADA_ENTRY_TYPES[name] + if has_key(s:SHADA_MAP_ENTRIES, name) + unlet empty_default + let empty_default = {} + elseif has_key(s:SHADA_FIXED_ARRAY_ENTRIES, name) || name is# 'buffer_list' + unlet empty_default + let empty_default = [] + endif + else + throw 'invalid-type:Unknown type ' . name + endif + let ret.timestamp = s:shada_strptime(match[2]) + if empty(strings) + let ret.data = empty_default + else + while !empty(strings) + if strings[0][2] is# '=' + let data = s:shada_eval(strings[0][4:]) + call remove(strings, 0) + elseif strings[0][2] is# '%' + if name is# 'buffer_list' && !has_key(ret, 'data') + let ret.data = [] + endif + let match = matchlist( + \strings[0], + \'\m\C^ % \(Key_*\)\( Description_*\)\? Value') + if empty(match) + throw 'invalid-map-header:Invalid mapping header: ' . strings[0] + endif + call remove(strings, 0) + let key_len = len(match[1]) + let desc_skip_len = len(match[2]) + let data = {'_TYPE': v:msgpack_types.map, '_VAL': []} + while !empty(strings) && strings[0][2] is# '+' + let line = remove(strings, 0)[4:] + let key = substitute(line[:key_len - 1], '\v\C\ *$', '', '') + let strval = line[key_len + desc_skip_len + 2:] + if strval is# '@' + let val = [] + while !empty(strings) && strings[0][2] is# '|' + if strings[0][4] isnot# '-' + throw ('invalid-array:Expected hyphen-minus at column 5: ' + \. strings) + endif + call add(val, s:shada_eval(remove(strings, 0)[5:])) + endwhile + else + let val = s:shada_eval(strval) + endif + if (has_key(s:SHADA_STANDARD_KEYS, key) + \&& s:SHADA_STANDARD_KEYS[key][2] isnot# s:SHADA_REQUIRED + \&& msgpack#equal(s:SHADA_STANDARD_KEYS[key][2], val)) + unlet val + continue + endif + call add(data._VAL, [{'_TYPE': v:msgpack_types.string, '_VAL': [key]}, + \val]) + unlet val + endwhile + elseif strings[0][2] is# '@' + let match = matchlist( + \strings[0], + \'\m\C^ @ \(Description_* \)\?Value') + if empty(match) + throw 'invalid-array-header:Invalid array header: ' . strings[0] + endif + call remove(strings, 0) + let desc_skip_len = len(match[1]) + let data = [] + while !empty(strings) && strings[0][2] is# '-' + let val = remove(strings, 0)[4 + desc_skip_len :] + call add(data, s:shada_eval(val)) + endwhile + else + throw 'invalid-line:Unrecognized line: ' . strings[0] + endif + if !has_key(ret, 'data') + let ret.data = data + elseif type(ret.data) == type([]) + call add(ret.data, data) + else + let ret.data = [ret.data, data] + endif + unlet data + endwhile + endif + let ret._data = msgpackdump([ret.data]) + let ret.length = len(ret._data) - 1 + for s in ret._data + let ret.length += len(s) + endfor + return ret +endfunction + +"" +" Convert s:shada_sd_to_strings() output to a list of original entries. +function shada#strings_to_sd(strings) abort + let strings = filter(copy(a:strings), 'v:val !~# ''\v^\s*%(\#|$)''') + let stringss = [] + for string in strings + if string[0] isnot# ' ' + call add(stringss, []) + endif + call add(stringss[-1], string) + endfor + return map(copy(stringss), 's:shada_convert_strings(v:val)') +endfunction + +"" +" Convert a list of strings to list of strings suitable for writefile(). +function shada#get_binstrings(strings) abort + let entries = shada#strings_to_sd(a:strings) + if !g:shada#keep_old_header + call filter(entries, 'v:val.type != ' . s:SHADA_ENTRY_TYPES.header) + endif + if g:shada#add_own_header + let data = {'version': v:version, 'generator': 'shada.vim'} + let dumped_data = msgpackdump([data]) + let length = len(dumped_data) - 1 + for s in dumped_data + let length += len(s) + endfor + call insert(entries, { + \'type': s:SHADA_ENTRY_TYPES.header, + \'timestamp': localtime(), + \'length': length, + \'data': data, + \'_data': dumped_data, + \}) + endif + let mpack = [] + for entry in entries + let mpack += map(copy(s:SHADA_ENTRY_OBJECT_SEQUENCE), 'entry[v:val]') + endfor + return msgpackdump(mpack) +endfunction |