acl4のページ0021

  • (by K, 2026.04.26)

(1) 概要

  • a4_0021 は、 acl4v1 にとっての6番目のライブラリプログラムになります。
  • 提供される主な機能は、以下の通りです。
    • (1-1)プリプロセッサの#define/#typedDef/#undefに関する機能
  • 以下、それぞれについてもう少し詳しく説明します。


  • 関数 a_Preprocessor_substitute0(): ## によるトークン連結、過剰なコンマの削除、__FILE__、__LINE__、defRight()、defEnum() の処理をします。
  • 関数 a_TypedDef_getTypeList(): #typedDef における型情報を、比較しやすい内部形式に変換してそのポインタを返します。
  • 関数 a_TypedDef_cmpTyp(): #typedDef における型情報がマッチ条件を満たしているか確認します。
  • 関数 a_TypedDef_cmpTyps(): a_TypedDef_cmpTyp() をすべての引数について行って AND を取ります。
  • 関数 a_Preprocessor_findDef(): テキスト上の記述から、マッチする定義を探します。
  • 関数 a_Preprocessor_substitute1(): defined()、definedx()、マクロ展開の処理をします。
  • 関数 a_Preprocessor_marking0(): #define/#typedDef の置換先文字列の中のパラメータ部分をエンコードします。
  • 関数 a_Preprocessor_marking1(): #define/#typedDef の置換先文字列の中のパラメータ部分をエンコードします(別アルゴリズム)。
  • 関数 a_Preprocessor_define1(): #define/#typedDef の定義処理をします。
  • 関数 a_Preprocessor_define2(): プログラム中から、#define/#typedDef の定義処理をします。

(2) デモ

(3) ライブラリプログラム

