@vbarbarosh/node-helpers 3.66.0 → 3.67.0

package/src/fcmpx.js

@@ -0,0 +1,120 @@
+const fcmp_default = require('./fcmp_default');
+const fcmp_default_desc = require('./fcmp_default_desc');
+const identity = require('./identity');
+
+const MISSING = Symbol('fcmpx.missing');
+
+/**
+ * Comparator builder using compact expressions.
+ *
+ * fcmp expression — Creates an `fcmp` function from an expression, suitable for use with `[].sort()`.
+ *
+ * fcmpx('user.email')
+ * fcmpx('-user.age,user.email')
+ * fcmpx(v => v.user.email)
+ * fcmpx(['user.age', 'user.email'])
+ * fcmpx(['-user.age', 'user.email'])
+ */
+function fcmpx(expr)
+{
+    if (typeof expr === 'string') {
+        if (expr.includes(',')) {
+            return fcmpx(expr.split(','));
+        }
+        return fcmpx_compile(expr);
+    }
+    if (!Array.isArray(expr)) {
+        return fcmpx_compile(expr);
+    }
+    const fcmp_items = expr.map(fcmpx_parse);
+    return function (a, b) {
+        const tuple1 = fcmp_items.map(v => v.read(a));
+        const tuple2 = fcmp_items.map(v => v.read(b));
+        for (let i = 0; i < fcmp_items.length; ++i) {
+            const tmp = fcmp_items[i].fcmp(tuple1[i], tuple2[i]);
+            if (tmp) {
+                return tmp;
+            }
+        }
+        return 0;
+    };
+}
+
+function fcmpx_compile(expr)
+{
+    const {read, fcmp} = fcmpx_parse(expr);
+    return function (a, b) {
+        return fcmp(read(a), read(b));
+    };
+}
+
+function fcmpx_parse(expr)
+{
+    if (typeof expr === 'function') {
+        return {read: fcmpx_compile_read(expr), fcmp: fcmp_wrapper(fcmp_default)};
+    }
+    if (typeof expr === 'string') {
+        const desc = expr.startsWith('-');
+        const read = desc ? fcmpx_compile_read(expr.slice(1)) : fcmpx_compile_read(expr);
+        const fcmp = fcmp_wrapper(desc ? fcmp_default_desc : fcmp_default);
+        return {read, fcmp};
+    }
+    const fcmp_user = expr.fcmp;
+    const read = fcmpx_compile_read(expr.read);
+    const desc = expr.desc ?? false;
+    const fcmp = fcmp_wrapper(desc ? (fcmp_user ? (b, a) => fcmp_user(a, b) : fcmp_default_desc) : (fcmp_user ?? fcmp_default));
+    if (Array.isArray(expr.top)) {
+        const priority = new Map(expr.top.map((v, i) => [v, i]));
+        return {read: v => priority.get(read(v)) ?? priority.size, fcmp};
+    }
+    if (Array.isArray(expr.bottom)) {
+        const priority = new Map(expr.bottom.map((v, i) => [v, i]));
+        return {read: v => priority.get(read(v)) ?? -1, fcmp};
+    }
+    return {read, fcmp};
+}
+
+function fcmpx_compile_read(read)
+{
+    if (read === undefined || read === '' || read === '.') {
+        return identity;
+    }
+    if (typeof read === 'function') {
+        return function (value) {
+            return read(value) ?? MISSING;
+        };
+    }
+    if (typeof read === 'string') {
+        const props = read.split('.');
+        const [a, b, c, d, e] = props;
+        switch (props.length) {
+        case 1: return v => v?.[a] ?? MISSING;
+        case 2: return v => v?.[a]?.[b] ?? MISSING;
+        case 3: return v => v?.[a]?.[b]?.[c] ?? MISSING;
+        case 4: return v => v?.[a]?.[b]?.[c]?.[d] ?? MISSING;
+        case 5: return v => v?.[a]?.[b]?.[c]?.[d]?.[e] ?? MISSING;
+        default: return v => props.reduce((a,p) => a?.[p], v) ?? MISSING;
+        }
+    }
+    return v => v?.[read] ?? MISSING;
+}
+
+// Sorting rule: Missing values are considered greater than any defined value
+// and are therefore placed after all defined values.
+function fcmp_wrapper(fcmp)
+{
+    return function (a, b) {
+        if (a === MISSING) {
+            if (b === MISSING) {
+                return 0;
+            }
+            return 1;
+        }
+        if (b === MISSING) {
+            return -1;
+        }
+        return fcmp(a, b);
+    };
+}
+
+module.exports = fcmpx;

