Sweden-Number/dlls/hhctrl.ocx/stream.c

220 lines
5.1 KiB
C

/*
* Copyright 2007 Jacek Caban for CodeWeavers
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include "hhctrl.h"
#include "stream.h"
#include "wine/debug.h"
WINE_DEFAULT_DEBUG_CHANNEL(htmlhelp);
void strbuf_init(strbuf_t *buf)
{
buf->size = 8;
buf->len = 0;
buf->buf = heap_alloc(buf->size);
}
void strbuf_zero(strbuf_t *buf)
{
buf->len = 0;
}
void strbuf_free(strbuf_t *buf)
{
heap_free(buf->buf);
}
static void strbuf_append(strbuf_t *buf, const char *data, int len)
{
if(buf->len+len > buf->size) {
buf->size = buf->len+len;
buf->buf = heap_realloc(buf->buf, buf->size);
}
memcpy(buf->buf+buf->len, data, len);
buf->len += len;
}
void stream_init(stream_t *stream, IStream *str)
{
memset(stream, 0, sizeof(stream_t));
stream->str = str;
}
static BOOL stream_chr(stream_t *stream, strbuf_t *buf, char c)
{
BOOL b = TRUE;
ULONG i;
while(b) {
for(i=stream->p; i<stream->size; i++) {
if(stream->buf[i] == c) {
b = FALSE;
break;
}
}
if(buf && i > stream->p)
strbuf_append(buf, stream->buf+stream->p, i-stream->p);
stream->p = i;
if(stream->p == stream->size) {
stream->p = 0;
IStream_Read(stream->str, stream->buf, sizeof(stream->buf), &stream->size);
if(!stream->size)
break;
}
}
return stream->size != 0;
}
void get_node_name(strbuf_t *node, strbuf_t *name)
{
const char *ptr = node->buf+1;
strbuf_zero(name);
while(*ptr != '>' && !isspace(*ptr))
ptr++;
strbuf_append(name, node->buf+1, ptr-node->buf-1);
strbuf_append(name, "", 1);
}
/* Return the stream content up to the next HTML tag.
*
* Note: the first returned character is the end of the last tag (>).
*/
BOOL next_content(stream_t *stream, strbuf_t *buf)
{
if(!stream_chr(stream, buf, '<'))
return FALSE;
return TRUE;
}
static BOOL find_node_end(stream_t *stream, strbuf_t *buf)
{
int tag_count = 0, b = buf->len;
char *p;
while(1)
{
if(!stream_chr(stream, buf, '>'))
return FALSE;
if(buf->len == 0)
break;
p = &buf->buf[b];
while((p = memchr(p+1, '"', buf->len-(p+1-buf->buf))) != NULL)
tag_count++;
b = buf->len;
if(tag_count % 2 != 0)
{
if(!stream_chr(stream, buf, '"'))
return FALSE;
tag_count++;
}
else
break;
}
return TRUE;
}
BOOL next_node(stream_t *stream, strbuf_t *buf)
{
strbuf_t tmpbuf;
/* search through the end of the current node */
strbuf_init(&tmpbuf);
if(!find_node_end(stream, &tmpbuf))
{
strbuf_free(&tmpbuf);
return FALSE;
}
strbuf_free(&tmpbuf);
/* find the beginning of the next node */
if(!stream_chr(stream, NULL, '<'))
return FALSE;
/* read out the data of the next node */
if(!find_node_end(stream, buf))
return FALSE;
strbuf_append(buf, ">", 2);
return TRUE;
}
/*
* Find the value of a named HTML attribute.
*
* Note: Attribute names are case insensitive, so it is necessary to
* put both the node text and the attribute name in the same case
* before attempting a string search.
*/
const char *get_attr(const char *node, const char *name, int *len)
{
const char *ptr, *ptr2;
int name_len, node_len;
char name_buf[32];
char *node_buf;
int i;
/* Create a lower case copy of the node */
node_len = strlen(node)+1;
node_buf = heap_alloc(node_len*sizeof(char));
if(!node_buf)
return NULL;
memcpy(node_buf, node, node_len);
for(i=0;i<node_len;i++)
node_buf[i] = tolower(node_buf[i]);
/* Create a lower case copy of the attribute name (search string) */
name_len = strlen(name);
memcpy(name_buf, name, name_len);
for(i=0;i<name_len;i++)
name_buf[i] = tolower(name_buf[i]);
name_buf[name_len++] = '=';
name_buf[name_len++] = '\"';
name_buf[name_len] = 0;
ptr = strstr(node_buf, name_buf);
if(!ptr) {
WARN("name not found\n");
heap_free(node_buf);
return NULL;
}
ptr += name_len;
ptr2 = strchr(ptr, '\"');
if(!ptr2)
{
heap_free(node_buf);
return NULL;
}
*len = ptr2-ptr;
/* Return the pointer offset within the original string */
ptr = node+(ptr-node_buf);
heap_free(node_buf);
return ptr;
}