lbbs/src/lml.c

/***************************************************************************
                                                        lml.h  -  description
                                                         -------------------
        Copyright            : (C) 2004-2025 by Leaflet
        Email                : leaflet@leafok.com
 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 3 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/

#include "common.h"
#include "lml.h"
#include "log.h"
#include <stdio.h>
#include <string.h>
#include <sys/param.h>

#define LML_TAG_PARAM_BUF_LEN 256
#define LML_TAG_OUTPUT_BUF_LEN 1024

typedef int (*lml_tag_filter_cb)(const char *tag_name, const char *tag_param_buf, char *tag_output_buf, size_t tag_output_buf_len);

static int lml_tag_color_filter(const char *tag_name, const char *tag_param_buf, char *tag_output_buf, size_t tag_output_buf_len)
{
        if (strcasecmp(tag_name, "color") == 0)
        {
                if (strcasecmp(tag_param_buf, "red") == 0)
                {
                        return snprintf(tag_output_buf, tag_output_buf_len, "\033[1;31m");
                }
                else if (strcasecmp(tag_param_buf, "green") == 0)
                {
                        return snprintf(tag_output_buf, tag_output_buf_len, "\033[1;32m");
                }
                else if (strcasecmp(tag_param_buf, "yellow") == 0)
                {
                        return snprintf(tag_output_buf, tag_output_buf_len, "\033[1;33m");
                }
                else if (strcasecmp(tag_param_buf, "blue") == 0)
                {
                        return snprintf(tag_output_buf, tag_output_buf_len, "\033[1;34m");
                }
                else if (strcasecmp(tag_param_buf, "magenta") == 0)
                {
                        return snprintf(tag_output_buf, tag_output_buf_len, "\033[1;35m");
                }
                else if (strcasecmp(tag_param_buf, "cyan") == 0)
                {
                        return snprintf(tag_output_buf, tag_output_buf_len, "\033[1;36m");
                }
                else if (strcasecmp(tag_param_buf, "black") == 0)
                {
                        return snprintf(tag_output_buf, tag_output_buf_len, "\033[1;30;47m");
                }
        }
        return 0;
}

#define LML_TAG_QUOTE_MAX_LEVEL 10
#define LML_TAG_QUOTE_LEVEL_LOOP 3

static const char *lml_tag_quote_color[] = {
        "\033[33m", // yellow
        "\033[32m", // green
        "\033[35m", // magenta
};

static int lml_tag_quote_level = 0;

static int lml_tag_quote_filter(const char *tag_name, const char *tag_param_buf, char *tag_output_buf, size_t tag_output_buf_len)
{
        if (strcasecmp(tag_name, "quote") == 0)
        {
                if (lml_tag_quote_level <= LML_TAG_QUOTE_MAX_LEVEL)
                {
                        lml_tag_quote_level++;
                }
                return snprintf(tag_output_buf, tag_output_buf_len, lml_tag_quote_color[lml_tag_quote_level % LML_TAG_QUOTE_LEVEL_LOOP]);
        }
        else if (strcasecmp(tag_name, "/quote") == 0)
        {
                if (lml_tag_quote_level > 0)
                {
                        lml_tag_quote_level--;
                }
                return snprintf(tag_output_buf, tag_output_buf_len,
                                                (lml_tag_quote_level > 0 ? lml_tag_quote_color[lml_tag_quote_level % LML_TAG_QUOTE_LEVEL_LOOP] : "\033[m"));
        }

        return 0;
}

const static char *LML_tag_def[][3] = {
        {"left", "[", ""},
        {"right", "]", NULL},
        {"bold", "\033[1m", ""}, // does not work in Fterm
        {"/bold", "\033[22m", NULL},
        {"b", "\033[1m", ""},
        {"/b", "\033[22m", NULL},
        {"italic", "\033[5m", ""},       // use blink instead
        {"/italic", "\033[m", NULL}, // \033[25m does not work in Fterm
        {"i", "\033[5m", ""},
        {"/i", "\033[m", NULL},
        {"underline", "\033[4m", ""},
        {"/underline", "\033[m", NULL}, // \033[24m does not work in Fterm
        {"u", "\033[4m", ""},
        {"/u", "\033[m", NULL},
        {"color", NULL, (const char *)lml_tag_color_filter},
        {"/color", "\033[m", NULL},
        {"quote", NULL, (const char *)lml_tag_quote_filter},
        {"/quote", NULL, (const char *)lml_tag_quote_filter},
        {"url", "", ""},
        {"/url", "(链接: %s)", NULL},
        {"link", "", ""},
        {"/link", "(链接: %s)", NULL},
        {"email", "", ""},
        {"/email", "(Email: %s)", NULL},
        {"user", "", ""},
        {"/user", "(用户: %s)", NULL},
        {"article", "", ""},
        {"/article", "(文章: %s)", NULL},
        {"image", "(图片: %s)", ""},
        {"flash", "(Flash: %s)", ""},
        {"bwf", "\033[1;31m****\033[m", ""},
};

#define LML_TAG_COUNT 31

static int LML_tag_name_len[LML_TAG_COUNT];
static int LML_init = 0;

inline static void lml_init(void)
{
        int i;

        if (!LML_init)
        {
                for (i = 0; i < LML_TAG_COUNT; i++)
                {
                        LML_tag_name_len[i] = (int)strlen(LML_tag_def[i][0]);
                }

                LML_init = 1;
        }
}

int lml_plain(const char *str_in, char *str_out, int buf_len)
{
        char c;
        char tag_param_buf[LML_TAG_PARAM_BUF_LEN];
        char tag_output_buf[LML_TAG_OUTPUT_BUF_LEN];
        int i;
        int j = 0;
        int k;
        int tag_start_pos = -1;
        int tag_end_pos = -1;
        int tag_param_pos = -1;
        int tag_output_len;
        int new_line = 1;
        int fb_quote_level = 0;

        lml_init();

        lml_tag_quote_level = 0;

        for (i = 0; str_in[i] != '\0'; i++)
        {
                if (new_line)
                {
                        if (fb_quote_level > 0)
                        {
                                lml_tag_quote_level -= fb_quote_level;

                                tag_output_len = snprintf(tag_output_buf, LML_TAG_OUTPUT_BUF_LEN,
                                                                                  (lml_tag_quote_level > 0 ? lml_tag_quote_color[lml_tag_quote_level % LML_TAG_QUOTE_LEVEL_LOOP] : "\033[m"));
                                if (j + tag_output_len >= buf_len)
                                {
                                        log_error("Buffer is not longer enough for output string %d >= %d\n", j + tag_output_len, buf_len);
                                        str_out[j] = '\0';
                                        return j;
                                }
                                memcpy(str_out + j, tag_output_buf, (size_t)tag_output_len);
                                j += tag_output_len;

                                fb_quote_level = 0;
                        }

                        while (str_in[i + fb_quote_level * 2] == ':' && str_in[i + fb_quote_level * 2 + 1] == ' ') // FB2000 quote leading str
                        {
                                fb_quote_level++;
                        }

                        if (fb_quote_level > 0)
                        {
                                lml_tag_quote_level += fb_quote_level;

                                tag_output_len = snprintf(tag_output_buf, LML_TAG_OUTPUT_BUF_LEN,
                                                                                  lml_tag_quote_color[(lml_tag_quote_level) % LML_TAG_QUOTE_LEVEL_LOOP]);
                                if (j + tag_output_len >= buf_len)
                                {
                                        log_error("Buffer is not longer enough for output string %d >= %d\n", j + tag_output_len, buf_len);
                                        str_out[j] = '\0';
                                        return j;
                                }
                                memcpy(str_out + j, tag_output_buf, (size_t)tag_output_len);
                                j += tag_output_len;
                        }

                        new_line = 0;
                }

                if (str_in[i] == '\033' && str_in[i + 1] == '[') // Escape sequence -- copy directly
                {
                        for (k = i + 2; str_in[k] != '\0' && str_in[k] != 'm'; k++)
                                ;

                        if (str_in[k] == 'm') // Valid
                        {
                                if (j + (k - i + 1) >= buf_len)
                                {
                                        log_error("Buffer is not longer enough for output string %d >= %d\n", j + (k - i + 1), buf_len);
                                        str_out[j] = '\0';
                                        return j;
                                }
                                memcpy(str_out + j, str_in + i, (size_t)(k - i + 1));
                                j += (k - i + 1);
                                i = k;
                                continue;
                        }
                        else // reach end of string
                        {
                                break;
                        }
                }

                if (str_in[i] == '\n')
                {
                        tag_start_pos = -1; // jump out of tag at end of line
                        new_line = 1;
                }
                else if (str_in[i] == '\r')
                {
                        continue; // ignore '\r'
                }

                if (str_in[i] == '[')
                {
                        tag_start_pos = i + 1;
                }
                else if (str_in[i] == ']')
                {
                        if (tag_start_pos >= 0)
                        {
                                tag_end_pos = i;

                                // Skip space characters
                                while (str_in[tag_start_pos] == ' ')
                                {
                                        tag_start_pos++;
                                }

                                for (k = 0; k < LML_TAG_COUNT; k++)
                                {
                                        if (strncasecmp(LML_tag_def[k][0], str_in + tag_start_pos, (size_t)LML_tag_name_len[k]) == 0)
                                        {
                                                tag_param_pos = -1;
                                                switch (str_in[tag_start_pos + LML_tag_name_len[k]])
                                                {
                                                case ' ':
                                                        tag_param_pos = tag_start_pos + LML_tag_name_len[k] + 1;
                                                        while (str_in[tag_param_pos] == ' ')
                                                        {
                                                                tag_param_pos++;
                                                        }
                                                        strncpy(tag_param_buf, str_in + tag_param_pos, (size_t)MIN(tag_end_pos - tag_param_pos, LML_TAG_PARAM_BUF_LEN));
                                                        tag_param_buf[MIN(tag_end_pos - tag_param_pos, LML_TAG_PARAM_BUF_LEN)] = '\0';
                                                case ']':
                                                        if (tag_param_pos == -1 && LML_tag_def[k][1] != NULL && LML_tag_def[k][2] != NULL) // Apply default param if not defined
                                                        {
                                                                strncpy(tag_param_buf, LML_tag_def[k][2], LML_TAG_PARAM_BUF_LEN - 1);
                                                                tag_param_buf[LML_TAG_PARAM_BUF_LEN - 1] = '\0';
                                                        }
                                                        if (LML_tag_def[k][1] != NULL)
                                                        {
                                                                tag_output_len = snprintf(tag_output_buf, LML_TAG_OUTPUT_BUF_LEN, LML_tag_def[k][1], tag_param_buf);
                                                        }
                                                        else
                                                        {
                                                                tag_output_len = ((lml_tag_filter_cb)LML_tag_def[k][2])(
                                                                        LML_tag_def[k][0], tag_param_buf, tag_output_buf, LML_TAG_OUTPUT_BUF_LEN);
                                                        }
                                                        if (j + tag_output_len >= buf_len)
                                                        {
                                                                log_error("Buffer is not longer enough for output string %d >= %d\n", j + tag_output_len, buf_len);
                                                                str_out[j] = '\0';
                                                                return j;
                                                        }
                                                        memcpy(str_out + j, tag_output_buf, (size_t)tag_output_len);
                                                        j += tag_output_len;
                                                        break;
                                                default: // tag_name not match
                                                        continue;
                                                }
                                                break;
                                        }
                                }

                                tag_start_pos = -1;
                        }
                }
                else if (tag_start_pos == -1) // not in LML tag
                {
                        if (str_in[i] & 0b10000000) // head of multi-byte character
                        {
                                if (j + 4 >= buf_len) // Assuming UTF-8 CJK characters use 4 bytes, though most of them actually use 3 bytes
                                {
                                        log_error("Buffer is not longer enough for output string %ld >= %d\n", j + 4, buf_len);
                                        str_out[j] = '\0';
                                        return j;
                                }

                                c = (str_in[i] & 0b01110000) << 1;
                                while (c & 0b10000000)
                                {
                                        str_out[j++] = str_in[i++];
                                        if (str_in[i] == '\0')
                                        {
                                                str_out[j] = '\0';
                                                return j;
                                        }
                                        c = (c & 0b01111111) << 1;
                                }
                        }

                        if (j + 1 >= buf_len)
                        {
                                log_error("Buffer is not longer enough for output string %ld >= %d\n", j + 1, buf_len);
                                str_out[j] = '\0';
                                return j;
                        }
                        str_out[j++] = str_in[i];
                }
                else // in LML tag
                {
                        // Do nothing
                }
        }

        if (lml_tag_quote_level > 0)
        {
                tag_output_len = snprintf(tag_output_buf, LML_TAG_OUTPUT_BUF_LEN, "\033[m");
                if (j + tag_output_len >= buf_len)
                {
                        log_error("Buffer is not longer enough for output string %d >= %d\n", j + tag_output_len, buf_len);
                        str_out[j] = '\0';
                        return j;
                }
                memcpy(str_out + j, tag_output_buf, (size_t)tag_output_len);
                j += tag_output_len;
        }

        str_out[j] = '\0';

        return j;
}
1	sysadm	1.1	/***************************************************************************
2			lml.h - description
3			-------------------
4			Copyright : (C) 2004-2025 by Leaflet
5			Email : leaflet@leafok.com
6			***************************************************************************/
7
8			/***************************************************************************
9			* *
10			* This program is free software; you can redistribute it and/or modify *
11			* it under the terms of the GNU General Public License as published by *
12			* the Free Software Foundation; either version 3 of the License, or *
13			* (at your option) any later version. *
14			* *
15			***************************************************************************/
16
17	sysadm	1.12	#include "common.h"
18	sysadm	1.1	#include "lml.h"
19			#include "log.h"
20			#include <stdio.h>
21			#include <string.h>
22			#include <sys/param.h>
23
24	sysadm	1.2	#define LML_TAG_PARAM_BUF_LEN 256
25			#define LML_TAG_OUTPUT_BUF_LEN 1024
26	sysadm	1.1
27	sysadm	1.3	typedef int (lml_tag_filter_cb)(const char tag_name, const char tag_param_buf, char tag_output_buf, size_t tag_output_buf_len);
28
29			static int lml_tag_color_filter(const char tag_name, const char tag_param_buf, char *tag_output_buf, size_t tag_output_buf_len)
30			{
31			if (strcasecmp(tag_name, "color") == 0)
32			{
33			if (strcasecmp(tag_param_buf, "red") == 0)
34			{
35			return snprintf(tag_output_buf, tag_output_buf_len, "\033[1;31m");
36			}
37			else if (strcasecmp(tag_param_buf, "green") == 0)
38			{
39			return snprintf(tag_output_buf, tag_output_buf_len, "\033[1;32m");
40			}
41			else if (strcasecmp(tag_param_buf, "yellow") == 0)
42			{
43			return snprintf(tag_output_buf, tag_output_buf_len, "\033[1;33m");
44			}
45			else if (strcasecmp(tag_param_buf, "blue") == 0)
46			{
47			return snprintf(tag_output_buf, tag_output_buf_len, "\033[1;34m");
48			}
49			else if (strcasecmp(tag_param_buf, "magenta") == 0)
50			{
51			return snprintf(tag_output_buf, tag_output_buf_len, "\033[1;35m");
52			}
53			else if (strcasecmp(tag_param_buf, "cyan") == 0)
54			{
55			return snprintf(tag_output_buf, tag_output_buf_len, "\033[1;36m");
56			}
57			else if (strcasecmp(tag_param_buf, "black") == 0)
58			{
59			return snprintf(tag_output_buf, tag_output_buf_len, "\033[1;30;47m");
60			}
61			}
62			return 0;
63			}
64	sysadm	1.1
65	sysadm	1.4	#define LML_TAG_QUOTE_MAX_LEVEL 10
66			#define LML_TAG_QUOTE_LEVEL_LOOP 3
67
68			static const char *lml_tag_quote_color[] = {
69	sysadm	1.5	"\033[33m", // yellow
70			"\033[32m", // green
71			"\033[35m", // magenta
72	sysadm	1.4	};
73
74			static int lml_tag_quote_level = 0;
75
76			static int lml_tag_quote_filter(const char tag_name, const char tag_param_buf, char *tag_output_buf, size_t tag_output_buf_len)
77			{
78			if (strcasecmp(tag_name, "quote") == 0)
79			{
80			if (lml_tag_quote_level <= LML_TAG_QUOTE_MAX_LEVEL)
81			{
82			lml_tag_quote_level++;
83			}
84			return snprintf(tag_output_buf, tag_output_buf_len, lml_tag_quote_color[lml_tag_quote_level % LML_TAG_QUOTE_LEVEL_LOOP]);
85			}
86			else if (strcasecmp(tag_name, "/quote") == 0)
87			{
88			if (lml_tag_quote_level > 0)
89			{
90			lml_tag_quote_level--;
91			}
92	sysadm	1.5	return snprintf(tag_output_buf, tag_output_buf_len,
93			(lml_tag_quote_level > 0 ? lml_tag_quote_color[lml_tag_quote_level % LML_TAG_QUOTE_LEVEL_LOOP] : "\033[m"));
94	sysadm	1.4	}
95
96			return 0;
97			}
98
99	sysadm	1.2	const static char *LML_tag_def[][3] = {
100			{"left", "[", ""},
101			{"right", "]", NULL},
102	sysadm	1.6	{"bold", "\033[1m", ""}, // does not work in Fterm
103	sysadm	1.5	{"/bold", "\033[22m", NULL},
104	sysadm	1.3	{"b", "\033[1m", ""},
105	sysadm	1.5	{"/b", "\033[22m", NULL},
106	sysadm	1.7	{"italic", "\033[5m", ""}, // use blink instead
107	sysadm	1.6	{"/italic", "\033[m", NULL}, // \033[25m does not work in Fterm
108	sysadm	1.5	{"i", "\033[5m", ""},
109	sysadm	1.6	{"/i", "\033[m", NULL},
110	sysadm	1.2	{"underline", "\033[4m", ""},
111	sysadm	1.6	{"/underline", "\033[m", NULL}, // \033[24m does not work in Fterm
112	sysadm	1.2	{"u", "\033[4m", ""},
113	sysadm	1.6	{"/u", "\033[m", NULL},
114	sysadm	1.3	{"color", NULL, (const char *)lml_tag_color_filter},
115			{"/color", "\033[m", NULL},
116	sysadm	1.4	{"quote", NULL, (const char *)lml_tag_quote_filter},
117			{"/quote", NULL, (const char *)lml_tag_quote_filter},
118	sysadm	1.2	{"url", "", ""},
119	sysadm	1.13	{"/url", "(链接: %s)", NULL},
120	sysadm	1.2	{"link", "", ""},
121	sysadm	1.13	{"/link", "(链接: %s)", NULL},
122	sysadm	1.2	{"email", "", ""},
123			{"/email", "(Email: %s)", NULL},
124			{"user", "", ""},
125	sysadm	1.13	{"/user", "(用户: %s)", NULL},
126	sysadm	1.2	{"article", "", ""},
127	sysadm	1.13	{"/article", "(文章: %s)", NULL},
128			{"image", "(图片: %s)", ""},
129	sysadm	1.2	{"flash", "(Flash: %s)", ""},
130	sysadm	1.3	{"bwf", "\033[1;31m****\033[m", ""},
131	sysadm	1.1	};
132
133	sysadm	1.4	#define LML_TAG_COUNT 31
134	sysadm	1.3
135	sysadm	1.1	static int LML_tag_name_len[LML_TAG_COUNT];
136			static int LML_init = 0;
137
138			inline static void lml_init(void)
139			{
140			int i;
141
142			if (!LML_init)
143			{
144			for (i = 0; i < LML_TAG_COUNT; i++)
145			{
146	sysadm	1.2	LML_tag_name_len[i] = (int)strlen(LML_tag_def[i][0]);
147	sysadm	1.1	}
148
149			LML_init = 1;
150			}
151			}
152
153			int lml_plain(const char str_in, char str_out, int buf_len)
154			{
155	sysadm	1.13	char c;
156	sysadm	1.2	char tag_param_buf[LML_TAG_PARAM_BUF_LEN];
157	sysadm	1.1	char tag_output_buf[LML_TAG_OUTPUT_BUF_LEN];
158			int i;
159			int j = 0;
160			int k;
161			int tag_start_pos = -1;
162			int tag_end_pos = -1;
163	sysadm	1.2	int tag_param_pos = -1;
164	sysadm	1.1	int tag_output_len;
165	sysadm	1.5	int new_line = 1;
166			int fb_quote_level = 0;
167	sysadm	1.1
168			lml_init();
169
170	sysadm	1.4	lml_tag_quote_level = 0;
171
172	sysadm	1.1	for (i = 0; str_in[i] != '\0'; i++)
173			{
174	sysadm	1.5	if (new_line)
175			{
176			if (fb_quote_level > 0)
177			{
178			lml_tag_quote_level -= fb_quote_level;
179
180			tag_output_len = snprintf(tag_output_buf, LML_TAG_OUTPUT_BUF_LEN,
181			(lml_tag_quote_level > 0 ? lml_tag_quote_color[lml_tag_quote_level % LML_TAG_QUOTE_LEVEL_LOOP] : "\033[m"));
182	sysadm	1.8	if (j + tag_output_len >= buf_len)
183	sysadm	1.5	{
184	sysadm	1.8	log_error("Buffer is not longer enough for output string %d >= %d\n", j + tag_output_len, buf_len);
185	sysadm	1.5	str_out[j] = '\0';
186			return j;
187			}
188			memcpy(str_out + j, tag_output_buf, (size_t)tag_output_len);
189			j += tag_output_len;
190
191			fb_quote_level = 0;
192			}
193
194			while (str_in[i + fb_quote_level * 2] == ':' && str_in[i + fb_quote_level * 2 + 1] == ' ') // FB2000 quote leading str
195			{
196			fb_quote_level++;
197			}
198
199			if (fb_quote_level > 0)
200			{
201			lml_tag_quote_level += fb_quote_level;
202
203			tag_output_len = snprintf(tag_output_buf, LML_TAG_OUTPUT_BUF_LEN,
204			lml_tag_quote_color[(lml_tag_quote_level) % LML_TAG_QUOTE_LEVEL_LOOP]);
205	sysadm	1.8	if (j + tag_output_len >= buf_len)
206	sysadm	1.5	{
207	sysadm	1.8	log_error("Buffer is not longer enough for output string %d >= %d\n", j + tag_output_len, buf_len);
208	sysadm	1.5	str_out[j] = '\0';
209			return j;
210			}
211			memcpy(str_out + j, tag_output_buf, (size_t)tag_output_len);
212			j += tag_output_len;
213			}
214
215			new_line = 0;
216			}
217
218	sysadm	1.8	if (str_in[i] == '\033' && str_in[i + 1] == '[') // Escape sequence -- copy directly
219			{
220			for (k = i + 2; str_in[k] != '\0' && str_in[k] != 'm'; k++)
221			;
222
223			if (str_in[k] == 'm') // Valid
224			{
225			if (j + (k - i + 1) >= buf_len)
226			{
227			log_error("Buffer is not longer enough for output string %d >= %d\n", j + (k - i + 1), buf_len);
228			str_out[j] = '\0';
229			return j;
230			}
231			memcpy(str_out + j, str_in + i, (size_t)(k - i + 1));
232	sysadm	1.9	j += (k - i + 1);
233	sysadm	1.8	i = k;
234			continue;
235			}
236			else // reach end of string
237			{
238			break;
239			}
240			}
241
242	sysadm	1.5	if (str_in[i] == '\n')
243			{
244			tag_start_pos = -1; // jump out of tag at end of line
245			new_line = 1;
246			}
247			else if (str_in[i] == '\r')
248			{
249			continue; // ignore '\r'
250			}
251
252	sysadm	1.1	if (str_in[i] == '[')
253			{
254			tag_start_pos = i + 1;
255			}
256			else if (str_in[i] == ']')
257			{
258			if (tag_start_pos >= 0)
259			{
260			tag_end_pos = i;
261
262			// Skip space characters
263			while (str_in[tag_start_pos] == ' ')
264			{
265			tag_start_pos++;
266			}
267
268			for (k = 0; k < LML_TAG_COUNT; k++)
269			{
270	sysadm	1.2	if (strncasecmp(LML_tag_def[k][0], str_in + tag_start_pos, (size_t)LML_tag_name_len[k]) == 0)
271	sysadm	1.1	{
272	sysadm	1.2	tag_param_pos = -1;
273	sysadm	1.1	switch (str_in[tag_start_pos + LML_tag_name_len[k]])
274			{
275			case ' ':
276			tag_param_pos = tag_start_pos + LML_tag_name_len[k] + 1;
277			while (str_in[tag_param_pos] == ' ')
278			{
279			tag_param_pos++;
280			}
281	sysadm	1.2	strncpy(tag_param_buf, str_in + tag_param_pos, (size_t)MIN(tag_end_pos - tag_param_pos, LML_TAG_PARAM_BUF_LEN));
282			tag_param_buf[MIN(tag_end_pos - tag_param_pos, LML_TAG_PARAM_BUF_LEN)] = '\0';
283			case ']':
284	sysadm	1.3	if (tag_param_pos == -1 && LML_tag_def[k][1] != NULL && LML_tag_def[k][2] != NULL) // Apply default param if not defined
285	sysadm	1.1	{
286	sysadm	1.2	strncpy(tag_param_buf, LML_tag_def[k][2], LML_TAG_PARAM_BUF_LEN - 1);
287			tag_param_buf[LML_TAG_PARAM_BUF_LEN - 1] = '\0';
288	sysadm	1.1	}
289	sysadm	1.3	if (LML_tag_def[k][1] != NULL)
290			{
291			tag_output_len = snprintf(tag_output_buf, LML_TAG_OUTPUT_BUF_LEN, LML_tag_def[k][1], tag_param_buf);
292			}
293			else
294			{
295			tag_output_len = ((lml_tag_filter_cb)LML_tag_def[k][2])(
296			LML_tag_def[k][0], tag_param_buf, tag_output_buf, LML_TAG_OUTPUT_BUF_LEN);
297			}
298	sysadm	1.8	if (j + tag_output_len >= buf_len)
299	sysadm	1.1	{
300	sysadm	1.8	log_error("Buffer is not longer enough for output string %d >= %d\n", j + tag_output_len, buf_len);
301	sysadm	1.1	str_out[j] = '\0';
302			return j;
303			}
304			memcpy(str_out + j, tag_output_buf, (size_t)tag_output_len);
305			j += tag_output_len;
306			break;
307			default: // tag_name not match
308			continue;
309			}
310			break;
311			}
312			}
313
314			tag_start_pos = -1;
315			}
316			}
317			else if (tag_start_pos == -1) // not in LML tag
318			{
319	sysadm	1.13	if (str_in[i] & 0b10000000) // head of multi-byte character
320	sysadm	1.1	{
321	sysadm	1.13	if (j + 4 >= buf_len) // Assuming UTF-8 CJK characters use 4 bytes, though most of them actually use 3 bytes
322	sysadm	1.1	{
323	sysadm	1.13	log_error("Buffer is not longer enough for output string %ld >= %d\n", j + 4, buf_len);
324	sysadm	1.1	str_out[j] = '\0';
325			return j;
326			}
327	sysadm	1.13
328			c = (str_in[i] & 0b01110000) << 1;
329			while (c & 0b10000000)
330	sysadm	1.1	{
331	sysadm	1.13	str_out[j++] = str_in[i++];
332			if (str_in[i] == '\0')
333			{
334			str_out[j] = '\0';
335			return j;
336			}
337			c = (c & 0b01111111) << 1;
338	sysadm	1.1	}
339			}
340
341	sysadm	1.8	if (j + 1 >= buf_len)
342	sysadm	1.1	{
343	sysadm	1.8	log_error("Buffer is not longer enough for output string %ld >= %d\n", j + 1, buf_len);
344	sysadm	1.1	str_out[j] = '\0';
345			return j;
346			}
347			str_out[j++] = str_in[i];
348			}
349			else // in LML tag
350			{
351			// Do nothing
352			}
353			}
354
355	sysadm	1.5	if (lml_tag_quote_level > 0)
356			{
357			tag_output_len = snprintf(tag_output_buf, LML_TAG_OUTPUT_BUF_LEN, "\033[m");
358	sysadm	1.8	if (j + tag_output_len >= buf_len)
359	sysadm	1.5	{
360	sysadm	1.8	log_error("Buffer is not longer enough for output string %d >= %d\n", j + tag_output_len, buf_len);
361	sysadm	1.5	str_out[j] = '\0';
362			return j;
363			}
364			memcpy(str_out + j, tag_output_buf, (size_t)tag_output_len);
365			j += tag_output_len;
366			}
367
368	sysadm	1.1	str_out[j] = '\0';
369
370			return j;
371	sysadm	1.5	}
webmaster@leafok.com	ViewVC Help
Powered by ViewVC 1.3.0-beta1