DEV Community: shajunxing

Banana CVar, a set of advanced data types in C that supports garbage collection

shajunxing — Mon, 23 Jun 2025 15:45:17 +0000

This article is openly licensed via CC BY-NC-ND 4.0.

Project Address: https://github.com/shajunxing/banana-cvar

This is an example of using data types and garbage collector from project https://github.com/shajunxing/banana-script in C program. Rule for garbage collection in C program is quite simple: Record value and address of each variable. If value at address matches recorded value, it's marked as being in use because that means call stack hasn't changed. On the other side, if leave that variable scope, such as when function exits, these two will eventually not match.

How to build see https://github.com/shajunxing/banana-script and will not be repeated.

In example.c, if you comment out line gc(); and check task manager, you’ll see memory keeps growing. This happens because var f = string("This is a dynamic string"); is dynamically allocating memory. But if you uncomment that line, memory stabilizes and doesn't grow, which shows that garbage collection strategy is really successful.

#include <stdlib.h>
#include "var.h"

void foo() {
    var a = null();
    var b = boolean(true);
    var c = boolean(false);
    var d = number(3.14);
    var e = scripture("This is a constant string");
    var f = string("This is a dynamic string");
    print(a, b, c, d, e, f);
}

int main() {
    for(;;) {
        foo();
        gc();
    }
    return EXIT_SUCCESS;
}

Banana Script, An inperpreter for a strict subset of JavaScript

shajunxing — Mon, 23 Jun 2025 15:42:56 +0000

This article is openly licensed via CC BY-NC-ND 4.0.

Project Address: https://github.com/shajunxing/banana-script

Introduction

My goal is to remove and modify useless and ambiguous parts of JavaScript language that I've summarized in practice, and to create a minimal syntax interpreter by keeping only what I like and need. Only JSON-compatible data types and function are supported, function is first-class value, and function supports closure. I don't like object-oriented programming, so everything class related are not supported. There are no built-in immunable global variables, global functions, or object members, even contents added during interpreter initialization can be easily deleted at any time and reverted to clean empty state.

Two-Minute Brief Syntax Guide for Proficient JavaScript Users

Data types are null boolean number string array object function, results of typeof correspond strictly to these names. No undefined because null is enough. Array and object are clean, no predefined members such as __proto__.

Variable declaraction use let, all variables are local, const is not supported because all must be deletable. Access undeclared variables will cause error, access array/object's unexisting members will get null, and put null will delete corresponding member.

Function definition supports default parameter param = value and rest parameter ...params. Array literal and function call support spread syntax ..., which will not skip null members. No predefined members such as this arguments in function. If return is outside function, means exit vm.

Operators follow strict rule, no implicit conversion. Only boolean can do logical operations. == != are strict meaning, and can be done by all types. Strings can do all relational operations and +. Numbers can do all relational and numerical operations. Operator precedence from low to high is:

Ternary operator ? :
Logical or operator ||
Logical and operator &&
Relational operator == != < <= > >=
Additive operator + -
Multiplicative operator * / %
Exponential operator **
Prefix operator + - ! typeof
Array/object member access and function call operator [] . ?. ()

Assignment expression = += -= *= /= %= ++ -- does not return value, Comma expression , is not supported.

Conditional statement is if, loops are while do while for, conditions must be boolean. for loop only support following syntax, [] means optional. for in and for of only handle non-null members:

for ([[let] variable = expression ] ; [condition] ; [assignment expression])
for ([let] variable in array/object)
for ([let] variable of array/object)

No modules. In inperpreter's view, source code is only one large flat text.

Garbage collection is manual, you can do it at any time you need.

delete means delete local variable within current scope (object members can be deleted by setting null). For example, variables added to the function closure are all local variables before return, so unused variables can be deleted before return to reduce closure size, run following two statements in REPL environment to see differences.

let f = function(a, b){let c = a + b; return function(d){return c + d;};}(1, 2); dump(); print(f(3)); delete f;
let f = function(a, b){let c = a + b; delete a; delete b; return function(d){return c + d;};}(1, 2); dump(); print(f(3)); delete f;