package/src/fcmpx.test.js

@@ -0,0 +1,158 @@
+const assert = require('assert');
+const fcmpx = require('./fcmpx');
+
+const users = [
+    {id: 'fred|48|100', user: {name: 'fred', age: 48, balance: 100}},
+    {id: 'barney|36|-200', user: {name: 'barney', age: 36, balance: -200}},
+    {id: 'wilma|-|-', user: {name: 'wilma', tag: {short: 'foo', long: 'foofoo'}}},
+    {id: 'betty|32|-', user: {name: 'betty', tag: {short: 'bar', long: 'barbar'}, age: 32}},
+];
+
+const tests = [
+    {
+        description: 'missing: should move undefined values to the bottom',
+        items: [
+            {id: 'user1', user: {age: 48}},
+            {id: 'user2', user: {age: 36}},
+            {id: 'user3'},
+            {id: 'user4', user: {age: 32}},
+        ],
+        extract: v => v.id,
+        expressions: [
+            'user.age',
+            v => v.user?.age,
+            {read: 'user.age'},
+            {read: v => v.user?.age},
+            ['user.age'],
+            [v => v.user?.age],
+            [{read: 'user.age'}],
+            [{read: v => v.user?.age}],
+        ],
+        expected: ['user4', 'user2', 'user1', 'user3'],
+    },
+    {
+        description: 'missing: should move undefined values to the bottom #2',
+        items: [
+            {id: 'user1', user: {age: 48}},
+            {id: 'user2', user: {age: 36}},
+            {id: 'user3', user: {tag: {short: 'foo'}}},
+            {id: 'user4', user: {tag: {short: 'bar'}, age: 32}},
+        ],
+        extract: v => v.id,
+        expressions: [
+            'user.age,user.tag.short',
+            ['user.age', 'user.tag.short'],
+            [v => v.user.age, v => v.user.tag?.short],
+            [{read: 'user.age'}, {read: 'user.tag.short'}],
+            [{read: v => v.user.age}, {read: v => v.user.tag?.short}],
+        ],
+        expected: ['user4', 'user2', 'user1', 'user3'],
+    },
+    {
+        description: 'missing: should move undefined values to the bottom and keep their initial order',
+        items: [
+            {id: 'user1', user: {balance: 100}},
+            {id: 'user2', user: {balance: -200}},
+            {id: 'user3'},
+            {id: 'user4'},
+        ],
+        extract: v => v.id,
+        expressions: [
+            'user.balance',
+            v => v.user?.balance,
+            [v => v.user?.balance],
+        ],
+        expected: ['user2', 'user1', 'user3', 'user4'],
+    },
+    {
+        description: 'move undefined value to the bottom, keep their initial order',
+        items: users,
+        extract: v => v.id,
+        expressions: [
+            'user.balance,user.age',
+            [v => v.user.balance, v => v.user.age],
+        ],
+        expected: ['barney|36|-200', 'fred|48|100', 'betty|32|-', 'wilma|-|-'],
+    },
+    {
+        description: 'move undefined value to the bottom, keep their initial order',
+        items: users,
+        extract: v => v.id,
+        expressions: [
+            'user.balance,user.age',
+            [v => v.user.balance, v => v.user.age],
+        ],
+        expected: ['barney|36|-200', 'fred|48|100', 'betty|32|-', 'wilma|-|-'],
+    },
+    {
+        description: 'user.tag.short',
+        items: [
+            {user: {name: 'fred', age: 48}},
+            {user: {name: 'barney', age: 36}},
+            {user: {name: 'wilma', tag: {short: 'foo'}}},
+            {user: {name: 'betty', tag: {short: 'bar'}, age: 32}},
+        ],
+        extract: v => `${v.user.name}|${v.user.tag?.short ?? '-'}`,
+        expressions: [
+            'user.tag.short',
+            v => v.user.tag?.short,
+            [v => v.user.tag?.short],
+        ],
+        expected: ['betty|bar', 'wilma|foo', 'fred|-', 'barney|-'],
+    },
+    {
+        description: 'user.tag.short,user.age',
+        items: [
+            {user: {name: 'fred', age: 48}},
+            {user: {name: 'barney', age: 36}},
+            {user: {name: 'wilma', tag: {short: 'foo'}}},
+            {user: {name: 'betty', tag: {short: 'bar'}, age: 32}},
+        ],
+        extract: v => `${v.user.name}|${v.user.tag?.short ?? ''}|${v.user.age ?? ''}`,
+        expressions: [
+            'user.tag.short,user.age',
+            ['user.tag.short', 'user.age'],
+            [v => v.user.tag?.short, v => v.user.age],
+        ],
+        expected: ['betty|bar|32', 'wilma|foo|', 'barney||36', 'fred||48'],
+    },
+    {
+        description: 'top: move specified values to the top',
+        items: [
+            {id: 'task1', priority: 'normal'},
+            {id: 'task2', priority: 'low'},
+            {id: 'task3', priority: 'high'},
+            {id: 'task4', priority: 'normal'},
+        ],
+        extract: v => `${v.id}:${v.priority}`,
+        expressions: [
+            {read: 'priority', top: ['high']},
+        ],
+        expected: ['task3:high', 'task1:normal', 'task2:low', 'task4:normal'],
+    },
+    {
+        description: 'top: move specified values to the top #2',
+        items: [
+            {id: 'task1', priority: 'normal'},
+            {id: 'task2', priority: 'low'},
+            {id: 'task3', priority: 'high'},
+            {id: 'task4', priority: 'normal'},
+        ],
+        extract: v => `${v.id}:${v.priority}`,
+        expressions: [
+            {read: 'priority', top: ['high', 'normal', 'low']},
+        ],
+        expected: ['task3:high', 'task1:normal', 'task4:normal', 'task2:low'],
+    },
+];
+
+describe('fcmpx', function () {
+    tests.forEach(function (test) {
+        test.expressions.forEach(function (expr, i) {
+            it(`${test.description}: #${i+1} | ${test.description}`, function () {
+                const actual = test.items.slice().sort(fcmpx(expr)).map(test.extract);
+                assert.deepStrictEqual(actual, test.expected);
+            });
+        });
+    });
+});

