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
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
|
/* DO NOT EDIT! GENERATED AUTOMATICALLY! */
#line 1 "html-ostream.oo.h"
/* Output stream that produces HTML output.
Copyright (C) 2006, 2015-2016 Free Software Foundation, Inc.
Written by Bruno Haible <bruno@clisp.org>, 2006.
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.
This program 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 General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>. */
#ifndef _HTML_OSTREAM_H
#define _HTML_OSTREAM_H
#include "ostream.h"
#line 28 "html-ostream.h"
struct html_ostream_representation;
/* html_ostream_t is defined as a pointer to struct html_ostream_representation.
In C++ mode, we use a smart pointer class.
In C mode, we have no other choice than a typedef to the root class type. */
#if IS_CPLUSPLUS
struct html_ostream_t
{
private:
struct html_ostream_representation *_pointer;
public:
html_ostream_t () : _pointer (NULL) {}
html_ostream_t (struct html_ostream_representation *pointer) : _pointer (pointer) {}
struct html_ostream_representation * operator -> () { return _pointer; }
operator struct html_ostream_representation * () { return _pointer; }
operator struct any_ostream_representation * () { return (struct any_ostream_representation *) _pointer; }
operator void * () { return _pointer; }
bool operator == (const void *p) { return _pointer == p; }
bool operator != (const void *p) { return _pointer != p; }
operator ostream_t () { return (ostream_t) (struct any_ostream_representation *) _pointer; }
explicit html_ostream_t (ostream_t x) : _pointer ((struct html_ostream_representation *) (void *) x) {}
};
#else
typedef ostream_t html_ostream_t;
#endif
/* Functions that invoke the methods. */
extern void html_ostream_write_mem (html_ostream_t first_arg, const void *data, size_t len);
extern void html_ostream_flush (html_ostream_t first_arg);
extern void html_ostream_free (html_ostream_t first_arg);
extern void html_ostream_begin_span (html_ostream_t first_arg, const char *classname);
extern void html_ostream_end_span (html_ostream_t first_arg, const char *classname);
/* Type representing an implementation of html_ostream_t. */
struct html_ostream_implementation
{
const typeinfo_t * const *superclasses;
size_t superclasses_length;
size_t instance_size;
#define THIS_ARG html_ostream_t first_arg
#include "html_ostream.vt.h"
#undef THIS_ARG
};
/* Public portion of the object pointed to by a html_ostream_t. */
struct html_ostream_representation_header
{
const struct html_ostream_implementation *vtable;
};
#if HAVE_INLINE
/* Define the functions that invoke the methods as inline accesses to
the html_ostream_implementation.
Use #define to avoid a warning because of extern vs. static. */
# define html_ostream_write_mem html_ostream_write_mem_inline
static inline void
html_ostream_write_mem (html_ostream_t first_arg, const void *data, size_t len)
{
const struct html_ostream_implementation *vtable =
((struct html_ostream_representation_header *) (struct html_ostream_representation *) first_arg)->vtable;
vtable->write_mem (first_arg,data,len);
}
# define html_ostream_flush html_ostream_flush_inline
static inline void
html_ostream_flush (html_ostream_t first_arg)
{
const struct html_ostream_implementation *vtable =
((struct html_ostream_representation_header *) (struct html_ostream_representation *) first_arg)->vtable;
vtable->flush (first_arg);
}
# define html_ostream_free html_ostream_free_inline
static inline void
html_ostream_free (html_ostream_t first_arg)
{
const struct html_ostream_implementation *vtable =
((struct html_ostream_representation_header *) (struct html_ostream_representation *) first_arg)->vtable;
vtable->free (first_arg);
}
# define html_ostream_begin_span html_ostream_begin_span_inline
static inline void
html_ostream_begin_span (html_ostream_t first_arg, const char *classname)
{
const struct html_ostream_implementation *vtable =
((struct html_ostream_representation_header *) (struct html_ostream_representation *) first_arg)->vtable;
vtable->begin_span (first_arg,classname);
}
# define html_ostream_end_span html_ostream_end_span_inline
static inline void
html_ostream_end_span (html_ostream_t first_arg, const char *classname)
{
const struct html_ostream_implementation *vtable =
((struct html_ostream_representation_header *) (struct html_ostream_representation *) first_arg)->vtable;
vtable->end_span (first_arg,classname);
}
#endif
extern const typeinfo_t html_ostream_typeinfo;
#define html_ostream_SUPERCLASSES &html_ostream_typeinfo, ostream_SUPERCLASSES
#define html_ostream_SUPERCLASSES_LENGTH (1 + ostream_SUPERCLASSES_LENGTH)
extern const struct html_ostream_implementation html_ostream_vtable;
#line 37 "html-ostream.oo.h"
#ifdef __cplusplus
extern "C" {
#endif
/* Create an output stream that takes input in the UTF-8 encoding and
writes it in HTML form on DESTINATION.
This stream produces a sequence of lines. The caller is responsible
for opening the <body><html> elements before and for closing them after
the use of this stream.
Note that the resulting stream must be closed before DESTINATION can be
closed. */
extern html_ostream_t html_ostream_create (ostream_t destination);
#ifdef __cplusplus
}
#endif
#endif /* _HTML_OSTREAM_H */
|