throw can throw any value, which are received by catch. finally is not supported, because I think it's totally unecessary, and will make code execution order weird.

Technical internals

This project is C99 compatable, no other dependences, even make systems are not necessary, only need C compiler, compilation environment is msgc/gcc/mingw. First, from https://github.com/shajunxing/banana-nomake download single file make.h, then open make.c, modify #include to correct path, then with msvc type cl make.c && make.exe release, or with mingw type gcc -o make.exe make.c && ./make.exe release. Executables are in bin folder.

Project follows "minimal dependency" rule, only including necessary headers. Also, there's only one-way referencing between modules, with no circular referencing. Here’s how modules work and their dependencies:

    js-common   js-data     js-vm       js-syntax
        <-----------
                    <-----------
                                <-----------
        <-----------------------
        <-----------------------------------

js-common: Constants, macro definitions, and functions common to project, such as log, memory io
js-data: Data types and garbage collection, you can even use this module separately in C projects to manipulate high-level data structures with GC functionality, see https://github.com/shajunxing/banana-cvar
js-vm: Bytecode Virtual Machine, compiled separately to get an interpreter with minimal footprint without source code parsing
js-syntax: Lexical parsing and syntax parsing, which converts source code into bytecode

All values are struct js_value type, you can create by js_xxx() functions, xxx is value type, and you can read c values direct from this struct, see definition in js_data.h. Created values follow garbage collecting rules. DON'T directly modify their content, if you want to get different values, create new one. Compound types array object can be operated by js_array_xxx() js_object_xxx() functions.

C functions must be struct js_result (*)(struct js_vm *) format, use js_c_function() to create c function value, yes of course they are all values and can be put anywhere, for example, if put on stack root using js_variable_declare(), they will be global. struct js_result has two members, if .success is true, .value is return value, if false, .value is received by catch if there are try catch. c function can also call script function using js_call(). Inside C function, use js_parameter_base() js_parameter_length() js_parameter_get() to get passed in parameters.

Merge malloc/calloc/realloc/free into one safe macro, and test code

shajunxing — Fri, 13 Jun 2025 02:07:44 +0000

I standalize actions of checking NULL before allocation, setting pointer to NULL after released, and initializing newly allocated memory to 0. Only flaw is, pointer must be manually initized to NULL on declaraction, which cannot be gracefully implemented by macro.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>