a_static int a_Preprocessor_substitute0(a_Token0 *t0, a_VecChr *lin, a_VecChr *path, intptr_t linNo, uint32_t stpTkn, a_VecChr *tmp, a_VecChr *defEnum)
{
    char *p = lin->p; t0->s1 = p + a_VecChr_N(lin);
    int rv = 0;
    for (t0->s = p;;) {
        char *t = a_Token1_get(t0);
        if (t0->len == 0 || t0->c == stpTkn) break;
        if (t0->len == 2 && t[0] == '#' && t[1] == '#') { // ## があったら前後の空白類とともに削除する.
            intptr_t pos0 = t - p, pos1 = pos0 + 2;
            while (pos0 > 0 && p[pos0 - 1] <= ' ') pos0--;
            while (pos1 < a_VecChr_N(lin) && p[pos1] <= ' ') pos1++;
            a_VecChr_replace(lin, pos0, pos1 - pos0, NULL, 0);
            t0->s = p; // 長さが短くなるだけなのでpは変化しない.
            t0->s1 = p + a_VecChr_N(lin);
            rv = 1;
        }
    }
    if (rv != 0) return rv;
cont0:
    t0->c = 0; intptr_t pos0 = 0; 
    for (t0->s = p;;) {
        intptr_t c0 = t0->c, pos00 = pos0;
cont1:
        char *t = a_Token1_get(t0);
        if (t0->len == 0 || t0->c == stpTkn) break;
        pos0 = t - p;
        if (t0->c == '.' && t[1] == '(') {
            a_VecChr_replace(lin, pos0, 2, "(_a, ", 5); return 1; // 置換する.
        }
        if (c0 == '(' && t0->c == ',') { *t = ' '; rv = 1; goto cont1; } // ここで処理すると改行を超えられないという問題はある.
        if (c0 == '{' && t0->c == ',') { *t = ' '; rv = 1; goto cont1; } // それが深刻な問題になったら、別の方法を考えないといけない.
        if (c0 == ',' && t0->c == ',') { *t = ' '; rv = 1; goto cont1; }
        if (c0 == ',' && t0->c == ')') { puts(p); p[pos00] = ' '; rv = 1; goto cont0; }
        if (c0 == ',' && t0->c == '}') { p[pos00] = ' '; rv = 1; goto cont0; }
        if (t0->cTyp != 3) continue;
        if (t0->len == 8 && memcmp(t, "__FILE__", 8) == 0) {
            a_VecChr_N(tmp) = 0; a_VecChr_printf(tmp, "\"%.*s\"", (int) a_VecChr_N(path), path->p);
            a_VecChr_replace(lin, pos0, t0->len, tmp->p, a_VecChr_N(tmp)); return 1;
        }
        if (t0->len == 8 && memcmp(t, "__LINE__", 8) == 0) {
            a_VecChr_N(tmp) = 0; a_VecChr_printf(tmp, "%d", (int) linNo);
            a_VecChr_replace(lin, pos0, t0->len, tmp->p, a_VecChr_N(tmp)); return 1;
        }
        if (t0->len == 8 && &t[8] < t0->s1 && memcmp(t, "defRight(", 9) == 0) {
            t0->s = &t[9]; a_parseArgs(t0, tmp); a_parseArgs_Arg *paa = (a_parseArgs_Arg *) tmp->p;
            if (t0->c == ')' && a_VecChr_N(tmp) == 2 * (intptr_t) sizeof (a_parseArgs_Arg)) {
                a_VecChr vca[1], vcb[1];
                a_VecChr_iniCpy0(_a_ vca, paa[0].s, paa[0].n);
                a_VecChr_iniCpy0(_a_ vcb, paa[1].s, paa[1].n);
                char *ssp = strstr(vca->p, vcb->p);
                if (ssp != NULL) {
                    intptr_t len1 = a_VecChr_N(vca) - (ssp - vca->p) - a_VecChr_N(vcb);
                    a_VecChr_replace(lin, pos0, t0->s - t, ssp + a_VecChr_N(vcb), len1); rv = 1;
                    a_VecChr_din4(_a_ vca, vcb, 0, 0);
cont2:
                    p = lin->p;
                    t0->s = p + pos0;
                    t0->s1 = p + a_VecChr_N(lin);
                    goto cont0;
                }
                a_VecChr_din4(_a_ vca, vcb, 0, 0);
            }
            t0->s = t; a_Token1_get(t0); // 巻き戻す.
        }
        if (t0->len == 7 && &t[7] < t0->s1 && memcmp(t, "defLeft(", 8) == 0) {
            t0->s = &t[8]; a_parseArgs(t0, tmp); a_parseArgs_Arg *paa = (a_parseArgs_Arg *) tmp->p;
            if (t0->c == ')' && a_VecChr_N(tmp) == 2 * (intptr_t) sizeof (a_parseArgs_Arg)) {
                a_VecChr vca[1], vcb[1];
                a_VecChr_iniCpy0(_a_ vca, paa[0].s, paa[0].n);
                a_VecChr_iniCpy0(_a_ vcb, paa[1].s, paa[1].n);
                char *ssp = strstr(vca->p, vcb->p);
                if (ssp != NULL) {
                    intptr_t len1 = ssp - vca->p;
                    a_VecChr_replace(lin, pos0, t0->s - t, vca->p, len1); rv = 1;
                    a_VecChr_din4(_a_ vca, vcb, 0, 0);
                    goto cont2;
                }
                a_VecChr_din4(_a_ vca, vcb, 0, 0);
            }
            t0->s = t; a_Token1_get(t0); // 巻き戻す.
        }
        if (t0->len == 6 && &t[6] < t0->s1 && memcmp(t, "defMid(", 7) == 0) {
            t0->s = &t[7]; a_parseArgs(t0, tmp); a_parseArgs_Arg *paa = (a_parseArgs_Arg *) tmp->p;
            if (t0->c == ')' && a_VecChr_N(tmp) == 3 * (intptr_t) sizeof (a_parseArgs_Arg)) {
                a_VecChr vca[1], vcb[1], vcc[1];
                a_VecChr_iniCpy0(_a_ vca, paa[0].s, paa[0].n);
                a_VecChr_iniCpy0(_a_ vcb, paa[1].s, paa[1].n);
                a_VecChr_iniCpy0(_a_ vcc, paa[2].s, paa[2].n);
                char *ssp = strstr(vca->p, vcb->p);
                if (ssp != NULL) {
                    char *ssq = strstr(ssp + paa[1].n, vcc->p);
                    if (ssq != NULL) {
                        intptr_t len1 = ssq - (ssp + paa[1].n);
                        a_VecChr_replace(lin, pos0, t0->s - t, ssp + paa[1].n, len1); rv = 1;
                        a_VecChr_din4(_a_ vca, vcb, 0, 0);
                        goto cont2;
                    }
                }
                a_VecChr_din4(_a_ vca, vcb, vcc, 0);
            }
            t0->s = t; a_Token1_get(t0); // 巻き戻す.
        }
        if (t0->len == 7 && &t[7] < t0->s1 && memcmp(t, "defEnum(", 8) == 0) {
            t0->s = &t[8]; a_parseArgs(t0, tmp); a_parseArgs_Arg *paa = (a_parseArgs_Arg *) tmp->p;
            if (t0->c == ')' && a_VecChr_N(tmp) == 2 * (intptr_t) sizeof (a_parseArgs_Arg)) {
                intptr_t i = strtol(paa[0].s, NULL, 0), j = strtol(paa[1].s, NULL, 0);
                a_VecChr_resize0(defEnum, (i + 1) * sizeof (intptr_t));
                *(intptr_t *) defEnum->p = j;
                a_VecChr_replace(lin, pos0, t0->s - t, NULL, 0); rv = 1; goto cont2;
            }
            if (t0->c == ')' && a_VecChr_N(tmp) == 1 * (intptr_t) sizeof (a_parseArgs_Arg)) {
                intptr_t i = strtol(paa[0].s, NULL, 0), j;
                a_VecChr_resize0(defEnum, (i + 1) * sizeof (intptr_t));
                j = *(intptr_t *) defEnum->p;
                char s[16]; sprintf(s, "%d", (int) j);
                *(intptr_t *) defEnum->p = j + 1;
                a_VecChr_replace(lin, pos0, t0->s - t, s, strlen(s)); rv = 1; goto cont2;
            }
            t0->s = t; a_Token1_get(t0); // 巻き戻す.
        }
    }
    return rv;
}

