lbbs/src/str_process.c

/***************************************************************************
                                                  str_process.c  -  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 "log.h"
#include "str_process.h"
#include <ctype.h>
#include <stdio.h>
#include <string.h>

int str_length(const char *str, int skip_ctrl_seq)
{
        int i;
        char c;
        int ret = 0;

        for (i = 0; str[i] != '\0'; i++)
        {
                c = str[i];

                if (c == '\r' || c == '\7') // skip
                {
                        continue;
                }

                if (skip_ctrl_seq && c == '\033' && str[i + 1] == '[') // Skip control sequence
                {
                        for (i = i + 2; isdigit(str[i]) || str[i] == ';' || str[i] == '?'; i++)
                                ;

                        if (str[i] == 'm') // valid
                        {
                                // skip
                        }
                        else if (isalpha(str[i]))
                        {
                                // unsupported ANSI CSI command
                        }
                        else
                        {
                                i--;
                        }

                        continue;
                }

                // Process UTF-8 Chinese characters
                if (c & 0x80) // head of multi-byte character
                {
                        c = (c & 0x70) << 1;
                        while (c & 0x80)
                        {
                                i++;
                                c = (c & 0x7f) << 1;
                        }

                        ret += 2;
                }
                else
                {
                        ret++;
                }
        }

        return ret;
}

int split_line(const char *buffer, int max_display_len, int *p_eol, int *p_display_len, int skip_ctrl_seq)
{
        int i;
        *p_eol = 0;
        *p_display_len = 0;
        char c;

        for (i = 0; buffer[i] != '\0'; i++)
        {
                c = buffer[i];

                if (c == '\r' || c == '\7') // skip
                {
                        continue;
                }

                if (skip_ctrl_seq && c == '\033' && buffer[i + 1] == '[') // Skip control sequence
                {
                        i += 2;
                        while (buffer[i] != '\0' && buffer[i] != 'm')
                        {
                                i++;
                        }
                        continue;
                }

                if (c & 0x80) // head of multi-byte character
                {
                        if (*p_display_len + 2 > max_display_len)
                        {
                                break;
                        }

                        c = (c & 0x70) << 1;
                        while (c & 0x80)
                        {
                                i++;
                                c = (c & 0x7f) << 1;
                        }

                        (*p_display_len) += 2;
                }
                else
                {
                        if (*p_display_len + 1 > max_display_len)
                        {
                                break;
                        }
                        (*p_display_len)++;

                        // \n is regarded as 1 character wide in terminal editor, which is different from Web version
                        if (c == '\n')
                        {
                                i++;
                                *p_eol = 1;
                                break;
                        }
                }
        }

        return i;
}

long split_data_lines(const char *p_buf, int max_display_len, long *p_line_offsets, long line_offsets_count,
                                          int skip_ctrl_seq, int *p_line_widths)
{
        int line_cnt = 0;
        int len;
        int end_of_line = 0;
        int display_len = 0;

        p_line_offsets[line_cnt] = 0L;

        do
        {
                len = split_line(p_buf, max_display_len, &end_of_line, &display_len, skip_ctrl_seq);

                if (p_line_widths)
                {
                        p_line_widths[line_cnt] = display_len;
                }

                // Exceed max_line_cnt
                if (line_cnt + 1 >= line_offsets_count)
                {
                        // log_error("Line count %d reaches limit %d\n", line_cnt + 1, line_offsets_count);
                        return line_cnt;
                }

                p_line_offsets[line_cnt + 1] = p_line_offsets[line_cnt] + len;
                line_cnt++;
                p_buf += len;
        } while (p_buf[0] != '\0');

        return line_cnt;
}

int str_filter(char *buffer, int skip_ctrl_seq)
{
        int i;
        int j;

        for (i = 0, j = 0; buffer[i] != '\0'; i++)
        {
                if (buffer[i] == '\r' || buffer[i] == '\7') // skip
                {
                        continue;
                }

                if (skip_ctrl_seq && buffer[i] == '\033' && buffer[i + 1] == '[') // Skip control sequence
                {
                        i += 2;
                        while (buffer[i] != '\0' && buffer[i] != 'm')
                        {
                                i++;
                        }
                        continue;
                }

                buffer[j] = buffer[i];
                j++;
        }

        buffer[j] = '\0';

        return j;
}
1	sysadm	1.1	/***************************************************************************
2			str_process.c - 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	sysadm	1.3	* the Free Software Foundation; either version 3 of the License, or *
13	sysadm	1.1	* (at your option) any later version. *
14			* *
15			***************************************************************************/
16
17			#include "common.h"
18			#include "log.h"
19	sysadm	1.18	#include "str_process.h"
20	sysadm	1.22	#include <ctype.h>
21	sysadm	1.1	#include <stdio.h>
22			#include <string.h>
23
24	sysadm	1.20	int str_length(const char *str, int skip_ctrl_seq)
25			{
26			int i;
27			char c;
28			int ret = 0;
29
30			for (i = 0; str[i] != '\0'; i++)
31			{
32			c = str[i];
33
34			if (c == '\r' \|\| c == '\7') // skip
35			{
36			continue;
37			}
38
39			if (skip_ctrl_seq && c == '\033' && str[i + 1] == '[') // Skip control sequence
40			{
41	sysadm	1.22	for (i = i + 2; isdigit(str[i]) \|\| str[i] == ';' \|\| str[i] == '?'; i++)
42			;
43
44			if (str[i] == 'm') // valid
45			{
46			// skip
47			}
48			else if (isalpha(str[i]))
49			{
50			// unsupported ANSI CSI command
51			}
52			else
53	sysadm	1.20	{
54	sysadm	1.22	i--;
55	sysadm	1.20	}
56	sysadm	1.22
57	sysadm	1.20	continue;
58			}
59
60			// Process UTF-8 Chinese characters
61	sysadm	1.21	if (c & 0x80) // head of multi-byte character
62	sysadm	1.20	{
63	sysadm	1.21	c = (c & 0x70) << 1;
64			while (c & 0x80)
65	sysadm	1.20	{
66			i++;
67	sysadm	1.21	c = (c & 0x7f) << 1;
68	sysadm	1.20	}
69
70			ret += 2;
71			}
72			else
73			{
74			ret++;
75			}
76			}
77
78			return ret;
79			}
80
81	sysadm	1.17	int split_line(const char buffer, int max_display_len, int p_eol, int *p_display_len, int skip_ctrl_seq)
82	sysadm	1.1	{
83	sysadm	1.7	int i;
84	sysadm	1.1	*p_eol = 0;
85	sysadm	1.4	*p_display_len = 0;
86	sysadm	1.11	char c;
87	sysadm	1.1
88	sysadm	1.7	for (i = 0; buffer[i] != '\0'; i++)
89	sysadm	1.1	{
90	sysadm	1.11	c = buffer[i];
91	sysadm	1.1
92			if (c == '\r' \|\| c == '\7') // skip
93			{
94			continue;
95			}
96
97	sysadm	1.17	if (skip_ctrl_seq && c == '\033' && buffer[i + 1] == '[') // Skip control sequence
98	sysadm	1.1	{
99			i += 2;
100	sysadm	1.7	while (buffer[i] != '\0' && buffer[i] != 'm')
101	sysadm	1.1	{
102			i++;
103			}
104			continue;
105			}
106
107	sysadm	1.21	if (c & 0x80) // head of multi-byte character
108	sysadm	1.1	{
109	sysadm	1.6	if (*p_display_len + 2 > max_display_len)
110	sysadm	1.1	{
111			break;
112			}
113	sysadm	1.20
114	sysadm	1.21	c = (c & 0x70) << 1;
115			while (c & 0x80)
116	sysadm	1.20	{
117			i++;
118	sysadm	1.21	c = (c & 0x7f) << 1;
119	sysadm	1.20	}
120
121	sysadm	1.10	(*p_display_len) += 2;
122	sysadm	1.1	}
123			else
124			{
125	sysadm	1.6	if (*p_display_len + 1 > max_display_len)
126	sysadm	1.1	{
127			break;
128			}
129	sysadm	1.4	(*p_display_len)++;
130	sysadm	1.12
131	sysadm	1.14	// \n is regarded as 1 character wide in terminal editor, which is different from Web version
132	sysadm	1.12	if (c == '\n')
133			{
134			i++;
135			*p_eol = 1;
136			break;
137			}
138	sysadm	1.1	}
139			}
140
141			return i;
142			}
143
144	sysadm	1.19	long split_data_lines(const char p_buf, int max_display_len, long p_line_offsets, long line_offsets_count,
145			int skip_ctrl_seq, int *p_line_widths)
146	sysadm	1.1	{
147	sysadm	1.7	int line_cnt = 0;
148	sysadm	1.13	int len;
149	sysadm	1.1	int end_of_line = 0;
150	sysadm	1.4	int display_len = 0;
151
152	sysadm	1.1	p_line_offsets[line_cnt] = 0L;
153
154	sysadm	1.13	do
155	sysadm	1.1	{
156	sysadm	1.17	len = split_line(p_buf, max_display_len, &end_of_line, &display_len, skip_ctrl_seq);
157	sysadm	1.8
158	sysadm	1.19	if (p_line_widths)
159			{
160			p_line_widths[line_cnt] = display_len;
161			}
162
163	sysadm	1.8	// Exceed max_line_cnt
164	sysadm	1.9	if (line_cnt + 1 >= line_offsets_count)
165	sysadm	1.1	{
166	sysadm	1.16	// log_error("Line count %d reaches limit %d\n", line_cnt + 1, line_offsets_count);
167	sysadm	1.8	return line_cnt;
168	sysadm	1.1	}
169	sysadm	1.8
170			p_line_offsets[line_cnt + 1] = p_line_offsets[line_cnt] + len;
171			line_cnt++;
172			p_buf += len;
173	sysadm	1.13	} while (p_buf[0] != '\0');
174	sysadm	1.1
175			return line_cnt;
176			}
177	sysadm	1.14
178	sysadm	1.17	int str_filter(char *buffer, int skip_ctrl_seq)
179	sysadm	1.14	{
180			int i;
181			int j;
182
183			for (i = 0, j = 0; buffer[i] != '\0'; i++)
184			{
185	sysadm	1.15	if (buffer[i] == '\r' \|\| buffer[i] == '\7') // skip
186	sysadm	1.14	{
187			continue;
188			}
189
190	sysadm	1.17	if (skip_ctrl_seq && buffer[i] == '\033' && buffer[i + 1] == '[') // Skip control sequence
191	sysadm	1.14	{
192			i += 2;
193			while (buffer[i] != '\0' && buffer[i] != 'm')
194			{
195			i++;
196			}
197			continue;
198			}
199
200			buffer[j] = buffer[i];
201			j++;
202			}
203
204			buffer[j] = '\0';
205
206			return j;
207			}
webmaster@leafok.com	ViewVC Help
Powered by ViewVC 1.3.0-beta1