package/src/format_date_fs.js

@@ -0,0 +1,13 @@
+function format_date_fs(d)
+{
+    const ymd = d.getFullYear() + dd(d.getMonth() + 1) + dd(d.getDate());
+    const hms = dd(d.getHours()) + dd(d.getMinutes()) + dd(d.getSeconds());
+    return ymd + '_' + hms;
+}
+
+function dd(v)
+{
+    return v > 9 ? `${v}` : `0${v}`;
+}
+
+module.exports = format_date_fs;

package/src/format_date_human.js

@@ -0,0 +1,13 @@
+function format_date_human(d)
+{
+    const ymd = d.getFullYear() + '/' + dd(d.getMonth() + 1) + '/' + dd(d.getDate());
+    const hms = dd(d.getHours()) + ':' + dd(d.getMinutes()) + ':' + dd(d.getSeconds());
+    return ymd + ' ' + hms;
+}
+
+function dd(v)
+{
+    return v > 9 ? `${v}` : `0${v}`;
+}
+
+module.exports = format_date_human;

package/src/format_progress_bytes.js

@@ -1,22 +1,22 @@
 const format_bytes = require('./format_bytes');
 const format_percents = require('./format_percents');
 const format_seconds = require('./format_seconds');
-const is_number_gt = require('@vbarbarosh/type-helpers/src/is_number_gt');
+const is_num_gt = require('@vbarbarosh/type-helpers/src/is_num_gt');
 
 function format_progress_bytes({percents, total, done, rate, eta, duration})
 {
-    const bps = is_number_gt(rate, 0) ? `${format_bytes(rate)}/s` : '~';
+    const bps = is_num_gt(rate, 0) ? `${format_bytes(rate)}/s` : '~';
     if (done > total) {
         return `${format_bytes(done)} at ${bps} duration=${format_seconds(duration)}`;
     }
-    if (is_number_gt(total, 0)) {
-        const eta_str = is_number_gt(eta, 0) ? format_seconds(eta) : '~';
+    if (is_num_gt(total, 0)) {
+        const eta_str = is_num_gt(eta, 0) ? format_seconds(eta) : '~';
         return `${format_percents(percents)} | ${format_bytes(done)} of ${format_bytes(total)} at ${bps} ETA ${eta_str} duration=${format_seconds(duration)}`;
     }
-    if (is_number_gt(done, 0)) {
+    if (is_num_gt(done, 0)) {
         return `${format_bytes(done)} of ~ at ${bps} duration=${format_seconds(duration)}`;
     }
-    if (is_number_gt(duration, 0)) {
+    if (is_num_gt(duration, 0)) {
         return `~ duration=${format_seconds(duration)}`;
     }
     return '~';

package/src/format_progress_kilo.js

@@ -1,22 +1,22 @@
 const format_kilo = require('./format_kilo');
 const format_percents = require('./format_percents');
 const format_seconds = require('./format_seconds');
-const is_number_gt = require('@vbarbarosh/type-helpers/src/is_number_gt');
+const is_num_gt = require('@vbarbarosh/type-helpers/src/is_num_gt');
 
 function format_progress_kilo({percents, total, done, rate, eta, duration})
 {
-    const speed = is_number_gt(rate, 0) ? `${format_kilo(rate)}/s` : '~';
+    const speed = is_num_gt(rate, 0) ? `${format_kilo(rate)}/s` : '~';
     if (done > total) {
         return `${format_kilo(done)} at ${speed} duration=${format_seconds(duration)}`;
     }
-    if (is_number_gt(total, 0)) {
-        const eta_str = is_number_gt(eta, 0) ? format_seconds(eta) : '~';
+    if (is_num_gt(total, 0)) {
+        const eta_str = is_num_gt(eta, 0) ? format_seconds(eta) : '~';
         return `${format_percents(percents)} | ${format_kilo(done)} of ${format_kilo(total)} at ${speed} ETA ${eta_str} duration=${format_seconds(duration)}`;
     }
-    if (is_number_gt(done, 0)) {
+    if (is_num_gt(done, 0)) {
         return `${format_kilo(done)} of ~ at ${speed} duration=${format_seconds(duration)}`;
     }
-    if (is_number_gt(duration, 0)) {
+    if (is_num_gt(duration, 0)) {
         return `~ duration=${format_seconds(duration)}`;
     }
     return '~';

package/src/fs_list.js

@@ -0,0 +1,16 @@
+const Promise = require('bluebird');
+const fs_fi = require('./fs_fi');
+const fs_path_join = require('./fs_path_join');
+const fs_readdir = require('./fs_readdir');
+
+async function fs_list(pathname = '.')
+{
+    const fi = await fs_fi(pathname);
+    if (fi.isDirectory()) {
+        const names = await fs_readdir(pathname);
+        return Promise.all(names.map(v => fs_fi(fs_path_join(pathname, v))));
+    }
+    return [fi];
+}
+
+module.exports = fs_list;

package/src/fs_list_deep.js

@@ -0,0 +1,20 @@
+const fs_fi = require('./fs_fi');
+const fs_path_join = require('./fs_path_join');
+const fs_readdir = require('./fs_readdir');
+
+async function fs_list_deep(path = '.')
+{
+    const out = [];
+    const queue = [path];
+    while (queue.length) {
+        const fi = await fs_fi(queue.pop());
+        out.push(fi);
+        if (fi.isDirectory()) {
+            const names = await fs_readdir(fi.pathname);
+            queue.push(...names.map(v => fs_path_join(fi.pathname, v)));
+        }
+    }
+    return out;
+}
+
+module.exports = fs_list_deep;

package/src/fs_ls.js

@@ -3,6 +3,9 @@ const fs_fi = require('./fs_fi');
 const fs_path_join = require('./fs_path_join');
 const fs_readdir = require('./fs_readdir');
 
+/**
+ * @deprecated Deprecated in favor or fs_list
+ */
 async function fs_ls(pathname = '.')
 {
     const fi = await fs_fi(pathname);

package/src/fs_path_extname.js

@@ -0,0 +1,14 @@
+const path = require('path');
+
+function fs_path_extname(p)
+{
+    return path.extname(p);
+}
+
+// function extname(s)
+// {
+//     const i = s.lastIndexOf('.');
+//     return (i > 0) ? s.slice(i) : null;
+// }
+
+module.exports = fs_path_extname;

package/src/fs_path_extname.test.js

@@ -0,0 +1,22 @@
+const assert = require('assert');
+const fs_path_extname = require('./fs_path_extname');
+
+const tests = [
+    ['.', ''],
+    ['..', ''],
+    ['.foo', ''],
+    ['..foo', '.foo'],
+    ['.foo.bar', '.bar'],
+    ['fs_path_extname.js', '.js'],
+    ['/path/to/file.js', '.js'],
+    ['/path/to/file.js/foo', ''],
+];
+
+describe('fs_path_extname', function () {
+    tests.forEach(function ([input, expected]) {
+        it(`${input} -> ${expected}`, function () {
+            const actual = fs_path_extname(input);
+            assert.strictEqual(actual, expected);
+        });
+    });
+});

package/src/now_fs.js

@@ -0,0 +1,8 @@
+const format_date_fs = require('./format_date_fs');
+
+function now_fs()
+{
+    return format_date_fs(new Date());
+}
+
+module.exports = now_fs;

package/src/now_human.js

@@ -0,0 +1,8 @@
+const format_date_human = require('./format_date_human');
+
+function now_human()
+{
+    return format_date_human(new Date());
+}
+
+module.exports = now_human;

package/src/parallel.js

@@ -1,7 +1,7 @@
 const NotImplemented = require('./errors/NotImplemented');
 const Promise = require('bluebird');
-const is_async_function = require('@vbarbarosh/type-helpers/src/is_async_function');
-const is_async_generator = require('@vbarbarosh/type-helpers/src/is_async_generator');
+const is_fn_async = require('@vbarbarosh/type-helpers/src/is_fn_async');
+const is_fn_gen_async = require('@vbarbarosh/type-helpers/src/is_fn_gen_async');
 
 /**
  * - Run until `spawn` return `null`.
@@ -12,7 +12,7 @@ const is_async_generator = require('@vbarbarosh/type-helpers/src/is_async_genera
  */
 async function parallel({concurrency, spawn, progress})
 {
-    if (is_async_function(spawn) || is_async_generator(spawn)) {
+    if (is_fn_async(spawn) || is_fn_gen_async(spawn)) {
         throw new Error('[spawn] should not be async function. Instead, it should be a simple function returning either [null] or a [promise].');
     }
     const running = [];

package/src/pid_exists.js

@@ -0,0 +1,12 @@
+function pid_exists(pid)
+{
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+
+module.exports = pid_exists;

package/src/pid_kill_grace.js

@@ -0,0 +1,28 @@
+const Promise = require('bluebird');
+const format_thousands = require('./format_thousands');
+const ignore = require('./ignore');
+const pid_exists = require('./pid_exists');
+
+async function pid_kill_grace(pid, {grace_timeout_ms = 5000, log = ignore} = {})
+{
+    log('Sending SIGTERM');
+    if (!process.kill(pid, 'SIGTERM')) {
+        throw new Error('SIGTERM Failed');
+    }
+
+    const end = Date.now() + grace_timeout_ms;
+    while (Date.now() < end) {
+        if (!pid_exists(pid)) {
+            return;
+        }
+        log(`Process is still there, waiting for 100ms, ${format_thousands(end - Date.now())}ms left`);
+        await Promise.delay(100);
+    }
+
+    log('Sending SIGKILL');
+    if (!process.kill(pid, 'SIGKILL')) {
+        throw new Error('SIGKILL Failed');
+    }
+}
+
+module.exports = pid_kill_grace;

package/src/ping_socket.js

@@ -0,0 +1,32 @@
+const Promise = require('bluebird');
+const net = require('net');
+
+/**
+ * - Always closes the socket.
+ * - Throws on any error or timeout.
+ * - Doesn’t hang if the server sends nothing.
+ */
+function ping_socket(socket_path, data = 'PING', timeout_ms = 1000)
+{
+    return new Promise(function (resolve, reject) {
+        let done = false;
+        const buf = [];
+        const socket = net.connect(socket_path);
+        socket.setTimeout(timeout_ms, () => finish(new Error('Socket Timeout')));
+        socket.on('end', () => finish(null, Buffer.concat(buf)))
+        socket.on('error', finish);
+        socket.on('connect', () => socket.end(data));
+        socket.on('data', chunk => buf.push(chunk));
+        function finish(error, out) {
+            if (done) {
+                return;
+            }
+            done = true;
+            socket.removeAllListeners();
+            socket.destroy();
+            error ? reject(error) : resolve(out);
+        }
+    });
+}
+
+module.exports = ping_socket;

package/src/plural.js

@@ -1,6 +1,12 @@
-function plural(n, apple, apples)
+function plural(n, singular, plural, zero)
 {
-    return (n % 10 === 1 && n % 100 !== 11) ? apple.split('#').join(n) : apples.split('#').join(n);
+    if (n === 0 && typeof zero === 'string') {
+        return zero;
+    }
+    if (n % 10 === 1 && n % 100 !== 11) {
+        return singular.split('#').join(n);
+    }
+    return plural.split('#').join(n);
 }
 
 module.exports = plural;

package/src/plural.test.js

@@ -1,15 +1,17 @@
 const assert = require('assert');
 const plural = require('./plural');
 
-const items = [
-    ['1 apple', 1, '# apple', '# apples', ],
+const tests = [
+    ['1 apple', 1, '# apple', '# apples'],
     ['2 apples', 2, '# apple', '# apples'],
     ['10 apples', 10, '# apple', '# apples'],
     ['21 apple', 21, '# apple', '# apples'],
+    ['0 apples', 0, '# apple', '# apples'],
+    ['No apples', 0, '# apple', '# apples', 'No apples'],
 ];
 
 describe('plural', function () {
-    items.forEach(function ([expected, ...args],) {
+    tests.forEach(function ([expected, ...args],) {
         it(expected, function () {
             const actual = plural(...args);
             assert.deepStrictEqual(actual, expected);

package/src/sanitize_var_name.js

@@ -1,9 +1,9 @@
-const camel_to_snake = require('./camel_to_snake');
 const sanitize_dash_name = require('./sanitize_dash_name');
+const str_camel_to_snake = require('./str_camel_to_snake');
 
 function sanitize_var_name(var_name)
 {
-    const out = sanitize_dash_name(camel_to_snake(var_name)).replace(/[^a-z0-9]+/g, '_');
+    const out = sanitize_dash_name(str_camel_to_snake(var_name)).replace(/[^a-z0-9]+/g, '_');
     if (out.length === 0) {
         return '_';
     }

package/src/{camel_to_snake.js → str_camel_to_snake.js}

@@ -1,4 +1,4 @@
-function camel_to_snake(s)
+function str_camel_to_snake(s)
 {
     return s
         .replace(/([a-z0-9])([A-Z])/g, '$1_$2')  // Insert underscore between lowercase/number and uppercase
@@ -6,4 +6,4 @@ function camel_to_snake(s)
         .toLowerCase();
 }
 
-module.exports = camel_to_snake;
+module.exports = str_camel_to_snake;

package/src/{camel_to_snake.test.js → str_camel_to_snake.test.js}

@@ -1,5 +1,5 @@
 const assert = require('assert');
-const camel_to_snake = require('./camel_to_snake');
+const str_camel_to_snake = require('./str_camel_to_snake');
 
 const items = [
     ['UPC', 'upc'],
@@ -8,10 +8,10 @@ const items = [
     ['XMLHTTPRequest', 'xmlhttp_request'],
 ];
 
-describe('camel_to_snake', function () {
+describe('str_camel_to_snake', function () {
     items.forEach(function ([input, expected],) {
         it(`${input === '' ? '☒' : input} → ${expected}`, function () {
-            assert.deepStrictEqual(camel_to_snake(input), expected);
+            assert.deepStrictEqual(str_camel_to_snake(input), expected);
         });
     });
 });

package/src/str_parse_kv.js

@@ -0,0 +1,10 @@
+function str_parse_kv(str)
+{
+    const i = str.indexOf(':');
+    if (i === -1) {
+        return [str.trim(), ''];
+    }
+    return [str.slice(0, i).trim(), str.slice(i + 1).trim()];
+}
+
+module.exports = str_parse_kv;

package/src/fcmp_strings.js

@@ -1,6 +0,0 @@
-function fcmp_strings(a, b)
-{
-    return String(a).localeCompare(b);
-}
-
-module.exports = fcmp_strings;