a_static void a_SetElm_mallocCpy(a_SetElm *w, const char *s, intptr_t n)
{
    w->k = a_malloc(_a_  n); memcpy((char *) w->k, s, n); w->n = n;
}

a_class(a_TypedDef_TypeCache) { a_SetElm elm[1]; a_VecChr typ[1]; };

a_static void a_TypedDef_TypeCache_din(a_SetElm *elm)
{
    a_TypedDef_TypeCache *p = (a_TypedDef_TypeCache *) elm;
    a_VecChr *q = (a_VecChr *) p->typ->p;
    intptr_t i, i1 = a_VecChr_N(p->typ) / sizeof (a_VecChr);
    for (i = 0; i < i1; i++)
        a_VecChr_din(_a_ &q[i]);
    a_free(_a_ (char *) p->elm->k, p->elm->n);
    a_VecChr_din(_a_ p->typ);
    a_free(_a_ p,  sizeof(a_TypedDef_TypeCache));
}

a_static a_VecChr *a_TypedDef_getTypeList(a_Set0 *cache, const char *s, intptr_t n, a_Token0 *t0, a_VecChr *tmp)
{
    a_TypedDef_TypeCache *p;
    a_VecChr *q;
    intptr_t i, i1;
    if (n == 0) {
        static a_VecChr nulSub[1] = { (char *) &a_VecChr_p0[2] };
        static void *nulPtr[3] = { (void *) sizeof (a_VecChr), (void *) sizeof (a_VecChr), nulSub };
        static a_VecChr nul[1] = { (char *) &nulPtr[2] };
        return nul;
    }
    p = a_Set0_findKn(cache, s, n);
    if (p == NULL) {
        p = a_malloc(_a_  sizeof(a_TypedDef_TypeCache));
        a_SetElm_mallocCpy(p->elm, s, n);
        t0->s = s; t0->s1 = s + n;
        if (*s == '(' || *s == '{' || *s == '[') t0->s++;
        a_parseArgs(t0, tmp);
        a_parseArgs_Arg *paa = (a_parseArgs_Arg *) tmp->p; i1 = a_VecChr_N(tmp) / sizeof (a_parseArgs_Arg);
        a_VecChr_ini(_a_ p->typ); a_VecChr_resize(p->typ, i1 * sizeof (a_VecChr));
        q = (a_VecChr *) p->typ->p;
        for (i = 0; i < i1; i++)
            a_VecChr_iniCpy(_a_ &q[i], paa[i].s, paa[i].n);
        a_Set0_add(cache, p->elm);
    }
    return p->typ;
}

