1 /* markupwriter.c generated by valac, the Vala compiler
2 * generated from markupwriter.vala, do not modify */
3
4 /* markupwriter.vala
5 *
6 * Copyright (C) 2008-2009 Florian Brosch, Didier Villevalois
7 *
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
12 *
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
17 *
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21 *
22 * Author:
23 * Didier 'Ptitjes Villevalois <ptitjes@free.fr>
24 */
25
26 #include "valadoc.h"
27 #include <glib.h>
28 #include <stdlib.h>
29 #include <string.h>
30 #include <gobject/gvaluecollector.h>
31
32 #define _g_string_free0(var) ((var == NULL) ? NULL : (var = (g_string_free (var, TRUE), NULL)))
33 #define _g_free0(var) (var = (g_free (var), NULL))
34 typedef struct _ValadocParamSpecMarkupWriter ValadocParamSpecMarkupWriter;
35
36 struct _ValadocMarkupWriterPrivate {
37 gboolean wrap;
38 };
39
40 struct _ValadocParamSpecMarkupWriter {
41 GParamSpec parent_instance;
42 };
43
44 static gint ValadocMarkupWriter_private_offset;
45 static gpointer valadoc_markup_writer_parent_class = NULL;
46
47 #define VALADOC_MARKUP_WRITER_MAX_COLUMN 150
48 static void valadoc_markup_writer_check_column (ValadocMarkupWriter* self,
49 const gchar* name,
50 gboolean end_tag);
51 static void valadoc_markup_writer_break_line (ValadocMarkupWriter* self);
52 static gboolean valadoc_markup_writer_real_inline_element (ValadocMarkupWriter* self,
53 const gchar* name);
54 static gboolean valadoc_markup_writer_real_content_inline_element (ValadocMarkupWriter* self,
55 const gchar* name);
56 static void valadoc_markup_writer_finalize (ValadocMarkupWriter * obj);
57 static GType valadoc_markup_writer_get_type_once (void);
58
59 static inline gpointer
valadoc_markup_writer_get_instance_private(ValadocMarkupWriter * self)60 valadoc_markup_writer_get_instance_private (ValadocMarkupWriter* self)
61 {
62 return G_STRUCT_MEMBER_P (self, ValadocMarkupWriter_private_offset);
63 }
64
65 static gunichar
string_get_char(const gchar * self,glong index)66 string_get_char (const gchar* self,
67 glong index)
68 {
69 gunichar result = 0U;
70 g_return_val_if_fail (self != NULL, 0U);
71 result = g_utf8_get_char (((gchar*) self) + index);
72 return result;
73 }
74
75 gchar*
valadoc_markup_writer_escape(const gchar * txt)76 valadoc_markup_writer_escape (const gchar* txt)
77 {
78 GString* builder = NULL;
79 GString* _tmp0_;
80 const gchar* start = NULL;
81 const gchar* pos = NULL;
82 gunichar c = 0U;
83 gchar* result = NULL;
84 g_return_val_if_fail (txt != NULL, NULL);
85 _tmp0_ = g_string_new ("");
86 builder = _tmp0_;
87 start = txt;
88 {
89 gboolean _tmp1_ = FALSE;
90 pos = txt;
91 _tmp1_ = TRUE;
92 while (TRUE) {
93 const gchar* _tmp4_;
94 if (!_tmp1_) {
95 const gchar* _tmp2_;
96 const gchar* _tmp3_;
97 _tmp2_ = pos;
98 _tmp3_ = g_utf8_next_char (_tmp2_);
99 pos = _tmp3_;
100 }
101 _tmp1_ = FALSE;
102 _tmp4_ = pos;
103 c = string_get_char (_tmp4_, (glong) 0);
104 if (!(c != ((gunichar) '\0'))) {
105 break;
106 }
107 switch (c) {
108 case '"':
109 {
110 GString* _tmp5_;
111 const gchar* _tmp6_;
112 const gchar* _tmp7_;
113 const gchar* _tmp8_;
114 GString* _tmp9_;
115 const gchar* _tmp10_;
116 const gchar* _tmp11_;
117 _tmp5_ = builder;
118 _tmp6_ = start;
119 _tmp7_ = pos;
120 _tmp8_ = start;
121 g_string_append_len (_tmp5_, _tmp6_, (gssize) (((gchar*) _tmp7_) - ((gchar*) _tmp8_)));
122 _tmp9_ = builder;
123 g_string_append (_tmp9_, """);
124 _tmp10_ = pos;
125 _tmp11_ = g_utf8_next_char (_tmp10_);
126 start = _tmp11_;
127 break;
128 }
129 case '<':
130 {
131 GString* _tmp12_;
132 const gchar* _tmp13_;
133 const gchar* _tmp14_;
134 const gchar* _tmp15_;
135 GString* _tmp16_;
136 const gchar* _tmp17_;
137 const gchar* _tmp18_;
138 _tmp12_ = builder;
139 _tmp13_ = start;
140 _tmp14_ = pos;
141 _tmp15_ = start;
142 g_string_append_len (_tmp12_, _tmp13_, (gssize) (((gchar*) _tmp14_) - ((gchar*) _tmp15_)));
143 _tmp16_ = builder;
144 g_string_append (_tmp16_, "<");
145 _tmp17_ = pos;
146 _tmp18_ = g_utf8_next_char (_tmp17_);
147 start = _tmp18_;
148 break;
149 }
150 case '>':
151 {
152 GString* _tmp19_;
153 const gchar* _tmp20_;
154 const gchar* _tmp21_;
155 const gchar* _tmp22_;
156 GString* _tmp23_;
157 const gchar* _tmp24_;
158 const gchar* _tmp25_;
159 _tmp19_ = builder;
160 _tmp20_ = start;
161 _tmp21_ = pos;
162 _tmp22_ = start;
163 g_string_append_len (_tmp19_, _tmp20_, (gssize) (((gchar*) _tmp21_) - ((gchar*) _tmp22_)));
164 _tmp23_ = builder;
165 g_string_append (_tmp23_, ">");
166 _tmp24_ = pos;
167 _tmp25_ = g_utf8_next_char (_tmp24_);
168 start = _tmp25_;
169 break;
170 }
171 case '&':
172 {
173 GString* _tmp26_;
174 const gchar* _tmp27_;
175 const gchar* _tmp28_;
176 const gchar* _tmp29_;
177 GString* _tmp30_;
178 const gchar* _tmp31_;
179 const gchar* _tmp32_;
180 _tmp26_ = builder;
181 _tmp27_ = start;
182 _tmp28_ = pos;
183 _tmp29_ = start;
184 g_string_append_len (_tmp26_, _tmp27_, (gssize) (((gchar*) _tmp28_) - ((gchar*) _tmp29_)));
185 _tmp30_ = builder;
186 g_string_append (_tmp30_, "&");
187 _tmp31_ = pos;
188 _tmp32_ = g_utf8_next_char (_tmp31_);
189 start = _tmp32_;
190 break;
191 }
192 case '\'':
193 {
194 GString* _tmp33_;
195 const gchar* _tmp34_;
196 const gchar* _tmp35_;
197 const gchar* _tmp36_;
198 GString* _tmp37_;
199 const gchar* _tmp38_;
200 const gchar* _tmp39_;
201 _tmp33_ = builder;
202 _tmp34_ = start;
203 _tmp35_ = pos;
204 _tmp36_ = start;
205 g_string_append_len (_tmp33_, _tmp34_, (gssize) (((gchar*) _tmp35_) - ((gchar*) _tmp36_)));
206 _tmp37_ = builder;
207 g_string_append (_tmp37_, "'");
208 _tmp38_ = pos;
209 _tmp39_ = g_utf8_next_char (_tmp38_);
210 start = _tmp39_;
211 break;
212 }
213 default:
214 break;
215 }
216 }
217 }
218 if ((&txt) == (&start)) {
219 gchar* _tmp40_;
220 _tmp40_ = g_strdup (txt);
221 result = _tmp40_;
222 _g_string_free0 (builder);
223 return result;
224 } else {
225 GString* _tmp41_;
226 const gchar* _tmp42_;
227 const gchar* _tmp43_;
228 const gchar* _tmp44_;
229 GString* _tmp45_;
230 gchar* _tmp46_;
231 _tmp41_ = builder;
232 _tmp42_ = start;
233 _tmp43_ = pos;
234 _tmp44_ = start;
235 g_string_append_len (_tmp41_, _tmp42_, (gssize) (((gchar*) _tmp43_) - ((gchar*) _tmp44_)));
236 _tmp45_ = builder;
237 _tmp46_ = _tmp45_->str;
238 _tmp45_->str = NULL;
239 result = _tmp46_;
240 _g_string_free0 (builder);
241 return result;
242 }
243 _g_string_free0 (builder);
244 }
245
246 /**
247 * Initializes a new instance of the MarkupWriter
248 *
249 * @param write stream a WriteFunc
250 * @param xml_declaration specifies whether this file starts with an xml-declaration
251 */
252 ValadocMarkupWriter*
valadoc_markup_writer_construct(GType object_type,ValadocMarkupWriterWriteFunc write,gpointer write_target,GDestroyNotify write_target_destroy_notify,gboolean xml_declaration)253 valadoc_markup_writer_construct (GType object_type,
254 ValadocMarkupWriterWriteFunc write,
255 gpointer write_target,
256 GDestroyNotify write_target_destroy_notify,
257 gboolean xml_declaration)
258 {
259 ValadocMarkupWriter* self = NULL;
260 ValadocMarkupWriterWriteFunc _tmp0_;
261 gpointer _tmp0__target;
262 GDestroyNotify _tmp0__target_destroy_notify;
263 self = (ValadocMarkupWriter*) g_type_create_instance (object_type);
264 _tmp0_ = write;
265 _tmp0__target = write_target;
266 _tmp0__target_destroy_notify = write_target_destroy_notify;
267 write = NULL;
268 write_target = NULL;
269 write_target_destroy_notify = NULL;
270 (self->write_target_destroy_notify == NULL) ? NULL : (self->write_target_destroy_notify (self->write_target), NULL);
271 self->write = NULL;
272 self->write_target = NULL;
273 self->write_target_destroy_notify = NULL;
274 self->write = _tmp0_;
275 self->write_target = _tmp0__target;
276 self->write_target_destroy_notify = _tmp0__target_destroy_notify;
277 if (xml_declaration) {
278 valadoc_markup_writer_do_write (self, "<?xml version=\"1.0\" encoding=\"utf-8\"?>");
279 }
280 self->indent = -1;
281 self->last_was_tag = TRUE;
282 (write_target_destroy_notify == NULL) ? NULL : (write_target_destroy_notify (write_target), NULL);
283 write = NULL;
284 write_target = NULL;
285 write_target_destroy_notify = NULL;
286 return self;
287 }
288
289 ValadocMarkupWriter*
valadoc_markup_writer_new(ValadocMarkupWriterWriteFunc write,gpointer write_target,GDestroyNotify write_target_destroy_notify,gboolean xml_declaration)290 valadoc_markup_writer_new (ValadocMarkupWriterWriteFunc write,
291 gpointer write_target,
292 GDestroyNotify write_target_destroy_notify,
293 gboolean xml_declaration)
294 {
295 return valadoc_markup_writer_construct (VALADOC_TYPE_MARKUP_WRITER, write, write_target, write_target_destroy_notify, xml_declaration);
296 }
297
298 /**
299 * Writes an start tag of a markup element to the file
300 *
301 * @param name the name of the markup
302 * @param attributes a list of name/value pairs
303 * @return this
304 */
305 ValadocMarkupWriter*
valadoc_markup_writer_start_tag(ValadocMarkupWriter * self,const gchar * name,gchar ** attributes,gint attributes_length1)306 valadoc_markup_writer_start_tag (ValadocMarkupWriter* self,
307 const gchar* name,
308 gchar** attributes,
309 gint attributes_length1)
310 {
311 gint _tmp0_;
312 GString* content = NULL;
313 GString* _tmp1_;
314 GString* _tmp2_;
315 GString* _tmp8_;
316 GString* _tmp9_;
317 const gchar* _tmp10_;
318 ValadocMarkupWriter* result = NULL;
319 g_return_val_if_fail (self != NULL, NULL);
320 g_return_val_if_fail (name != NULL, NULL);
321 _tmp0_ = self->indent;
322 self->indent = _tmp0_ + 1;
323 valadoc_markup_writer_check_column (self, name, FALSE);
324 if ((attributes_length1 % 2) != 0) {
325 g_warning ("markupwriter.vala:117: Given attributes array is not a list of pairs (" \
326 "name and value)");
327 attributes_length1 = attributes_length1 - 1;
328 }
329 _tmp1_ = g_string_new ("<");
330 content = _tmp1_;
331 _tmp2_ = content;
332 g_string_append (_tmp2_, name);
333 {
334 gint i = 0;
335 i = 0;
336 {
337 gboolean _tmp3_ = FALSE;
338 _tmp3_ = TRUE;
339 while (TRUE) {
340 const gchar* _tmp4_;
341 if (!_tmp3_) {
342 i = i + 2;
343 }
344 _tmp3_ = FALSE;
345 if (!(i < attributes_length1)) {
346 break;
347 }
348 _tmp4_ = attributes[i + 1];
349 if (_tmp4_ != NULL) {
350 GString* _tmp5_;
351 const gchar* _tmp6_;
352 const gchar* _tmp7_;
353 _tmp5_ = content;
354 _tmp6_ = attributes[i];
355 _tmp7_ = attributes[i + 1];
356 g_string_append_printf (_tmp5_, " %s=\"%s\"", _tmp6_, _tmp7_);
357 }
358 }
359 }
360 }
361 _tmp8_ = content;
362 g_string_append (_tmp8_, ">");
363 _tmp9_ = content;
364 _tmp10_ = _tmp9_->str;
365 valadoc_markup_writer_do_write (self, _tmp10_);
366 self->last_was_tag = TRUE;
367 result = self;
368 _g_string_free0 (content);
369 return result;
370 }
371
372 /**
373 * Writes a simple tag (<name />) to the file
374 *
375 * @param name the name of the markup
376 * @param attributes a list of name/value pairs
377 * @return this
378 */
379 ValadocMarkupWriter*
valadoc_markup_writer_simple_tag(ValadocMarkupWriter * self,const gchar * name,gchar ** attributes,gint attributes_length1)380 valadoc_markup_writer_simple_tag (ValadocMarkupWriter* self,
381 const gchar* name,
382 gchar** attributes,
383 gint attributes_length1)
384 {
385 gint _tmp0_;
386 GString* content = NULL;
387 GString* _tmp1_;
388 GString* _tmp2_;
389 GString* _tmp8_;
390 GString* _tmp9_;
391 const gchar* _tmp10_;
392 gint _tmp11_;
393 ValadocMarkupWriter* result = NULL;
394 g_return_val_if_fail (self != NULL, NULL);
395 g_return_val_if_fail (name != NULL, NULL);
396 _tmp0_ = self->indent;
397 self->indent = _tmp0_ + 1;
398 valadoc_markup_writer_check_column (self, name, FALSE);
399 if ((attributes_length1 % 2) != 0) {
400 g_warning ("markupwriter.vala:148: Given attributes array is not a list of pairs (" \
401 "name and value)");
402 attributes_length1 = attributes_length1 - 1;
403 }
404 _tmp1_ = g_string_new ("<");
405 content = _tmp1_;
406 _tmp2_ = content;
407 g_string_append (_tmp2_, name);
408 {
409 gint i = 0;
410 i = 0;
411 {
412 gboolean _tmp3_ = FALSE;
413 _tmp3_ = TRUE;
414 while (TRUE) {
415 const gchar* _tmp4_;
416 if (!_tmp3_) {
417 i = i + 2;
418 }
419 _tmp3_ = FALSE;
420 if (!(i < attributes_length1)) {
421 break;
422 }
423 _tmp4_ = attributes[i + 1];
424 if (_tmp4_ != NULL) {
425 GString* _tmp5_;
426 const gchar* _tmp6_;
427 const gchar* _tmp7_;
428 _tmp5_ = content;
429 _tmp6_ = attributes[i];
430 _tmp7_ = attributes[i + 1];
431 g_string_append_printf (_tmp5_, " %s=\"%s\"", _tmp6_, _tmp7_);
432 }
433 }
434 }
435 }
436 _tmp8_ = content;
437 g_string_append (_tmp8_, "/>");
438 _tmp9_ = content;
439 _tmp10_ = _tmp9_->str;
440 valadoc_markup_writer_do_write (self, _tmp10_);
441 _tmp11_ = self->indent;
442 self->indent = _tmp11_ - 1;
443 self->last_was_tag = TRUE;
444 result = self;
445 _g_string_free0 (content);
446 return result;
447 }
448
449 /**
450 * Writes an end tag of a markup element to the file
451 *
452 * @param name the name of the markup
453 * @return this
454 */
455 ValadocMarkupWriter*
valadoc_markup_writer_end_tag(ValadocMarkupWriter * self,const gchar * name)456 valadoc_markup_writer_end_tag (ValadocMarkupWriter* self,
457 const gchar* name)
458 {
459 gchar* _tmp0_;
460 gchar* _tmp1_;
461 gint _tmp2_;
462 ValadocMarkupWriter* result = NULL;
463 g_return_val_if_fail (self != NULL, NULL);
464 g_return_val_if_fail (name != NULL, NULL);
465 valadoc_markup_writer_check_column (self, name, TRUE);
466 _tmp0_ = g_strdup_printf ("</%s>", name);
467 _tmp1_ = _tmp0_;
468 valadoc_markup_writer_do_write (self, _tmp1_);
469 _g_free0 (_tmp1_);
470 _tmp2_ = self->indent;
471 self->indent = _tmp2_ - 1;
472 self->last_was_tag = TRUE;
473 result = self;
474 return result;
475 }
476
477 /**
478 * Writes the specified string to the output stream
479 *
480 * @see raw_text
481 * @return this
482 */
483 static gchar
string_get(const gchar * self,glong index)484 string_get (const gchar* self,
485 glong index)
486 {
487 gchar _tmp0_;
488 gchar result = '\0';
489 g_return_val_if_fail (self != NULL, '\0');
490 _tmp0_ = ((gchar*) self)[index];
491 result = _tmp0_;
492 return result;
493 }
494
495 static glong
string_strnlen(gchar * str,glong maxlen)496 string_strnlen (gchar* str,
497 glong maxlen)
498 {
499 gchar* end = NULL;
500 gchar* _tmp0_;
501 gchar* _tmp1_;
502 glong result = 0L;
503 _tmp0_ = memchr (str, 0, (gsize) maxlen);
504 end = _tmp0_;
505 _tmp1_ = end;
506 if (_tmp1_ == NULL) {
507 result = maxlen;
508 return result;
509 } else {
510 gchar* _tmp2_;
511 _tmp2_ = end;
512 result = (glong) (_tmp2_ - str);
513 return result;
514 }
515 }
516
517 static gchar*
string_substring(const gchar * self,glong offset,glong len)518 string_substring (const gchar* self,
519 glong offset,
520 glong len)
521 {
522 glong string_length = 0L;
523 gboolean _tmp0_ = FALSE;
524 gchar* _tmp3_;
525 gchar* result = NULL;
526 g_return_val_if_fail (self != NULL, NULL);
527 if (offset >= ((glong) 0)) {
528 _tmp0_ = len >= ((glong) 0);
529 } else {
530 _tmp0_ = FALSE;
531 }
532 if (_tmp0_) {
533 string_length = string_strnlen ((gchar*) self, offset + len);
534 } else {
535 gint _tmp1_;
536 gint _tmp2_;
537 _tmp1_ = strlen (self);
538 _tmp2_ = _tmp1_;
539 string_length = (glong) _tmp2_;
540 }
541 if (offset < ((glong) 0)) {
542 offset = string_length + offset;
543 g_return_val_if_fail (offset >= ((glong) 0), NULL);
544 } else {
545 g_return_val_if_fail (offset <= string_length, NULL);
546 }
547 if (len < ((glong) 0)) {
548 len = string_length - offset;
549 }
550 g_return_val_if_fail ((offset + len) <= string_length, NULL);
551 _tmp3_ = g_strndup (((gchar*) self) + offset, (gsize) len);
552 result = _tmp3_;
553 return result;
554 }
555
556 ValadocMarkupWriter*
valadoc_markup_writer_text(ValadocMarkupWriter * self,const gchar * text)557 valadoc_markup_writer_text (ValadocMarkupWriter* self,
558 const gchar* text)
559 {
560 gboolean _tmp0_ = FALSE;
561 ValadocMarkupWriter* result = NULL;
562 g_return_val_if_fail (self != NULL, NULL);
563 g_return_val_if_fail (text != NULL, NULL);
564 if (self->priv->wrap) {
565 gint _tmp1_;
566 gint _tmp2_;
567 _tmp1_ = strlen (text);
568 _tmp2_ = _tmp1_;
569 _tmp0_ = (_tmp2_ + self->current_column) > ((glong) VALADOC_MARKUP_WRITER_MAX_COLUMN);
570 } else {
571 _tmp0_ = FALSE;
572 }
573 if (_tmp0_) {
574 glong wrote = 0L;
575 wrote = (glong) 0;
576 while (TRUE) {
577 gint _tmp3_;
578 gint _tmp4_;
579 glong space_pos = 0L;
580 gint _tmp9_;
581 gint _tmp10_;
582 gint _tmp17_;
583 gint _tmp18_;
584 _tmp3_ = strlen (text);
585 _tmp4_ = _tmp3_;
586 if (!(wrote < ((glong) _tmp4_))) {
587 break;
588 }
589 space_pos = (glong) -1;
590 {
591 glong i = 0L;
592 i = wrote + 1;
593 {
594 gboolean _tmp5_ = FALSE;
595 _tmp5_ = TRUE;
596 while (TRUE) {
597 gint _tmp7_;
598 gint _tmp8_;
599 if (!_tmp5_) {
600 glong _tmp6_;
601 _tmp6_ = i;
602 i = _tmp6_ + 1;
603 }
604 _tmp5_ = FALSE;
605 _tmp7_ = strlen (text);
606 _tmp8_ = _tmp7_;
607 if (!(i < ((glong) _tmp8_))) {
608 break;
609 }
610 if (string_get (text, i) == ' ') {
611 if (((i - wrote) + self->current_column) > ((glong) VALADOC_MARKUP_WRITER_MAX_COLUMN)) {
612 break;
613 }
614 space_pos = i;
615 }
616 }
617 }
618 }
619 _tmp9_ = strlen (text);
620 _tmp10_ = _tmp9_;
621 if (((_tmp10_ - wrote) + self->current_column) <= ((glong) VALADOC_MARKUP_WRITER_MAX_COLUMN)) {
622 gchar* _tmp11_;
623 gchar* _tmp12_;
624 gint _tmp13_;
625 gint _tmp14_;
626 _tmp11_ = string_substring (text, wrote, (glong) -1);
627 _tmp12_ = _tmp11_;
628 valadoc_markup_writer_do_write (self, _tmp12_);
629 _g_free0 (_tmp12_);
630 _tmp13_ = strlen (text);
631 _tmp14_ = _tmp13_;
632 wrote = (glong) (_tmp14_ + 1);
633 } else {
634 if (space_pos == ((glong) -1)) {
635 } else {
636 gchar* _tmp15_;
637 gchar* _tmp16_;
638 _tmp15_ = string_substring (text, wrote, space_pos - wrote);
639 _tmp16_ = _tmp15_;
640 valadoc_markup_writer_do_write (self, _tmp16_);
641 _g_free0 (_tmp16_);
642 wrote = space_pos + 1;
643 }
644 }
645 _tmp17_ = strlen (text);
646 _tmp18_ = _tmp17_;
647 if (wrote < ((glong) _tmp18_)) {
648 valadoc_markup_writer_break_line (self);
649 valadoc_markup_writer_do_write (self, " ");
650 }
651 }
652 } else {
653 valadoc_markup_writer_do_write (self, text);
654 }
655 self->last_was_tag = FALSE;
656 result = self;
657 return result;
658 }
659
660 /**
661 * Writes the specified string to the output stream
662 *
663 * @see text
664 * @return this
665 */
666 ValadocMarkupWriter*
valadoc_markup_writer_raw_text(ValadocMarkupWriter * self,const gchar * text)667 valadoc_markup_writer_raw_text (ValadocMarkupWriter* self,
668 const gchar* text)
669 {
670 ValadocMarkupWriter* result = NULL;
671 g_return_val_if_fail (self != NULL, NULL);
672 g_return_val_if_fail (text != NULL, NULL);
673 valadoc_markup_writer_do_write (self, text);
674 self->last_was_tag = FALSE;
675 result = self;
676 return result;
677 }
678
679 void
valadoc_markup_writer_set_wrap(ValadocMarkupWriter * self,gboolean wrap)680 valadoc_markup_writer_set_wrap (ValadocMarkupWriter* self,
681 gboolean wrap)
682 {
683 g_return_if_fail (self != NULL);
684 self->priv->wrap = wrap;
685 }
686
687 static void
valadoc_markup_writer_break_line(ValadocMarkupWriter * self)688 valadoc_markup_writer_break_line (ValadocMarkupWriter* self)
689 {
690 ValadocMarkupWriterWriteFunc _tmp0_;
691 gpointer _tmp0__target;
692 ValadocMarkupWriterWriteFunc _tmp1_;
693 gpointer _tmp1__target;
694 gchar* _tmp2_;
695 gchar* _tmp3_;
696 g_return_if_fail (self != NULL);
697 _tmp0_ = self->write;
698 _tmp0__target = self->write_target;
699 _tmp0_ ("\n", _tmp0__target);
700 _tmp1_ = self->write;
701 _tmp1__target = self->write_target;
702 _tmp2_ = g_strnfill ((gsize) (self->indent * 2), ' ');
703 _tmp3_ = _tmp2_;
704 _tmp1_ (_tmp3_, _tmp1__target);
705 _g_free0 (_tmp3_);
706 self->current_column = (glong) (self->indent * 2);
707 }
708
709 void
valadoc_markup_writer_do_write(ValadocMarkupWriter * self,const gchar * text)710 valadoc_markup_writer_do_write (ValadocMarkupWriter* self,
711 const gchar* text)
712 {
713 gboolean _tmp0_ = FALSE;
714 ValadocMarkupWriterWriteFunc _tmp3_;
715 gpointer _tmp3__target;
716 gint _tmp4_;
717 gint _tmp5_;
718 g_return_if_fail (self != NULL);
719 g_return_if_fail (text != NULL);
720 if (self->priv->wrap) {
721 gint _tmp1_;
722 gint _tmp2_;
723 _tmp1_ = strlen (text);
724 _tmp2_ = _tmp1_;
725 _tmp0_ = (self->current_column + _tmp2_) > ((glong) VALADOC_MARKUP_WRITER_MAX_COLUMN);
726 } else {
727 _tmp0_ = FALSE;
728 }
729 if (_tmp0_) {
730 valadoc_markup_writer_break_line (self);
731 }
732 _tmp3_ = self->write;
733 _tmp3__target = self->write_target;
734 _tmp3_ (text, _tmp3__target);
735 _tmp4_ = strlen (text);
736 _tmp5_ = _tmp4_;
737 self->current_column = self->current_column + _tmp5_;
738 }
739
740 static void
valadoc_markup_writer_check_column(ValadocMarkupWriter * self,const gchar * name,gboolean end_tag)741 valadoc_markup_writer_check_column (ValadocMarkupWriter* self,
742 const gchar* name,
743 gboolean end_tag)
744 {
745 g_return_if_fail (self != NULL);
746 g_return_if_fail (name != NULL);
747 if (!self->priv->wrap) {
748 return;
749 } else {
750 gboolean _tmp0_ = FALSE;
751 if (!end_tag) {
752 _tmp0_ = valadoc_markup_writer_inline_element (self, name);
753 } else {
754 _tmp0_ = FALSE;
755 }
756 if (_tmp0_) {
757 return;
758 } else {
759 gboolean _tmp1_ = FALSE;
760 if (end_tag) {
761 _tmp1_ = valadoc_markup_writer_content_inline_element (self, name);
762 } else {
763 _tmp1_ = FALSE;
764 }
765 if (_tmp1_) {
766 return;
767 } else {
768 gboolean _tmp2_ = FALSE;
769 if (end_tag) {
770 _tmp2_ = !self->last_was_tag;
771 } else {
772 _tmp2_ = FALSE;
773 }
774 if (_tmp2_) {
775 return;
776 }
777 }
778 }
779 }
780 valadoc_markup_writer_break_line (self);
781 }
782
783 static gboolean
valadoc_markup_writer_real_inline_element(ValadocMarkupWriter * self,const gchar * name)784 valadoc_markup_writer_real_inline_element (ValadocMarkupWriter* self,
785 const gchar* name)
786 {
787 gboolean result = FALSE;
788 g_return_val_if_fail (name != NULL, FALSE);
789 result = FALSE;
790 return result;
791 }
792
793 gboolean
valadoc_markup_writer_inline_element(ValadocMarkupWriter * self,const gchar * name)794 valadoc_markup_writer_inline_element (ValadocMarkupWriter* self,
795 const gchar* name)
796 {
797 g_return_val_if_fail (self != NULL, FALSE);
798 return VALADOC_MARKUP_WRITER_GET_CLASS (self)->inline_element (self, name);
799 }
800
801 static gboolean
valadoc_markup_writer_real_content_inline_element(ValadocMarkupWriter * self,const gchar * name)802 valadoc_markup_writer_real_content_inline_element (ValadocMarkupWriter* self,
803 const gchar* name)
804 {
805 gboolean result = FALSE;
806 g_return_val_if_fail (name != NULL, FALSE);
807 result = TRUE;
808 return result;
809 }
810
811 gboolean
valadoc_markup_writer_content_inline_element(ValadocMarkupWriter * self,const gchar * name)812 valadoc_markup_writer_content_inline_element (ValadocMarkupWriter* self,
813 const gchar* name)
814 {
815 g_return_val_if_fail (self != NULL, FALSE);
816 return VALADOC_MARKUP_WRITER_GET_CLASS (self)->content_inline_element (self, name);
817 }
818
819 static void
valadoc_value_markup_writer_init(GValue * value)820 valadoc_value_markup_writer_init (GValue* value)
821 {
822 value->data[0].v_pointer = NULL;
823 }
824
825 static void
valadoc_value_markup_writer_free_value(GValue * value)826 valadoc_value_markup_writer_free_value (GValue* value)
827 {
828 if (value->data[0].v_pointer) {
829 valadoc_markup_writer_unref (value->data[0].v_pointer);
830 }
831 }
832
833 static void
valadoc_value_markup_writer_copy_value(const GValue * src_value,GValue * dest_value)834 valadoc_value_markup_writer_copy_value (const GValue* src_value,
835 GValue* dest_value)
836 {
837 if (src_value->data[0].v_pointer) {
838 dest_value->data[0].v_pointer = valadoc_markup_writer_ref (src_value->data[0].v_pointer);
839 } else {
840 dest_value->data[0].v_pointer = NULL;
841 }
842 }
843
844 static gpointer
valadoc_value_markup_writer_peek_pointer(const GValue * value)845 valadoc_value_markup_writer_peek_pointer (const GValue* value)
846 {
847 return value->data[0].v_pointer;
848 }
849
850 static gchar*
valadoc_value_markup_writer_collect_value(GValue * value,guint n_collect_values,GTypeCValue * collect_values,guint collect_flags)851 valadoc_value_markup_writer_collect_value (GValue* value,
852 guint n_collect_values,
853 GTypeCValue* collect_values,
854 guint collect_flags)
855 {
856 if (collect_values[0].v_pointer) {
857 ValadocMarkupWriter * object;
858 object = collect_values[0].v_pointer;
859 if (object->parent_instance.g_class == NULL) {
860 return g_strconcat ("invalid unclassed object pointer for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
861 } else if (!g_value_type_compatible (G_TYPE_FROM_INSTANCE (object), G_VALUE_TYPE (value))) {
862 return g_strconcat ("invalid object type `", g_type_name (G_TYPE_FROM_INSTANCE (object)), "' for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
863 }
864 value->data[0].v_pointer = valadoc_markup_writer_ref (object);
865 } else {
866 value->data[0].v_pointer = NULL;
867 }
868 return NULL;
869 }
870
871 static gchar*
valadoc_value_markup_writer_lcopy_value(const GValue * value,guint n_collect_values,GTypeCValue * collect_values,guint collect_flags)872 valadoc_value_markup_writer_lcopy_value (const GValue* value,
873 guint n_collect_values,
874 GTypeCValue* collect_values,
875 guint collect_flags)
876 {
877 ValadocMarkupWriter ** object_p;
878 object_p = collect_values[0].v_pointer;
879 if (!object_p) {
880 return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
881 }
882 if (!value->data[0].v_pointer) {
883 *object_p = NULL;
884 } else if (collect_flags & G_VALUE_NOCOPY_CONTENTS) {
885 *object_p = value->data[0].v_pointer;
886 } else {
887 *object_p = valadoc_markup_writer_ref (value->data[0].v_pointer);
888 }
889 return NULL;
890 }
891
892 GParamSpec*
valadoc_param_spec_markup_writer(const gchar * name,const gchar * nick,const gchar * blurb,GType object_type,GParamFlags flags)893 valadoc_param_spec_markup_writer (const gchar* name,
894 const gchar* nick,
895 const gchar* blurb,
896 GType object_type,
897 GParamFlags flags)
898 {
899 ValadocParamSpecMarkupWriter* spec;
900 g_return_val_if_fail (g_type_is_a (object_type, VALADOC_TYPE_MARKUP_WRITER), NULL);
901 spec = g_param_spec_internal (G_TYPE_PARAM_OBJECT, name, nick, blurb, flags);
902 G_PARAM_SPEC (spec)->value_type = object_type;
903 return G_PARAM_SPEC (spec);
904 }
905
906 gpointer
valadoc_value_get_markup_writer(const GValue * value)907 valadoc_value_get_markup_writer (const GValue* value)
908 {
909 g_return_val_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, VALADOC_TYPE_MARKUP_WRITER), NULL);
910 return value->data[0].v_pointer;
911 }
912
913 void
valadoc_value_set_markup_writer(GValue * value,gpointer v_object)914 valadoc_value_set_markup_writer (GValue* value,
915 gpointer v_object)
916 {
917 ValadocMarkupWriter * old;
918 g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, VALADOC_TYPE_MARKUP_WRITER));
919 old = value->data[0].v_pointer;
920 if (v_object) {
921 g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, VALADOC_TYPE_MARKUP_WRITER));
922 g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
923 value->data[0].v_pointer = v_object;
924 valadoc_markup_writer_ref (value->data[0].v_pointer);
925 } else {
926 value->data[0].v_pointer = NULL;
927 }
928 if (old) {
929 valadoc_markup_writer_unref (old);
930 }
931 }
932
933 void
valadoc_value_take_markup_writer(GValue * value,gpointer v_object)934 valadoc_value_take_markup_writer (GValue* value,
935 gpointer v_object)
936 {
937 ValadocMarkupWriter * old;
938 g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, VALADOC_TYPE_MARKUP_WRITER));
939 old = value->data[0].v_pointer;
940 if (v_object) {
941 g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, VALADOC_TYPE_MARKUP_WRITER));
942 g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
943 value->data[0].v_pointer = v_object;
944 } else {
945 value->data[0].v_pointer = NULL;
946 }
947 if (old) {
948 valadoc_markup_writer_unref (old);
949 }
950 }
951
952 static void
valadoc_markup_writer_class_init(ValadocMarkupWriterClass * klass,gpointer klass_data)953 valadoc_markup_writer_class_init (ValadocMarkupWriterClass * klass,
954 gpointer klass_data)
955 {
956 valadoc_markup_writer_parent_class = g_type_class_peek_parent (klass);
957 ((ValadocMarkupWriterClass *) klass)->finalize = valadoc_markup_writer_finalize;
958 g_type_class_adjust_private_offset (klass, &ValadocMarkupWriter_private_offset);
959 ((ValadocMarkupWriterClass *) klass)->inline_element = (gboolean (*) (ValadocMarkupWriter*, const gchar*)) valadoc_markup_writer_real_inline_element;
960 ((ValadocMarkupWriterClass *) klass)->content_inline_element = (gboolean (*) (ValadocMarkupWriter*, const gchar*)) valadoc_markup_writer_real_content_inline_element;
961 }
962
963 static void
valadoc_markup_writer_instance_init(ValadocMarkupWriter * self,gpointer klass)964 valadoc_markup_writer_instance_init (ValadocMarkupWriter * self,
965 gpointer klass)
966 {
967 self->priv = valadoc_markup_writer_get_instance_private (self);
968 self->current_column = (glong) 0;
969 self->priv->wrap = TRUE;
970 self->ref_count = 1;
971 }
972
973 static void
valadoc_markup_writer_finalize(ValadocMarkupWriter * obj)974 valadoc_markup_writer_finalize (ValadocMarkupWriter * obj)
975 {
976 ValadocMarkupWriter * self;
977 self = G_TYPE_CHECK_INSTANCE_CAST (obj, VALADOC_TYPE_MARKUP_WRITER, ValadocMarkupWriter);
978 g_signal_handlers_destroy (self);
979 (self->write_target_destroy_notify == NULL) ? NULL : (self->write_target_destroy_notify (self->write_target), NULL);
980 self->write = NULL;
981 self->write_target = NULL;
982 self->write_target_destroy_notify = NULL;
983 }
984
985 /**
986 * Writes markups and text to a file.
987 */
988 static GType
valadoc_markup_writer_get_type_once(void)989 valadoc_markup_writer_get_type_once (void)
990 {
991 static const GTypeValueTable g_define_type_value_table = { valadoc_value_markup_writer_init, valadoc_value_markup_writer_free_value, valadoc_value_markup_writer_copy_value, valadoc_value_markup_writer_peek_pointer, "p", valadoc_value_markup_writer_collect_value, "p", valadoc_value_markup_writer_lcopy_value };
992 static const GTypeInfo g_define_type_info = { sizeof (ValadocMarkupWriterClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) valadoc_markup_writer_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ValadocMarkupWriter), 0, (GInstanceInitFunc) valadoc_markup_writer_instance_init, &g_define_type_value_table };
993 static const GTypeFundamentalInfo g_define_type_fundamental_info = { (G_TYPE_FLAG_CLASSED | G_TYPE_FLAG_INSTANTIATABLE | G_TYPE_FLAG_DERIVABLE | G_TYPE_FLAG_DEEP_DERIVABLE) };
994 GType valadoc_markup_writer_type_id;
995 valadoc_markup_writer_type_id = g_type_register_fundamental (g_type_fundamental_next (), "ValadocMarkupWriter", &g_define_type_info, &g_define_type_fundamental_info, 0);
996 ValadocMarkupWriter_private_offset = g_type_add_instance_private (valadoc_markup_writer_type_id, sizeof (ValadocMarkupWriterPrivate));
997 return valadoc_markup_writer_type_id;
998 }
999
1000 GType
valadoc_markup_writer_get_type(void)1001 valadoc_markup_writer_get_type (void)
1002 {
1003 static volatile gsize valadoc_markup_writer_type_id__volatile = 0;
1004 if (g_once_init_enter (&valadoc_markup_writer_type_id__volatile)) {
1005 GType valadoc_markup_writer_type_id;
1006 valadoc_markup_writer_type_id = valadoc_markup_writer_get_type_once ();
1007 g_once_init_leave (&valadoc_markup_writer_type_id__volatile, valadoc_markup_writer_type_id);
1008 }
1009 return valadoc_markup_writer_type_id__volatile;
1010 }
1011
1012 gpointer
valadoc_markup_writer_ref(gpointer instance)1013 valadoc_markup_writer_ref (gpointer instance)
1014 {
1015 ValadocMarkupWriter * self;
1016 self = instance;
1017 g_atomic_int_inc (&self->ref_count);
1018 return instance;
1019 }
1020
1021 void
valadoc_markup_writer_unref(gpointer instance)1022 valadoc_markup_writer_unref (gpointer instance)
1023 {
1024 ValadocMarkupWriter * self;
1025 self = instance;
1026 if (g_atomic_int_dec_and_test (&self->ref_count)) {
1027 VALADOC_MARKUP_WRITER_GET_CLASS (self)->finalize (self);
1028 g_type_free_instance ((GTypeInstance *) self);
1029 }
1030 }
1031
1032