#define log_error(__arg_format, ...) \
    printf("ERROR %s:%d:%s: " __arg_format "\n", __FILE__, __LINE__, __func__, ##__VA_ARGS__)

#define fatal(__arg_format, ...)                                \
    do {                                                        \
        log_error("Fatal error: " __arg_format, ##__VA_ARGS__); \
        abort();                                                \
    } while (0)

#define enforce(__arg_condition)                               \
    do {                                                       \
        if (!(__arg_condition)) {                              \
            fatal("Enforcement failed: %s", #__arg_condition); \
        }                                                      \
    } while (0)

#if defined(_WIN32)
    #include <malloc.h>
    #define allocated_size _msize
#elif defined(__linux__)
    #include <malloc.h>
    #define allocated_size malloc_usable_size
#elif defined(__APPLE__)
    #include <malloc/malloc.h>
    #define allocated_size malloc_size
#else
    #error Looking up allocated memory block size is not supported in this platform.
#endif

#define allocate(__arg_pointer, __arg_unit_count)                                             \
    do {                                                                                      \
        typeof(__arg_unit_count) __unit_count = __arg_unit_count;                             \
        size_t __size_per_unit = sizeof(typeof(*__arg_pointer));                              \
        size_t __size = __unit_count * __size_per_unit;                                       \
        if (__arg_pointer == NULL) {                                                          \
            if (__unit_count > 0) {                                                           \
                __arg_pointer = (typeof(__arg_pointer))calloc(__unit_count, __size_per_unit); \
                enforce(__arg_pointer != NULL);                                               \
            }                                                                                 \
        } else {                                                                              \
            if (__unit_count > 0) {                                                           \
                size_t __old_size = allocated_size(__arg_pointer);                            \
                __arg_pointer = (typeof(__arg_pointer))realloc(__arg_pointer, __size);        \
                enforce(__arg_pointer != NULL);                                               \
                if (__size > __old_size) {                                                    \
                    memset((char *)(__arg_pointer) + __old_size, 0, __size - __old_size);     \
                }                                                                             \
            } else {                                                                          \
                free(__arg_pointer);                                                          \
                __arg_pointer = NULL;                                                         \
            }                                                                                 \
        }                                                                                     \
    } while (0)

struct foo {
    char a;
    short b;
    long c;
    long long d;
};

// msvc compile options: cl /W3 /utf-8 /std:clatest
// open task manager to check whether memory leaks
int main() {
    struct foo *foo = NULL;
    struct foo *ptr;
    int old_count = 0;
    int new_count = 0;
    int offset;
    srand((unsigned)time(NULL));
    for (;;) {
        // check whether old memory is 0xff
        for (offset = 0; offset < old_count; offset++) {
            ptr = foo + offset;
            enforce(ptr->a == -1);
            enforce(ptr->b == -1);
            enforce(ptr->c == -1);
            enforce(ptr->d == -1);
        }
        // set a smaller value to make more 0 appear for testing 'free()'
        new_count = rand() % 10;
        allocate(foo, new_count);
        // check whether new space is 0
        for (offset = old_count; offset < (new_count - old_count); offset++) {
            ptr = foo + offset;
            enforce(ptr->a == 0);
            enforce(ptr->b == 0);
            enforce(ptr->c == 0);
            enforce(ptr->d == 0);
        }
        // fill 0xff
        for (offset = 0; offset < new_count; offset++) {
            ptr = foo + offset;
            ptr->a = -1;
            ptr->b = -1;
            ptr->c = -1;
            ptr->d = -1;
        }
        old_count = new_count;
    }
    return EXIT_SUCCESS;
}

Ways for extracting portable version of Microsoft Visual C/C++ compiler

shajunxing — Tue, 20 May 2025 04:50:35 +0000

Although even visual studio build tool must be installed, command line compiler can actually run completely independently, so you can install it in any temporary location (such as in virtual machine), and then use following batch script to extract it, note that directories, version numbers, etc. should be modified according to your actual situation:

@echo off
cd /d %~dp0
robocopy /mir "C:\Program Files (x86)\Microsoft Visual Studio\2022\BuildTools\VC\Tools\MSVC\14.43.34808\bin\Hostx64\x64" "%CD%\vc\bin"
robocopy /mir "C:\Program Files (x86)\Microsoft Visual Studio\2022\BuildTools\VC\Tools\MSVC\14.43.34808\include" "%CD%\vc\include"
robocopy /mir "C:\Program Files (x86)\Microsoft Visual Studio\2022\BuildTools\VC\Tools\MSVC\14.43.34808\lib\x64" "%CD%\vc\lib"
robocopy /mir "C:\Program Files (x86)\Windows Kits\10\bin\10.0.22621.0\x64" "%CD%\win\bin"
robocopy /mir "C:\Program Files (x86)\Windows Kits\10\Include\10.0.22621.0\shared" "%CD%\win\include\shared"
robocopy /mir "C:\Program Files (x86)\Windows Kits\10\Include\10.0.22621.0\ucrt" "%CD%\win\include\ucrt"
robocopy /mir "C:\Program Files (x86)\Windows Kits\10\Lib\10.0.22621.0\ucrt\x64" "%CD%\win\lib\ucrt"
robocopy /mir "C:\Program Files (x86)\Windows Kits\10\Include\10.0.22621.0\um" "%CD%\win\include\um"
robocopy /mir "C:\Program Files (x86)\Windows Kits\10\Lib\10.0.22621.0\um\x64" "%CD%\win\lib\um"

Then create env.bat in directory. The purpose of this batch file is to set compiler's environment variables. You can do setup by calling it:

@echo off
pushd %~dp0
set PATH=%CD%\vc\bin;%CD%\win\bin;%PATH%
set Include=%CD%\vc\include;%CD%\win\include\shared;%CD%\win\include\ucrt;%CD%\win\include\um;%INCLUDE%
set Lib=%CD%\vc\lib;%CD%\win\lib\ucrt;%CD%\win\lib\um;%LIB%
popd

Finally, use following c code, save as utf-8 encoded test_msvc.c, in command prompt switch to utf-8 by executing chcp 65001, and then compile and run it using cl test_msvc.c /link /NODEFAULTLIB msvcrt.lib libvcruntime.lib ucrt.lib kernel32.lib user32.lib && test_msvc.exe to test if any files are missing and if ucrt encoding is correct.

#include <stdio.h>
#include <stdlib.h>
#include <windows.h>

int main() {
    puts("Hello, World!");
    puts("你好，世界！");
    int i = 10;
    MessageBox(NULL, "Hello, World!", "Greetings", MB_OK);
    return EXIT_SUCCESS;
}

According to https://learn.microsoft.com/en-us/cpp/porting/upgrade-your-code-to-the-universal-crt?view=msvc-170 and https://learn.microsoft.com/en-us/cpp/c-runtime-library/crt-library-features?view=msvc-170, c runtime of msvc has been divided into three parts. Above compilation command is best way to generate smallest size without dependency vcruntime140.dll (all others are dynamically linked).

Banana NoMake, only one .h required, direct write script with C, replace those annoying gmake, nmake, cmake...

shajunxing — Thu, 15 May 2025 13:24:50 +0000

This article is openly licensed via CC BY-NC-ND 4.0.

Project Address: https://github.com/shajunxing/banana-nomake

I don't like those build systems, I think they break their own belief "mechanism better than policy" and "keep it simple stupid". Why should one learn those ugly and rigid rules? Wouldn't a Turing-Complete programming language be better? Since C compiler is essential, encapsulate necessary functions into a header file, most important points I summarized as follows: 1. Recursive traversal of file and directories; 2. Comparison of file timestamps; 3. Serial and parallel execution of commands, then I can happily write scripts in C, right? Customers would be happy too, as they won't need to install any additional build systems, they can simply type gcc script.c && ./a.out or cl script.c && script.exe, isn't it quite easy?

Brief guide: use listdir to batch process multiple files in a directory, use max mtime to compare file modification times, use append concat endswith equals format join startswith to handle strings, and use async await run to execute commands.

For example, in a certain project, source code is in src directory, compiled intermediate files are in build directory, and target files are in bin directory. Since C language string literals support direct concatenation, it's really easy to define file names, directories, and command lines.

#define bin_dir "bin" pathsep
// ...
#define example_exe bin_dir "example" exeext
// ...
#ifdef _MSC_VER
    #define cc "cl /nologo /c /W3 /MD /Zp /utf-8 /std:clatest /O2 /Fo"
    #define ld "link /nologo /incremental:no /nodefaultlib /out:"
// ...

Dependency relationship in traditional makefile, like example_exe: example_obj var_h js_data_h js_common_h, basically just compares modification times of files before and after colon. If before is older than after, it runs following commands. So, if you write it directly in C, it becomes a lot clearer and more straightforward.

if (mtime(example_exe) < mtime(example_obj, var_h, js_data_h, js_common_h)) {
    run(link_example);
}

Because C is Turing-Complete programming language, it can easily implement more complex and flexible logic, which is something those make systems can't compare to. Here's a complete example where I use async() and await() to execute commands concurrently on multiple cores, and it's pretty straightforward in C. On the other hand, even if those make systems could pull it off, configuration rules would be all over the place and hard to understand.

#define bin_dir "bin" pathsep
#define build_dir "build" pathsep
#define src_dir "src" pathsep
#define banana_script_src_dir ".." pathsep "banana-script" pathsep "src" pathsep
#define js_common_h banana_script_src_dir "js-common.h"
#define js_common_c banana_script_src_dir "js-common.c"
#define js_common_obj build_dir "js_common" objext
#define js_data_h banana_script_src_dir "js-data.h"
#define js_data_c banana_script_src_dir "js-data.c"
#define js_data_obj build_dir "js_data" objext
#define var_h src_dir "var.h"
#define var_c src_dir "var.c"
#define var_obj build_dir "var" objext
#define example_c src_dir "example.c"
#define example_obj build_dir "example" objext
#define example_exe bin_dir "example" exeext
#ifdef _MSC_VER
    #define cc "cl /nologo /c /W3 /MD /Zp /utf-8 /std:clatest /O2 /Fo"
    #define ld "link /nologo /incremental:no /nodefaultlib /out:"
    #define extra_libs " msvcrt.lib libvcruntime.lib ucrt.lib kernel32.lib user32.lib"
#elif defined(__GNUC__)
    #define cc "gcc -c -Wall -O3 -o "
    #define ld "gcc -fvisibility=hidden -fvisibility-inlines-hidden -static -static-libgcc -s -Wl,--exclude-all-symbols -o "
    #define extra_libs ""
#else
    #error Only msvc and gcc are supported
#endif
#define compile_js_common cc js_common_obj " " js_common_c
#define compile_js_data cc js_data_obj " " js_data_c
#define compile_var cc var_obj " " var_c
#define compile_example cc example_obj " " example_c
#define link_example ld example_exe " " example_obj " " var_obj " " js_data_obj " " js_common_obj extra_libs

void build() {
    mkdir(bin_dir);
    mkdir(build_dir);
    // DON'T compare obj because it is generated asynchronously
    if (mtime(js_common_obj) < mtime(js_common_h, js_common_c)) {
        async(compile_js_common);
    }
    if (mtime(js_data_obj) < mtime(js_data_h, js_data_c, js_common_h)) {
        async(compile_js_data);
    }
    if (mtime(var_obj) < mtime(var_h, var_c, js_data_h js_common_h)) {
        async(compile_var);
    }
    if (mtime(example_obj) < mtime(example_c, var_h, js_data_h js_common_h)) {
        async(compile_example);
    }
    await();
    if (mtime(example_exe) < mtime(example_obj, var_h, js_data_h, js_common_h)) {
        run(link_example);
    }
}

void cleanup(const char *dir, const char *base, const char *ext) {
    if (base) {
        char *file_name = concat(dir, base, ext);
        remove(file_name);
        free(file_name);
    } else {
        listdir(dir, cleanup);
        rmdir(dir);
    }
}

int main(int argc, char **argv) {
    if (argc == 1) {
        build();
        return EXIT_SUCCESS;
    } else if (argc == 2) {
        if (equals(argv[1], "clean")) {
            listdir(bin_dir, cleanup);
            listdir(build_dir, cleanup);
            return EXIT_SUCCESS;
        } else if (equals(argv[1], "-h", "--help")) {
            ;
        } else {
            printf("Invalid target: %s\n", argv[1]);
        }
    } else {
        printf("Too many arguments\n");
    }
    printf("Usage: %s [clean|-h|--help]\n", argv[0]);
    return EXIT_FAILURE;
}

Below are detailed API definitions:

Constants	Description
`const enum compiler_type compiler`	Compiler type, can be one of `msvc` `gcc`.
`#define dllext`	File extension of shared library, e.g `".dll"` `".so"`
`#define exeext`	File extension of executable, e.g `".exe"`
`#define libext`	File extension of library, e.g `".lib"` `".a"`
`#define objext`	File extension of compiled object, e.g `".obj"` `".o"`
`const enum os_type os`	Operating system type, can be one of `windows` `posix`.
`#define pathsep`	File system path seperator, , e.g `"\\"` `"/"`

Functions	Description
`void append(char **dest, ...)`	Append multiple strings sequentially to end of `dest`, `dest` must be dynamically allocated.
`void async(const char *cmd)`	Parallel run command line `cmd`. Maximum number of workers equals to num of cpu cores. If return value is not 0, print error message and exit program.
`void await()`	Wait for all workers to finish.
`char *concat(...)`	Concatenate multiple strings, return string should be freed when used up.
`bool endswith(const char *str, ...)`	Determine whether `str` ends with any of rest parameters.
`bool equals(const char *str, ...)`	Determine whether `str` are equal to any of rest parameters.
`char format(const char fmt, ...)`	Format string like `printf`, return string should be freed when used up.
`char join(char sep, ...)`	Join multiple strings by given seperator `sep`, return string should be freed when used up.
`void listdir(const char dir, void (callback)(const char dir, const char base, const char *ext))`	Iterate all items in directory `dir`, whether `dir` ends with or without path seperator doesn't matter, for each item invoke `callback`, set 3 parameters: `dir` always ends with path seperator. If item is file, combination is complete file path, `ext` will be `""` if file has no extension. If is directory, `dir` will be subdirectory's full path, `base` and `ext` will be `NULL`.
`double max(...)`	Take one or more double values, returns maximum one.
`double mtime(...)`	Get one or more file modification utc time and returns latest one, value for non-existent file is -DBL_MAX
`void run(const char *cmd)`	Run command line `cmd`. If return value is not 0, print error message and exit program.
`bool startswith(const char *str, ...)`	Determine whether `str` starts with any of rest parameters.

debian stretch升级bookworm历险记

shajunxing — Thu, 08 May 2025 15:34:56 +0000

脑抽升级，其实完全没必要，跑得好好的，升级啥。更改源，apt update，apt full-upgrade，弹出蓝色界面提示什么“xdm”需要重启，是否继续，因为是在图形界面下，我没敢点继续，怕xterm连带被关掉，然后就悲剧了，apt无法再执行，提示glibc版本找不到，估计是apt升级了但是libc没有，dpkg还能跑，firefox等软件已无法打开，只得windows里面packages.debian.org找apt的依赖包，u盘下载拿到linux上，dpkg -i --force-all装，但是依赖实在太多，不停报错。一气之下下载.iso，rufus软件写u盘，u盘启动，到分区阶段犹豫了，我是需要保留/home的，网上查了下，建议备份，但三百多G没那么大的u盘。重启，幸好xwindow还能进，但是u盘需要手工mount了，我一想，u盘里面不是有deb吗，缺啥补啥呗，find ./ -name "..."搜，dpkg -i --force-all ./.../.../*.deb强制装，提示未配置的，dpkg-reconfigure重新配，apt能跑了，再次apt full-upgrade，提升版本不对，估计iso里的和网上最新的版本不一样，apt --fix-broken install，反正就是dpkg -i --force-all apt --fix-broken install apt full-upgrade来回折腾，缺啥装啥，最好ctrl-alt-f1进文本界面，别在x下面弄，提升什么选择配置文件，选包里自带的，不要选硬盘原有的，相当于全新安装。遇到卡死的，比如配置gconf，ctrl-alt-f2，ps aux | grep "gconf"，然后kill掉那个pid最小的，

C语言得到变参数量的宏，0参数不会错误返回1，gcc和msvc都测试通过

shajunxing — Thu, 08 May 2025 15:32:11 +0000

参考 https://stackoverflow.com/questions/2124339/c-preprocessor-va-args-number-of-arguments

我原先用的是：

#define _expand(x) x
#define _numargs(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, _61, _62, _63, N, ...) N
#define numargs(...) _expand(_numargs(_, ##__VA_ARGS__, 63, 62, 61, 60, 59, 58, 57, 56, 55, 54, 53, 52, 51, 50, 49, 48, 47, 46, 45, 44, 43, 42, 41, 40, 39, 38, 37, 36, 35, 34, 33, 32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0))

msvc必须要用_expand套一下，原因据说是参数展开时机问题，但零参数会得到错误结果1，gcc有另外的问题，就是不能使用比如-std=c99 -std=c23，否则零参数也是1，原因是##是gcc扩展，参见https://gcc.gnu.org/onlinedocs/cpp/Variadic-Macros.html，而标准c直到c23才加入__VA_OPT__，有意思的是msvc也支持##。

高赞那个用(sizeof((int[]){__VA_ARGS__})/sizeof(int))的，首先msvc必须高版本，且会报C4047类型不匹配警告，而gcc则是错误无法编译。

只有下面6赞的回答是完美的，我稍微调整了下，以适配个人风格：

#define _numargs_call(__arg_0, __arg_1) __arg_0 __arg_1
#define _numargs_select(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, _61, _62, _63, __arg_0, ...) __arg_0
#define numargs(...) _numargs_call(_numargs_select, (_, ##__VA_ARGS__, 63, 62, 61, 60, 59, 58, 57, 56, 55, 54, 53, 52, 51, 50, 49, 48, 47, 46, 45, 44, 43, 42, 41, 40, 39, 38, 37, 36, 35, 34, 33, 32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0))

msvc现在是用_numargs_call套一下，零参数不会出问题了，甚至古老的vs2007/wdk7.1也正常。

测试代码：

int main() {
    printf("numargs = %d\n", numargs());
    printf("numargs = %d\n", numargs(1));
    printf("numargs = %d\n", numargs(1, 3.14));
    printf("numargs = %d\n", numargs(1, 3.14, "hello"));
    return EXIT_SUCCESS;
}

执行cl test.c && test.exe或gcc -o test.exe test .c && ./test.exe，结果都是：

numargs = 0
numargs = 1
numargs = 2
numargs = 3

如何在公共聊天室传递隐密信息

shajunxing — Thu, 08 May 2025 15:31:27 +0000

比如你想加某人好友，又不愿意自己或对方帐号打在公屏上让所有人都看到，可以这样做：弄个临时或垃圾邮箱，让对方把帐号发到这个邮箱，同时附上一段随机字串，你收到后，把随机字串发在公屏上，问是他发的吗，如此确认即可。

当然了，也可以用非对称密钥。

Node.js写的简单的本地子网端口扫描器

shajunxing — Thu, 08 May 2025 15:30:55 +0000

比如你的手机开了ftp，或者别的电脑开了什么服务，你懒得再过去翻看ip地址，就用这个脚本，自动从你电脑获取ip地址和掩码计算需要扫描的子网地址，然后自动扫描，需要扫哪些端口自己改一下就是了。

let net = require("net");
let os = require("os");
function int2ip(int) {
    return [ (int >>> 24) & 255, (int >>> 16) & 255, (int >>> 8) & 255, int & 255 ].join(".");
}
function ip2int(ip) {
    return ip.split(".").reduce((int, v) => int * 256 + +v);
}
let ip, mask, found;
let ifaces = os.networkInterfaces();
for (let ifname in ifaces) {
    let iface = ifaces[ifname];
    for (let addr of iface) {
        if (!addr.internal && addr.family === "IPv4") {
            ip = addr.address;
            mask = addr.netmask;
            found = true;
            break;
        }
    }
    if (found) {
        break;
    }
}
if (!ip) {
    console.log("No usable ipv4 network");
    process.exit(-1);
}
console.log("Scanning on", ip, mask);
ip = ip2int(ip);
mask = ip2int(mask);
let net_num = ip & mask;
let max_host_num = ip2int("255.255.255.255") & ~mask;
for (let host_num = 1; host_num < max_host_num; host_num++) {
    let ip = int2ip(net_num + host_num);
    for (let port of [2121, 8000]) {
        let socket = new net.Socket();
        socket.setTimeout(1500);
        socket.on("connect", function() {
            console.log("Found", ip, port);
            socket.destroy();
        });
        socket.on("error", function() {
            socket.destroy();
        });
        socket.on("timeout", function() {
            socket.destroy();
        });
        socket.connect(port, ip);
    }
}

比如我一般常用8000（http）和2121（ftp），这是我扫出来的结果：

Scanning on 192.168.196.88 255.255.255.0
Found 192.168.196.88 8000
Found 192.168.196.130 2121