a_static int a_TypedDef_cmpTyp(a_VecChr *typ, const char *s, intptr_t n)
{
    a_VecChr *q = (a_VecChr *) typ->p;
    intptr_t i, i1 = a_VecChr_N(typ) / sizeof (a_VecChr);
    for (i = 0; i < i1; i++) {
        intptr_t qin = a_VecChr_N(&q[i]);
        if (qin == 0) return 1;
        if (n >= qin && memcmp(s, q[i].p, qin) == 0) return 1;
    }
    return 0;
}

a_static int a_TypedDef_cmpTyps(a_VecChr *typs, a_parseArgs_Arg *paa, intptr_t an)
{
    intptr_t i;
    if (a_VecChr_N(typs) == 0) return 1;
    a_VecChr **tp = (a_VecChr **) typs->p;
    for (i = 0; i < an; i++) {
        if (a_TypedDef_cmpTyp(tp[i], paa[i].s, paa[i].n) == 0) return 0;
    }
    return 1;
}

a_class(a_Preprocessor_Define0) { a_SetElm elm[1]; a_VecChr vc[1]; };
a_class(a_Preprocessor_Define1) { a_VecChr typs[1], def[1]; };

a_static void a_Preprocessor_Define0_din(a_SetElm *elm)
{
    a_Preprocessor_Define0 *p = (a_Preprocessor_Define0 *) elm;
    a_VecChr *anp = (a_VecChr *) p->vc->p; intptr_t ani = a_VecChr_N(p->vc) / sizeof (a_VecChr) - 1;
    for (; ani >= 0; ani--) {
        a_Preprocessor_Define1 *d1p = (a_Preprocessor_Define1 *) anp[ani].p;
        intptr_t d1i = a_VecChr_N(&anp[ani]) / sizeof (a_Preprocessor_Define1) - 1;
        for (; d1i >= 0; d1i--)
            a_VecChr_din4(_a_ d1p[d1i].typs, d1p[d1i].def, 0, 0);
        a_VecChr_din(_a_ &anp[ani]);
    }
    a_free(_a_ (char *) p->elm->k, p->elm->n);
    a_VecChr_din(_a_ p->vc);
    a_free(_a_ p,  sizeof(a_Preprocessor_Define0));
}

a_static a_VecChr *a_Preprocessor_findDef(a_Set0 *set, char *t, a_Token0 *t0, a_VecChr *tmp, int rmvFlg, intptr_t *repLen)
{
    intptr_t n = t0->len, i;
    a_Preprocessor_Define0 *pd = a_Set0_findKn(set, t, n);
    if (pd == NULL) return NULL;
    a_VecChr *vcp = (a_VecChr *) pd->vc->p;
    intptr_t vcn = a_VecChr_N(pd->vc) / sizeof (a_VecChr), an, def1n, rl = n;
    a_Preprocessor_Define1 *def1p;
    if (t + n < t0->s1 && t[n] == '(') {
        a_Token1_get(t0);
        a_parseArgs(t0, tmp);
        an = a_VecChr_N(tmp) / sizeof (a_parseArgs_Arg);
        if (an + 1 >= vcn) goto skip;
        def1n = a_VecChr_N(&vcp[an + 1]) / sizeof (a_Preprocessor_Define1);
        if (def1n == 0) goto skip;
        def1p = (a_Preprocessor_Define1 *) vcp[an + 1].p;
        rl = t0->s - t;
        for (i = def1n - 1; i >= 0; i--) {
            if (a_TypedDef_cmpTyps(def1p[i].typs, (a_parseArgs_Arg *) tmp->p, an) != 0) goto find;
        }
    }
skip:
    an = -1;
    def1n = a_VecChr_N(&vcp[0]) / sizeof (a_Preprocessor_Define1);;
    def1p = (a_Preprocessor_Define1 *) vcp[0].p;
    if (def1n == 0) return NULL;
    i = def1n - 1;
find:
    if (rmvFlg != 0) {
        a_VecChr_din4(_a_ def1p[i].typs, def1p[i].def, 0, 0);
        a_VecChr_replace(&vcp[an + 1], i * sizeof (a_Preprocessor_Define1), sizeof (a_Preprocessor_Define1), NULL, 0);
        while (vcn > 0) {
            if (a_VecChr_N(&vcp[vcn - 1]) > 0) break;
            a_VecChr_din(_a_ &vcp[vcn - 1]);
            vcn--;
        }
        a_VecChr_N(pd->vc) = vcn * sizeof (a_VecChr);
        if (vcn == 0) {
            a_SetElm elm[1];
            elm->k = t;
            elm->n = n;
            a_Set0_rmv(set, elm);
            a_VecChr_din(_a_ pd->vc);
        }
        return NULL;
    }
    *repLen = rl;
    return def1p[i].def;
}

