utils/sprintf.js

  1. /*
  2.  * This file is part of AUX.
  3.  *
  4.  * AUX is free software; you can redistribute it and/or
  5.  * modify it under the terms of the GNU General Public
  6.  * License as published by the Free Software Foundation; either
  7.  * version 3 of the License, or (at your option) any later version.
  8.  *
  9.  * AUX is distributed in the hope that it will be useful,
  10.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  12.  * General Public License for more details.
  13.  *
  14.  * You should have received a copy of the GNU General
  15.  * Public License along with this program; if not, write to the
  16.  * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  17.  * Boston, MA  02110-1301  USA
  18.  */
  20. /**
  21.  * Module containing sprintf like formatting functions.
  22.  *
  23.  * @module utils/sprintf
  24.  */
  26. /**
  27.  * Generates formatting functions from sprintf-style format strings.
  28.  * This is generally faster when the same format string is used many times.
  29.  *
  30.  * @returns {function} A formatting function.
  31.  * @param {string} fmt - The format string.
  32.  * @function FORMAT
  33.  * @example
  34.  * var f = FORMAT("%.2f Hz");
  35.  * @see sprintf
  36.  */
  37. function round(num, precision) {
  38.   const base = Math.pow(10, precision);
  39.   return (Math.round(num * base) / base).toFixed(precision);
  40. }
  41. const fun =
  42.   'function round(num, precision) { \n\
  43.   var base = 10 ** precision; \n\
  44.   return (Math.round(num * base) / base).toFixed(precision);\n\
  45. };';
  46. export function FORMAT(fmt) {
  47.   const args = [];
  48.   let s = fun + ' return ';
  49.   let res;
  50.   let last = 0;
  51.   let argnum = 0;
  52.   let precision;
  53.   const regexp = /%(\.\d+)?([bcdefgosO%])/g;
  54.   let argname;
  56.   while ((res = regexp.exec(fmt))) {
  57.     if (argnum) s += '+';
  58.     s += JSON.stringify(fmt.substring(last, regexp.lastIndex - res[0].length));
  59.     s += '+';
  60.     argname = 'a' + argnum;
  61.     if (args.indexOf(argname) === -1) args.push(argname);
  62.     if (argnum + 1 < arguments.length) {
  63.       argname =
  64.         '(' + sprintf(arguments[argnum + 1].replace('%', '%s'), argname) + ')';
  65.     }
  66.     switch (res[2].charCodeAt(0)) {
  67.       case 100: // d
  68.         s += '(' + argname + ' | 0)';
  69.         break;
  70.       case 102: // f
  71.         if (res[1]) {
  72.           // length qualifier
  73.           precision = parseInt(res[1].substring(1));
  74.           s += 'round(+' + argname + ', ' + precision + ')';
  75.         } else {
  76.           s += '(+' + argname + ')';
  77.         }
  78.         break;
  79.       case 115: // s
  80.         s += argname;
  81.         break;
  82.       case 37:
  83.         s += '"%"';
  84.         argnum--;
  85.         break;
  86.       case 79:
  87.       case 111:
  88.         s += 'JSON.stringify(' + argname + ')';
  89.         break;
  90.       default:
  91.         throw new Error('unknown format:' + res[0]);
  92.     }
  93.     argnum++;
  94.     last = regexp.lastIndex;
  95.   }
  97.   if (argnum) s += '+';
  98.   s += JSON.stringify(fmt.substring(last));
  99.   /* jshint -W054 */
  100.   return new Function(args, s);
  101. }
  103. /**
  104.  * Formats the arguments according to a given format string.
  105.  * @returns {function} A formatting function.
  106.  * @param {string} fmt - The format string.
  107.  * @param {...*} args - The format arguments.
  108.  * @function sprintf
  109.  * @example
  110.  * sprintf("%d Hz", 440);
  111.  * @see FORMAT
  112.  */
  113. export function sprintf(fmt) {
  114.   let i, last_fmt;
  115.   let c,
  116.     arg_num = 1;
  117.   const ret = [];
  118.   let precision, s;
  119.   let has_precision = false;
  121.   for (
  122.     last_fmt = 0;
  123.     -1 !== (i = fmt.indexOf('%', last_fmt));
  124.     last_fmt = i + 1
  125.   ) {
  126.     if (last_fmt < i) {
  127.       ret.push(fmt.substring(last_fmt, i));
  128.     }
  130.     i++;
  132.     if ((has_precision = fmt.charCodeAt(i) === 46) /* '.' */) {
  133.       i++;
  134.       precision = parseInt(fmt.substring(i));
  135.       while ((c = fmt.charCodeAt(i)) >= 48 && c <= 57) i++;
  136.     }
  138.     c = fmt.charCodeAt(i);
  140.     if (c === 37) {
  141.       ret.push('%');
  142.       continue;
  143.     }
  145.     s = arguments[arg_num++];
  147.     switch (fmt.charCodeAt(i)) {
  148.       case 102 /* f */:
  149.         s = +s;
  150.         if (has_precision) {
  151.           s = round(s, precision);
  152.         }
  153.         break;
  154.       case 100 /* d */:
  155.         s = s | 0;
  156.         break;
  157.       case 115 /* s */:
  158.         break;
  159.       case 79: /* O */
  160.       case 111 /* o */:
  161.         s = JSON.stringify(s);
  162.         break;
  163.       default:
  164.         throw new Error('Unsupported format.');
  165.     }
  167.     ret.push(s);
  169.     last_fmt = i + 1;
  170.   }
  172.   if (last_fmt < fmt.length) {
  173.     ret.push(fmt.substring(last_fmt, fmt.length));
  174.   }
  176.   return ret.join('');
  177. }