a_static int a_Preprocessor_substitute1(a_Token0 *t0, a_Token0 *t0a, a_VecChr *lin, uint32_t stpTkn, a_Set0 *set, a_VecChr *tmp, a_VecChr *tmp1, int defC)
{
    char *p = lin->p; t0a->s1 = t0->s1 = p + a_VecChr_N(lin);
    a_Preprocessor_Define0 *pd;
    for (t0->s = p;;) {
        char *t = a_Token1_get(t0), *u; intptr_t repLen;
        if (t0->len == 0 || t0->c == stpTkn) break;
        if (t0->cTyp != 3) continue;
        if (t0->len == 7 && &t[7] < t0->s1 && memcmp(t, "defined(", 8) == 0) {
            t0a->s = &t[8]; a_parseArgs(t0a, tmp);
            if (t0a->c == ')' && a_VecChr_N(tmp) == sizeof (a_parseArgs_Arg)) {
                a_parseArgs_Arg *paa = (a_parseArgs_Arg *) tmp->p;
                pd = a_Set0_findKn(set, paa->s, paa->n);
defined1: ;
                char c = '0';
                if (pd != NULL) c = '1';
                a_VecChr_replace(lin, t - p, t0a->s - t, &c, 1);
                return 1;
            }
        }
        if (t0->len == 7 && memcmp(t, "defined", 7) == 0) {
            t0a->s = &t[7]; u = a_Token1_get(t0a);
            pd = a_Set0_findKn(set, u, t0a->len);
            goto defined1;
        }
        if (t0->len == 8 && &t[8] < t0->s1 && memcmp(t, "definedx(", 9) == 0) {
            t0a->s = &t[9]; t = a_Token1_get(t0a);
            char c = '0';
            if (a_Preprocessor_findDef(set, t, t0a, tmp, 0, &repLen) != 0) c = '1';
            a_VecChr_replace(lin, t - p, repLen, &c, 1);
            return 1;
        }
        // マクロ展開.
        t0a->s = t; t = a_Token1_get(t0a);
        a_VecChr *def = a_Preprocessor_findDef(set, t, t0a, tmp, 0, &repLen);
        a_parseArgs_Arg *paa = (a_parseArgs_Arg *) tmp->p;
        if (def != NULL) {
            a_VecChr_resize(tmp1, a_VecChr_N(def));
            memcpy(tmp1->p, def->p, a_VecChr_N(def));
            for (;;) {
                char *q = memchr(tmp1->p, defC, a_VecChr_N(tmp1));
                if (q == NULL) break;
                int i = ((unsigned char *) q)[1] - defC;
                a_VecChr_replace(tmp1, q - tmp1->p, 2, paa[i].s, paa[i].n); // 引数を代入.
            }
            a_VecChr_replace(lin, t - p, repLen, tmp1->p, a_VecChr_N(tmp1));
            return 1;
        }
    }
    return 0;
}

a_static void a_Preprocessor_marking0(a_VecChr *tmp, a_parseArgs_Arg *paa, intptr_t an, intptr_t as, int c, a_Token0 *t0)
// #defineの引数を [01 01] とか [01 02] などに置換する.
{
    int i;
    a_Set0 set[1]; a_Set0_ini(_a_ set, NULL); a_SetElm elm[256];
    char mark[2], *t; mark[0] = (char) c;
    if (an + c > 256) a_errExit("Preprocessor_define1: too many args (c=%d, an=%d)", c, an);
    for (i = 0; i < an; i++) {
        elm[i].k = paa->s;
        elm[i].n = paa->n;
        paa += as;
        a_Set0_add(set, &elm[i]);
    }
    t0->s = tmp->p; t0->s1 = tmp->p + a_VecChr_N(tmp); a_VecChr_N(tmp) = 0;
    for (;;) {
        t = a_Token1_get(t0);
        if (t0->len == 0) break;
        a_VecChr_N(tmp) = t + t0->len - tmp->p;
    }
    t0->s = tmp->p; t0->s1 = tmp->p + a_VecChr_N(tmp);
    for (;;) {
        t = a_Token1_get(t0);
        if (t0->len == 0) break;
        if (t0->len >= 2 && t[0] == '/' && t[1] == '/') {
            a_VecChr_N(tmp) = t - tmp->p; // コメントが後続しているならそこから打ち切る。
            break;
        }
    }
    while (a_VecChr_N(tmp) > 0 && ((unsigned char *) tmp->p)[a_VecChr_N(tmp) - 1] <= ' ') a_VecChr_N(tmp)--;
    t0->s = tmp->p; t0->s1 = tmp->p + a_VecChr_N(tmp);
    for (;;) {
        t = a_Token1_get(t0);
        if (t0->len == 0) break;
        a_SetElm *e = a_Set0_findKn(set, t, t0->len);
        if (e != NULL) {
            mark[1] = (char) (c + (e - elm));
            intptr_t pos0 = t - tmp->p;
            a_VecChr_replace(tmp, pos0, t0->len, mark, 2); // 変数名を [01 xx] に置換.
            t0->s = tmp->p + pos0 + t0->len;
            t0->s1 = tmp->p + a_VecChr_N(tmp);
        }
    }
    a_Set0_din(_a_ set);
}

a_static void a_Preprocessor_marking1(a_VecChr *tmp, a_parseArgs_Arg *paa, intptr_t an, intptr_t as, int c, a_VecChr *tmp1)
{
    int i; // Token1_getをあえて使わずに、strstrで見つけて置換していく.
    for (i = 0; i < an; i++) {
        a_VecChr_N(tmp1) = 0;
        a_VecChr_puts(tmp1, paa->s, paa->n);
        char *p = strstr(tmp->p, tmp1->p), mark[2];
        mark[0] = (char) c;
        mark[1] = (char) (c + i);
        while (p != NULL) {
            intptr_t pos = p - tmp->p;
            a_VecChr_replace(tmp, pos, a_VecChr_N(tmp1), mark, 2);
            p = strstr(tmp->p + pos + 2, tmp1->p);
        }
        paa += as;
    }
}

a_static void a_Preprocessor_define0(a_Set0 *set, const char *s, intptr_t sn, const char *t, intptr_t tn, intptr_t an, a_Set0 *typCache, a_parseArgs_Arg *tyPaa, intptr_t as, a_Token0 *t0a, a_VecChr *tmp)
{
    a_Preprocessor_Define0 *pd0 = a_Set0_findKn(set, s, sn);
    if (pd0 == NULL) {
        pd0 = a_malloc(_a_ sizeof (a_Preprocessor_Define0));
        a_SetElm_mallocCpy(pd0->elm, s, sn);
        a_VecChr_ini(_a_ pd0->vc);
        a_Set0_add(set, pd0->elm);
    }
    while ((an + 1) * sizeof (a_VecChr) >= (unsigned int) a_VecChr_N(pd0->vc)) {
        a_VecChr *tvc = a_VecChr_stkAdd(pd0->vc, sizeof (a_VecChr));
        a_VecChr_ini(_a_ tvc);
    }
    a_VecChr *vcp = (a_VecChr *) pd0->vc->p;
    a_Preprocessor_Define1 *pd1 = a_VecChr_stkAdd(&vcp[an + 1], sizeof (a_Preprocessor_Define1));
    a_VecChr_ini(_a_ pd1->typs);
    a_VecChr_iniCpy(_a_ pd1->def, t, tn);
    if (an > 0 && tyPaa != NULL) {
        a_VecChr_resize(pd1->typs, an * sizeof (a_VecChr *));
        a_VecChr **tp = (a_VecChr **) pd1->typs->p;
        intptr_t i;
        for (i = 0; i < an; i++) {
            tp[i] = a_TypedDef_getTypeList(typCache, tyPaa->s, tyPaa->n, t0a, tmp);
            tyPaa += as;
        }
    }
}

a_static void a_Preprocessor_define1(int mod, a_Token0 *t0, a_VecChr *lin, a_Preprocessor_SourceFiles *sfs, a_VecChr *args, a_VecChr *tmp, a_VecChr *tmp1, a_Set0 *set, int defC, a_Set0 *typCache)
{
    char *k = a_Token1_get(t0); intptr_t kn = t0->len, an = -1;
    if (k[kn] == '(') {
        t0->s++; a_parseArgs(t0, args);
        if (t0->len == 0) return;
        an = a_VecChr_N(args) / sizeof (a_parseArgs_Arg);
        if (an + defC > 256) a_errExit("Preprocessor_define1: too many args (c=%d, n=%d)", defC, an);
    }
    if (mod == 1 && an < 2) return;
    char *t = a_Token1_get(t0), *s1 = lin->p + a_VecChr_N(lin);
    a_VecChr_replace(tmp, 0, a_VecChr_N(tmp), t, s1 - t);
    a_VecChr_reserve0(tmp);
    int mod1 = 0;
    if (t + 1 < s1 && t[0] == '[' && t[1] == '^') {
        mod1 = 1;
        a_VecChr_replace(tmp, 0, 2, NULL, 0);
        int mc = 1;
        char *u = strstr(tmp->p, "^]");
        if (u != NULL) {
            mc = 0;
            a_VecChr_N(tmp) = u - tmp->p;
        }
        while (mc > 0) {
            a_Preprocessor_SourceFiles_gets(sfs, tmp1);
            if (a_VecChr_N(tmp1) == 0) break;
            u = strstr(tmp1->p, "^]");
            if (strstr(tmp1->p, "[^") != NULL) mc++;
            if (u != NULL) mc--;
            if (mc > 0)
                a_VecChr_replace(tmp, a_VecChr_N(tmp), 0, tmp1->p, a_VecChr_N(tmp1));
            else
                a_VecChr_replace(tmp, a_VecChr_N(tmp), 0, tmp1->p, u - tmp1->p);
        }
    } else {
        while (a_VecChr_N(tmp) > 0 && tmp->p[a_VecChr_N(tmp) - 1] <= ' ') a_VecChr_N(tmp)--;
    }
    if (mod1 == 0)
        a_Preprocessor_marking0(tmp, ((a_parseArgs_Arg *) args->p) + mod, an >> mod, mod + 1, defC, t0);
    else
        a_Preprocessor_marking1(tmp, ((a_parseArgs_Arg *) args->p) + mod, an >> mod, mod + 1, defC, tmp1);
    if (mod == 0)
        a_Preprocessor_define0(set, k, kn, tmp->p, a_VecChr_N(tmp), an >> mod, NULL, NULL, 0, t0, tmp1);
    else
        a_Preprocessor_define0(set, k, kn, tmp->p, a_VecChr_N(tmp), an >> mod, typCache, (a_parseArgs_Arg *) args->p, 2, t0, tmp1);
}

a_static void a_Preprocessor_define2(int mod, const char *s, a_Token0 *t0, a_Set0 *set, int defC, a_Set0 *typCache)
{
    a_VecChr lin[1], args[1], tmp[1], tmp1[1]; a_VecChr_ini4(_a_ lin, args, tmp, tmp1);
    a_VecChr_puts(lin, s, -1); t0->s = lin->p; t0->s1 = lin->p + a_VecChr_N(lin); 
    a_Preprocessor_define1(mod, t0, lin, NULL, args, tmp, tmp1, set, defC, typCache);
    a_VecChr_din4(_a_ lin, args, tmp, tmp1);
}

(99) 更新履歴

  • 2026.04.26(日) 初版
  • 2026.05.03(日) defLeft, defMid を追加

トップ   編集 凍結 差分 バックアップ 添付 複製 名前変更 リロード   新規 一覧 単語検索 最終更新   ヘルプ   最終更新のRSS
Last-modified: 2026-05-03 (日) 23:31:12 (43d)