LupusNobilis/sogo
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
sogo/OpenChange/unrtf-0.21.2.diff
Julien Kerihuel 7e001a05a4 Issue #1829: Fix crash in unrtf library. 
Integer overflow in array index leading to unpredictable behavior.
Using correct integer signess and casting fix the problem and turn
negative value into 0. Expected fallback behavior then apply.

Make use of uint8_t since the hash array is a static array of 255 elements.
2013-01-18 10:27:37 -05:00

12506 lines
394 KiB
Diff
Raw Blame History

diff -durpN unrtf-0.21.2.old/configure.ac unrtf-0.21.2/configure.ac
--- unrtf-0.21.2.old/configure.ac 2010-08-15 03:59:52.000000000 +0200
+++ unrtf-0.21.2/configure.ac 2013-01-17 02:42:10.681861561 +0100
@@ -33,7 +33,7 @@ AC_HEADER_STDC
# following is not really necessary, since it is already done by preceding
# macro, but it shows how to extend HAVE_ macros to other headers.
-AC_CHECK_HEADERS([stdlib.h stdio.h ctype.h string.h])
+AC_CHECK_HEADERS([stdlib.h stdio.h ctype.h string.h stdint.h])
# Checks for typedefs, structures, and compiler characteristics.
diff -durpN unrtf-0.21.2.old/outputs/html.conf unrtf-0.21.2/outputs/html.conf
--- unrtf-0.21.2.old/outputs/html.conf 2010-08-15 14:44:09.000000000 +0200
+++ unrtf-0.21.2/outputs/html.conf 2013-01-17 02:41:09.681864239 +0100
@@ -5,7 +5,7 @@ comment_end
-->
document_begin
- <!DOCTYPE html PUBLIC -//W3C//DTD HTML 4.01 Transitional//EN>
+ <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html40/loose.dtd">
#Second test of comments
<html>
@@ -67,7 +67,7 @@ align_right_end
</div>
forced_space
- &nbsp
+ &nbsp;
line_break
<br>
diff -durpN unrtf-0.21.2.old/src/attr.c unrtf-0.21.2/src/attr.c
--- unrtf-0.21.2.old/src/attr.c 2010-07-04 04:30:58.000000000 +0200
+++ unrtf-0.21.2/src/attr.c 2013-01-17 02:41:09.681864239 +0100
@@ -1,23 +1,23 @@
/*=============================================================================
- GNU UnRTF, a command-line program to convert RTF documents to other formats.
- Copyright (C) 2000,2001,2004 by Zachary Smith
+ GNU UnRTF, a command-line program to convert RTF documents to other formats.
+ Copyright (C) 2000,2001,2004 by Zachary Smith
- 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 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.
+ 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, write to the Free Software
- Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- The maintainer is reachable by electronic mail at daved@physiol.usyd.edu.au
-=============================================================================*/
+ The maintainer is reachable by electronic mail at daved@physiol.usyd.edu.au
+ =============================================================================*/
/*----------------------------------------------------------------------
@@ -57,47 +57,20 @@
#include <stdarg.h>
#endif
+#include "attr.h"
+#include "convert.h"
#include "malloc.h"
#include "defs.h"
#include "error.h"
+#include "output.h"
+#include "unrtf.h"
#ifndef HAVE_ATTR_H
-#include "attr.h"
#define HAVE_ATTR_H
#endif
#include "main.h"
-extern void starting_body();
-extern void starting_text();
-
-extern int simulate_allcaps;
-extern int simulate_smallcaps;
-
-
-#define MAX_ATTRS (10000)
-
-
-/* For each RTF text block (the text within braces) we must keep
- * an AttrStack which is a stack of attributes and their optional
- * parameter. Since RTF text blocks are nested, these make up a
- * stack of stacks. And, since RTF text blocks inherit attributes
- * from parent blocks, all new AttrStacks do the same from
- * their parent AttrStack.
- */
-typedef struct _stack {
- unsigned char attr_stack[MAX_ATTRS];
- char *attr_stack_params[MAX_ATTRS];
- int tos;
- struct _stack *next;
-} AttrStack;
-
-/*@null@*/ static AttrStack *stack_of_stacks = NULL;
-/*@null@*/ static AttrStack *stack_of_stacks_top = NULL;
-
-
-
-
/*========================================================================
* Name: attr_express_begin
* Purpose: Print the HTML for beginning an attribute.
@@ -106,95 +79,96 @@ typedef struct _stack {
*=======================================================================*/
void
-attr_express_begin (int attr, char* param) {
- switch(attr)
- {
- case ATTR_BOLD:
- if (safe_printf(0, op->bold_begin)) fprintf(stderr, TOO_MANY_ARGS, "bold_begin");;
- break;
- case ATTR_ITALIC:
- if (safe_printf(0, op->italic_begin)) fprintf(stderr, TOO_MANY_ARGS, "italic_begin");;
- break;
+attr_express_begin (int attr, char* param, const struct OutputContext *oc) {
+ const struct unRTFOutputDevice *device = &oc->conversion->options->device;
+ switch(attr)
+ {
+ case ATTR_BOLD:
+ if (safe_printf(device, 0, oc->personality->bold_begin)) fprintf(stderr, TOO_MANY_ARGS, "bold_begin");;
+ break;
+ case ATTR_ITALIC:
+ if (safe_printf(device, 0, oc->personality->italic_begin)) fprintf(stderr, TOO_MANY_ARGS, "italic_begin");;
+ break;
- /* Various underlines, they all resolve to HTML's <u> */
- case ATTR_THICK_UL:
- case ATTR_WAVE_UL:
- case ATTR_DASH_UL:
- case ATTR_DOT_UL:
- case ATTR_DOT_DASH_UL:
- case ATTR_2DOT_DASH_UL:
- case ATTR_WORD_UL:
- case ATTR_UNDERLINE:
- if (safe_printf(0, op->underline_begin)) fprintf(stderr, TOO_MANY_ARGS, "underline_begin");;
- break;
+ /* Various underlines, they all resolve to HTML's <u> */
+ case ATTR_THICK_UL:
+ case ATTR_WAVE_UL:
+ case ATTR_DASH_UL:
+ case ATTR_DOT_UL:
+ case ATTR_DOT_DASH_UL:
+ case ATTR_2DOT_DASH_UL:
+ case ATTR_WORD_UL:
+ case ATTR_UNDERLINE:
+ if (safe_printf(device, 0, oc->personality->underline_begin)) fprintf(stderr, TOO_MANY_ARGS, "underline_begin");;
+ break;
- case ATTR_DOUBLE_UL:
- if (safe_printf(0, op->dbl_underline_begin)) fprintf(stderr, TOO_MANY_ARGS, "dbl_underline_begin");;
- break;
+ case ATTR_DOUBLE_UL:
+ if (safe_printf(device, 0, oc->personality->dbl_underline_begin)) fprintf(stderr, TOO_MANY_ARGS, "dbl_underline_begin");;
+ break;
- case ATTR_FONTSIZE:
- op_begin_std_fontsize (op, atoi (param));
- break;
+ case ATTR_FONTSIZE:
+ op_begin_std_fontsize (oc, atoi (param));
+ break;
- case ATTR_FONTFACE:
- if (safe_printf(1, op->font_begin,param)) fprintf(stderr, TOO_MANY_ARGS, "font_begin");;
- break;
+ case ATTR_FONTFACE:
+ if (safe_printf(device, 1, oc->personality->font_begin,param)) fprintf(stderr, TOO_MANY_ARGS, "font_begin");;
+ break;
- case ATTR_FOREGROUND:
- if (safe_printf(1, op->foreground_begin, param)) fprintf(stderr, TOO_MANY_ARGS, "foreground_begin");;
- break;
+ case ATTR_FOREGROUND:
+ if (safe_printf(device, 1, oc->personality->foreground_begin, param)) fprintf(stderr, TOO_MANY_ARGS, "foreground_begin");;
+ break;
- case ATTR_BACKGROUND:
- if (!simple_mode)
- if (safe_printf(1, op->background_begin,param)) fprintf(stderr, TOO_MANY_ARGS, "background_begin");;
- break;
+ case ATTR_BACKGROUND:
+ if (!oc->conversion->options->simple_mode)
+ if (safe_printf(device, 1, oc->personality->background_begin,param)) fprintf(stderr, TOO_MANY_ARGS, "background_begin");;
+ break;
- case ATTR_SUPER:
- if (safe_printf(0, op->superscript_begin)) fprintf(stderr, TOO_MANY_ARGS, "superscript_begin");;
- break;
- case ATTR_SUB:
- if (safe_printf(0, op->subscript_begin)) fprintf(stderr, TOO_MANY_ARGS, "subscript_begin");;
- break;
+ case ATTR_SUPER:
+ if (safe_printf(device, 0, oc->personality->superscript_begin)) fprintf(stderr, TOO_MANY_ARGS, "superscript_begin");;
+ break;
+ case ATTR_SUB:
+ if (safe_printf(device, 0, oc->personality->subscript_begin)) fprintf(stderr, TOO_MANY_ARGS, "subscript_begin");;
+ break;
- case ATTR_STRIKE:
- if (safe_printf(0, op->strikethru_begin)) fprintf(stderr, TOO_MANY_ARGS, "strikethru_begin");;
- break;
+ case ATTR_STRIKE:
+ if (safe_printf(device, 0, oc->personality->strikethru_begin)) fprintf(stderr, TOO_MANY_ARGS, "strikethru_begin");;
+ break;
- case ATTR_DBL_STRIKE:
- if (safe_printf(0, op->dbl_strikethru_begin)) fprintf(stderr, TOO_MANY_ARGS, "dbl_strikethru_begin");;
- break;
+ case ATTR_DBL_STRIKE:
+ if (safe_printf(device, 0, oc->personality->dbl_strikethru_begin)) fprintf(stderr, TOO_MANY_ARGS, "dbl_strikethru_begin");;
+ break;
- case ATTR_EXPAND:
- if (safe_printf(1, op->expand_begin, param)) fprintf(stderr, TOO_MANY_ARGS, "expand_begin");;
- break;
+ case ATTR_EXPAND:
+ if (safe_printf(device, 1, oc->personality->expand_begin, param)) fprintf(stderr, TOO_MANY_ARGS, "expand_begin");;
+ break;
- case ATTR_OUTLINE:
- if (safe_printf(0, op->outline_begin)) fprintf(stderr, TOO_MANY_ARGS, "outline_begin");;
- break;
- case ATTR_SHADOW:
- if (safe_printf(0, op->shadow_begin)) fprintf(stderr, TOO_MANY_ARGS, "shadow_begin");;
- break;
- case ATTR_EMBOSS:
- if (safe_printf(0, op->emboss_begin)) fprintf(stderr, TOO_MANY_ARGS, "emboss_begin");;
- break;
- case ATTR_ENGRAVE:
- if (safe_printf(0, op->engrave_begin)) fprintf(stderr, TOO_MANY_ARGS, "engrave_begin");;
- break;
+ case ATTR_OUTLINE:
+ if (safe_printf(device, 0, oc->personality->outline_begin)) fprintf(stderr, TOO_MANY_ARGS, "outline_begin");;
+ break;
+ case ATTR_SHADOW:
+ if (safe_printf(device, 0, oc->personality->shadow_begin)) fprintf(stderr, TOO_MANY_ARGS, "shadow_begin");;
+ break;
+ case ATTR_EMBOSS:
+ if (safe_printf(device, 0, oc->personality->emboss_begin)) fprintf(stderr, TOO_MANY_ARGS, "emboss_begin");;
+ break;
+ case ATTR_ENGRAVE:
+ if (safe_printf(device, 0, oc->personality->engrave_begin)) fprintf(stderr, TOO_MANY_ARGS, "engrave_begin");;
+ break;
- case ATTR_CAPS:
- if (op->simulate_all_caps)
- simulate_allcaps = TRUE;
- break;
+ case ATTR_CAPS:
+ if (oc->personality->simulate_all_caps)
+ oc->conversion->simulate_allcaps = TRUE;
+ break;
- case ATTR_SMALLCAPS:
- if (op->simulate_small_caps)
- simulate_smallcaps = TRUE;
- else {
- if (op->small_caps_begin)
- if (safe_printf(0, op->small_caps_begin)) fprintf(stderr, TOO_MANY_ARGS, "small_caps_begin");;
- }
- break;
- }
+ case ATTR_SMALLCAPS:
+ if (oc->personality->simulate_small_caps)
+ oc->conversion->simulate_smallcaps = TRUE;
+ else {
+ if (oc->personality->small_caps_begin)
+ if (safe_printf(device, 0, oc->personality->small_caps_begin)) fprintf(stderr, TOO_MANY_ARGS, "small_caps_begin");;
+ }
+ break;
+ }
}
@@ -206,95 +180,96 @@ attr_express_begin (int attr, char* para
*=======================================================================*/
void
-attr_express_end (int attr, char *param)
+attr_express_end (int attr, char *param, const struct OutputContext *oc)
{
- switch(attr)
- {
- case ATTR_BOLD:
- if (safe_printf(0, op->bold_end)) fprintf(stderr, TOO_MANY_ARGS, "bold_end");;
- break;
- case ATTR_ITALIC:
- if (safe_printf(0, op->italic_end)) fprintf(stderr, TOO_MANY_ARGS, "italic_end");;
- break;
+ const struct unRTFOutputDevice *device = &oc->conversion->options->device;
+ switch(attr)
+ {
+ case ATTR_BOLD:
+ if (safe_printf(device, 0, oc->personality->bold_end)) fprintf(stderr, TOO_MANY_ARGS, "bold_end");;
+ break;
+ case ATTR_ITALIC:
+ if (safe_printf(device, 0, oc->personality->italic_end)) fprintf(stderr, TOO_MANY_ARGS, "italic_end");;
+ break;
- /* Various underlines, they all resolve to HTML's </u> */
- case ATTR_THICK_UL:
- case ATTR_WAVE_UL:
- case ATTR_DASH_UL:
- case ATTR_DOT_UL:
- case ATTR_DOT_DASH_UL:
- case ATTR_2DOT_DASH_UL:
- case ATTR_WORD_UL:
- case ATTR_UNDERLINE:
- if (safe_printf(0, op->underline_end)) fprintf(stderr, TOO_MANY_ARGS, "underline_end");;
- break;
+ /* Various underlines, they all resolve to HTML's </u> */
+ case ATTR_THICK_UL:
+ case ATTR_WAVE_UL:
+ case ATTR_DASH_UL:
+ case ATTR_DOT_UL:
+ case ATTR_DOT_DASH_UL:
+ case ATTR_2DOT_DASH_UL:
+ case ATTR_WORD_UL:
+ case ATTR_UNDERLINE:
+ if (safe_printf(device, 0, oc->personality->underline_end)) fprintf(stderr, TOO_MANY_ARGS, "underline_end");;
+ break;
- case ATTR_DOUBLE_UL:
- if (safe_printf(0, op->dbl_underline_end)) fprintf(stderr, TOO_MANY_ARGS, "dbl_underline_end");;
- break;
+ case ATTR_DOUBLE_UL:
+ if (safe_printf(device, 0, oc->personality->dbl_underline_end)) fprintf(stderr, TOO_MANY_ARGS, "dbl_underline_end");;
+ break;
- case ATTR_FONTSIZE:
- op_end_std_fontsize (op, atoi (param));
- break;
+ case ATTR_FONTSIZE:
+ op_end_std_fontsize (oc, atoi (param));
+ break;
- case ATTR_FONTFACE:
- if (safe_printf(0, op->font_end)) fprintf(stderr, TOO_MANY_ARGS, "font_end");;
- break;
+ case ATTR_FONTFACE:
+ if (safe_printf(device, 0, oc->personality->font_end)) fprintf(stderr, TOO_MANY_ARGS, "font_end");;
+ break;
- case ATTR_FOREGROUND:
- if (safe_printf(0, op->foreground_end)) fprintf(stderr, TOO_MANY_ARGS, "foreground_end");;
- break;
- case ATTR_BACKGROUND:
- if (!simple_mode)
- if (safe_printf(0, op->background_end)) fprintf(stderr, TOO_MANY_ARGS, "background_end");;
- break;
+ case ATTR_FOREGROUND:
+ if (safe_printf(device, 0, oc->personality->foreground_end)) fprintf(stderr, TOO_MANY_ARGS, "foreground_end");;
+ break;
+ case ATTR_BACKGROUND:
+ if (!oc->conversion->options->simple_mode)
+ if (safe_printf(device, 0, oc->personality->background_end)) fprintf(stderr, TOO_MANY_ARGS, "background_end");;
+ break;
- case ATTR_SUPER:
- if (safe_printf(0, op->superscript_end)) fprintf(stderr, TOO_MANY_ARGS, "superscript_end");;
- break;
- case ATTR_SUB:
- if (safe_printf(0, op->subscript_end)) fprintf(stderr, TOO_MANY_ARGS, "subscript_end");;
- break;
+ case ATTR_SUPER:
+ if (safe_printf(device, 0, oc->personality->superscript_end)) fprintf(stderr, TOO_MANY_ARGS, "superscript_end");;
+ break;
+ case ATTR_SUB:
+ if (safe_printf(device, 0, oc->personality->subscript_end)) fprintf(stderr, TOO_MANY_ARGS, "subscript_end");;
+ break;
- case ATTR_STRIKE:
- if (safe_printf(0, op->strikethru_end)) fprintf(stderr, TOO_MANY_ARGS, "strikethru_end");;
- break;
+ case ATTR_STRIKE:
+ if (safe_printf(device, 0, oc->personality->strikethru_end)) fprintf(stderr, TOO_MANY_ARGS, "strikethru_end");;
+ break;
- case ATTR_DBL_STRIKE:
- if (safe_printf(0, op->dbl_strikethru_end)) fprintf(stderr, TOO_MANY_ARGS, "dbl_strikethru_end");;
- break;
+ case ATTR_DBL_STRIKE:
+ if (safe_printf(device, 0, oc->personality->dbl_strikethru_end)) fprintf(stderr, TOO_MANY_ARGS, "dbl_strikethru_end");;
+ break;
- case ATTR_OUTLINE:
- if (safe_printf(0, op->outline_end)) fprintf(stderr, TOO_MANY_ARGS, "outline_end");;
- break;
- case ATTR_SHADOW:
- if (safe_printf(0, op->shadow_end)) fprintf(stderr, TOO_MANY_ARGS, "shadow_end");;
- break;
- case ATTR_EMBOSS:
- if (safe_printf(0, op->emboss_end)) fprintf(stderr, TOO_MANY_ARGS, "emboss_end");;
- break;
- case ATTR_ENGRAVE:
- if (safe_printf(0, op->engrave_end)) fprintf(stderr, TOO_MANY_ARGS, "engrave_end");;
- break;
+ case ATTR_OUTLINE:
+ if (safe_printf(device, 0, oc->personality->outline_end)) fprintf(stderr, TOO_MANY_ARGS, "outline_end");;
+ break;
+ case ATTR_SHADOW:
+ if (safe_printf(device, 0, oc->personality->shadow_end)) fprintf(stderr, TOO_MANY_ARGS, "shadow_end");;
+ break;
+ case ATTR_EMBOSS:
+ if (safe_printf(device, 0, oc->personality->emboss_end)) fprintf(stderr, TOO_MANY_ARGS, "emboss_end");;
+ break;
+ case ATTR_ENGRAVE:
+ if (safe_printf(device, 0, oc->personality->engrave_end)) fprintf(stderr, TOO_MANY_ARGS, "engrave_end");;
+ break;
- case ATTR_EXPAND:
- if (safe_printf(0, op->expand_end)) fprintf(stderr, TOO_MANY_ARGS, "expand_end");;
- break;
+ case ATTR_EXPAND:
+ if (safe_printf(device, 0, oc->personality->expand_end)) fprintf(stderr, TOO_MANY_ARGS, "expand_end");;
+ break;
- case ATTR_CAPS:
- if (op->simulate_all_caps)
- simulate_allcaps = FALSE;
- break;
+ case ATTR_CAPS:
+ if (oc->personality->simulate_all_caps)
+ oc->conversion->simulate_allcaps = FALSE;
+ break;
- case ATTR_SMALLCAPS:
- if (op->simulate_small_caps)
- simulate_smallcaps = FALSE;
- else {
- if (op->small_caps_end)
- if (safe_printf(0, op->small_caps_end)) fprintf(stderr, TOO_MANY_ARGS, "small_caps_end");;
- }
- break;
- }
+ case ATTR_SMALLCAPS:
+ if (oc->personality->simulate_small_caps)
+ oc->conversion->simulate_smallcaps = FALSE;
+ else {
+ if (oc->personality->small_caps_end)
+ if (safe_printf(device, 0, oc->personality->small_caps_end)) fprintf(stderr, TOO_MANY_ARGS, "small_caps_end");;
+ }
+ break;
+ }
}
@@ -307,32 +282,32 @@ attr_express_end (int attr, char *param)
*=======================================================================*/
void
-attr_push(int attr, char* param)
+attr_push(int attr, char* param, const struct OutputContext *oc)
{
- AttrStack *stack = stack_of_stacks_top;
- if (!stack) {
- warning_handler("No stack to push attribute onto");
- return;
- }
+ AttrStack *stack = oc->conversion->stack_of_stacks_top;
+ if (!stack) {
+ warning_handler("No stack to push attribute onto");
+ return;
+ }
- if (stack->tos >= MAX_ATTRS) {
- fprintf(stderr, "Too many attributes!\n");
- return;
- }
+ if (stack->tos >= MAX_ATTRS) {
+ fprintf(stderr, "Too many attributes!\n");
+ return;
+ }
- /* Make sure it's understood we're in the <body> section. */
- /* KLUDGE */
- starting_body();
- starting_text();
+ /* Make sure it's understood we're in the <body> section. */
+ /* KLUDGE */
+ starting_body(oc);
+ starting_text(oc);
- ++stack->tos;
- stack->attr_stack[stack->tos] = attr;
- if (param)
- stack->attr_stack_params[stack->tos] = my_strdup(param);
- else
- stack->attr_stack_params[stack->tos] = NULL;
+ ++stack->tos;
+ stack->attr_stack[stack->tos] = attr;
+ if (param)
+ stack->attr_stack_params[stack->tos] = unrtf_strdup(oc->conversion, param);
+ else
+ stack->attr_stack_params[stack->tos] = NULL;
- attr_express_begin(attr, param);
+ attr_express_begin(attr, param, oc);
}
@@ -344,62 +319,25 @@ attr_push(int attr, char* param)
*=======================================================================*/
char *
-attr_get_param(int attr)
-{
- int i;
- AttrStack *stack = stack_of_stacks_top;
- if (!stack) {
- warning_handler("No stack to get attribute from");
- return;
- }
-
- i=stack->tos;
- while (i>=0)
- {
- if(stack->attr_stack [i] == attr)
- {
- if(stack->attr_stack_params [i] != NULL)
- return stack->attr_stack_params [i];
- else
- return NULL;
- }
- i--;
- }
- return NULL;
-}
-
-
-/*========================================================================
- * Name: attrstack_copy_all
- * Purpose: Routine to copy all attributes from one stack to another.
- * Args: Two stacks.
- * Returns: None.
- *=======================================================================*/
-
-void
-attrstack_copy_all (AttrStack *src, AttrStack *dest)
+attr_get_param(const struct ConversionContext *cc, int attr)
{
- int i;
- int total;
-
- CHECK_PARAM_NOT_NULL(src);
- CHECK_PARAM_NOT_NULL(dest);
-
- total = src->tos + 1;
-
- for (i=0; i<total; i++)
- {
- int attr=src->attr_stack [i];
- char *param=src->attr_stack_params [i];
-
- dest->attr_stack[i] = attr;
- if (param)
- dest->attr_stack_params[i] = my_strdup (param);
- else
- dest->attr_stack_params[i] = NULL;
- }
+ int i;
+ AttrStack *stack = cc->stack_of_stacks_top;
+ if (!stack) {
+ warning_handler("No stack to get attribute from");
+ return NULL;
+ }
- dest->tos = src->tos;
+ i=stack->tos;
+ while (i>=0)
+ {
+ if(stack->attr_stack[i] == attr)
+ {
+ return stack->attr_stack_params[i];
+ }
+ i--;
+ }
+ return NULL;
}
/*========================================================================
@@ -414,21 +352,21 @@ attrstack_copy_all (AttrStack *src, Attr
*=======================================================================*/
void
-attrstack_unexpress_all (AttrStack *stack)
+attrstack_unexpress_all (AttrStack *stack, const struct OutputContext *oc)
{
- int i;
+ int i;
- CHECK_PARAM_NOT_NULL(stack);
+ CHECK_PARAM_NOT_NULL(stack);
- i=stack->tos;
- while (i>=0)
- {
- int attr=stack->attr_stack [i];
- char *param=stack->attr_stack_params [i];
+ i=stack->tos;
+ while (i>=0)
+ {
+ int attr=stack->attr_stack[i];
+ char *param=stack->attr_stack_params[i];
- attr_express_end (attr, param);
- i--;
- }
+ attr_express_end (attr, param, oc);
+ i--;
+ }
}
@@ -440,23 +378,20 @@ attrstack_unexpress_all (AttrStack *stac
* Returns: None.
*=======================================================================*/
void
-attrstack_push ()
+attrstack_push (struct ConversionContext *cc)
{
- AttrStack *new_stack;
- AttrStack *prev_stack;
-
- new_stack = (AttrStack*) my_malloc (sizeof (AttrStack));
- memset ((void*) new_stack, 0, sizeof (AttrStack));
+ AttrStack *new_stack;
- prev_stack = stack_of_stacks_top;
+ new_stack = (AttrStack*) unrtf_malloc (sizeof (AttrStack));
+ memset ((void*) new_stack, 0, sizeof (AttrStack));
+ new_stack->tos = -1;
- if (!stack_of_stacks) {
- stack_of_stacks = new_stack;
- } else {
- stack_of_stacks_top->next = new_stack;
- }
- stack_of_stacks_top = new_stack;
- new_stack->tos = -1;
+ if (!cc->stack_of_stacks) {
+ cc->stack_of_stacks = new_stack;
+ } else {
+ cc->stack_of_stacks_top->next = new_stack;
+ }
+ cc->stack_of_stacks_top = new_stack;
}
@@ -470,29 +405,30 @@ attrstack_push ()
*=======================================================================*/
int
-attr_pop (int attr)
+attr_pop (int attr, const struct OutputContext *oc)
{
- AttrStack *stack = stack_of_stacks_top;
+ AttrStack *stack = oc->conversion->stack_of_stacks_top;
- if (!stack) {
- warning_handler ("no stack to pop attribute from");
- return FALSE;
- }
+ if (!stack) {
+ warning_handler ("no stack to pop attribute from");
+ return FALSE;
+ }
- if(stack->tos>=0 && stack->attr_stack[stack->tos]==attr)
- {
- char *param = stack->attr_stack_params [stack->tos];
+ if(stack->tos>=0 && stack->attr_stack[stack->tos]==attr)
+ {
+ char *param = stack->attr_stack_params[stack->tos];
- attr_express_end (attr, param);
+ attr_express_end (attr, param, oc);
- if (param) my_free(param);
+ if (param) unrtf_free(param);
+ stack->attr_stack_params[stack->tos] = NULL;
- stack->tos--;
+ stack->tos--;
- return TRUE;
- }
- else
- return FALSE;
+ return TRUE;
+ }
+ else
+ return FALSE;
}
@@ -506,20 +442,20 @@ attr_pop (int attr)
*=======================================================================*/
int
-attr_read() {
- AttrStack *stack = stack_of_stacks_top;
- if (!stack) {
- warning_handler ("no stack to read attribute from");
- return FALSE;
- }
+attr_read(const struct ConversionContext *cc) {
+ AttrStack *stack = cc->stack_of_stacks_top;
+ if (!stack) {
+ warning_handler ("no stack to read attribute from");
+ return FALSE;
+ }
- if(stack->tos>=0)
- {
- int attr = stack->attr_stack [stack->tos];
- return attr;
- }
- else
- return ATTR_NONE;
+ if(stack->tos>=0)
+ {
+ int attr = stack->attr_stack[stack->tos];
+ return attr;
+ }
+ else
+ return ATTR_NONE;
}
@@ -531,20 +467,21 @@ attr_read() {
*=======================================================================*/
void
-attr_drop_all ()
+attr_drop_all (const struct ConversionContext *cc)
{
- AttrStack *stack = stack_of_stacks_top;
- if (!stack) {
- warning_handler ("no stack to drop all attributes from");
- return;
- }
+ AttrStack *stack = cc->stack_of_stacks_top;
+ if (!stack) {
+ warning_handler ("no stack to drop all attributes from");
+ return;
+ }
- while (stack->tos>=0)
- {
- char *param=stack->attr_stack_params [stack->tos];
- if (param) my_free(param);
- stack->tos--;
- }
+ while (stack->tos>=0)
+ {
+ char *param=stack->attr_stack_params[stack->tos];
+ if (param) unrtf_free(param);
+ stack->attr_stack_params[stack->tos] = NULL;
+ stack->tos--;
+ }
}
@@ -557,30 +494,34 @@ attr_drop_all ()
*=======================================================================*/
void
-attrstack_drop ()
+attrstack_drop (const struct OutputContext *oc)
{
- AttrStack *stack = stack_of_stacks_top;
- AttrStack *prev_stack;
- if (!stack) {
- warning_handler ("no attr-stack to drop");
- return;
- }
+ AttrStack *stack = oc->conversion->stack_of_stacks_top;
+ AttrStack *prev_stack;
+ if (!stack) {
+ warning_handler ("no attr-stack to drop");
+ return;
+ }
- attr_pop_all ();
- prev_stack = stack_of_stacks;
+ attr_pop_all (oc);
- while(prev_stack && prev_stack->next && prev_stack->next != stack)
- prev_stack = prev_stack->next;
+ if (stack == oc->conversion->stack_of_stacks) {
+ oc->conversion->stack_of_stacks_top = NULL;
+ oc->conversion->stack_of_stacks = NULL;
+ }
+ else {
+ prev_stack = oc->conversion->stack_of_stacks;
- if (prev_stack) {
- stack_of_stacks_top = prev_stack;
- prev_stack->next = NULL;
- } else {
- stack_of_stacks_top = NULL;
- stack_of_stacks = NULL;
- }
+ while (prev_stack->next && prev_stack->next != stack)
+ prev_stack = prev_stack->next;
- my_free ((void*) stack);
+ if (prev_stack) {
+ oc->conversion->stack_of_stacks_top = prev_stack;
+ prev_stack->next = NULL;
+ }
+ }
+
+ unrtf_free ((void*) stack);
}
/*========================================================================
@@ -592,21 +533,22 @@ attrstack_drop ()
*=======================================================================*/
void
-attr_pop_all()
+attr_pop_all(const struct OutputContext *oc)
{
- AttrStack *stack = stack_of_stacks_top;
- if (!stack) {
- warning_handler ("no stack to pop from");
- return;
- }
+ AttrStack *stack = oc->conversion->stack_of_stacks_top;
+ if (!stack) {
+ warning_handler ("no stack to pop from");
+ return;
+ }
- while (stack->tos>=0) {
- int attr=stack->attr_stack [stack->tos];
- char *param=stack->attr_stack_params [stack->tos];
- attr_express_end (attr,param);
- if (param) my_free(param);
- stack->tos--;
- }
+ while (stack->tos>=0) {
+ int attr=stack->attr_stack[stack->tos];
+ char *param=stack->attr_stack_params[stack->tos];
+ attr_express_end (attr,param, oc);
+ if (param) unrtf_free(param);
+ stack->attr_stack_params[stack->tos] = NULL;
+ stack->tos--;
+ }
}
@@ -621,23 +563,23 @@ attr_pop_all()
*=======================================================================*/
void
-attrstack_express_all() {
- AttrStack *stack = stack_of_stacks_top;
- int i;
+attrstack_express_all(const struct OutputContext *oc) {
+ AttrStack *stack = oc->conversion->stack_of_stacks_top;
+ int i;
- if (!stack) {
- warning_handler ("no stack to pop from");
- return;
- }
+ if (!stack) {
+ warning_handler ("no stack to pop from");
+ return;
+ }
- i=0;
- while (i<=stack->tos)
- {
- int attr=stack->attr_stack [i];
- char *param=stack->attr_stack_params [i];
- attr_express_begin (attr, param);
- i++;
- }
+ i=0;
+ while (i<=stack->tos)
+ {
+ int attr=stack->attr_stack[i];
+ char *param=stack->attr_stack_params[i];
+ attr_express_begin (attr, param, oc);
+ i++;
+ }
}
@@ -652,78 +594,112 @@ attrstack_express_all() {
*=======================================================================*/
void
-attr_pop_dump() {
- AttrStack *stack = stack_of_stacks_top;
- int i;
+attr_pop_dump(const struct OutputContext *oc) {
+ AttrStack *stack = oc->conversion->stack_of_stacks_top;
+ int i;
- if (!stack) return;
+ if (!stack) return;
- i=stack->tos;
- while (i>=0)
- {
- int attr=stack->attr_stack [i];
- attr_pop (attr);
- i--;
- }
+ i=stack->tos;
+ while (i>=0)
+ {
+ int attr=stack->attr_stack[i];
+ attr_pop (attr, oc);
+ i--;
+ }
}
/*========================================================================
* Name: safe_printf
* Purpose: Prevents format string attack and writes empty string
- instead of NULL.
+ instead of NULL.
* Args: Number of parameters (without a string), string to write,
- additional parameters to print (have to be strings).
+ additional parameters to print (have to be strings).
* Returns: Returns 0 if number of not escaped '%' in string
- is not greater than nr, else returns -1
+ is not greater than nr, else returns -1
*=======================================================================*/
-
int
-safe_printf(int nr, char *string, ...)
+safe_printf(const struct unRTFOutputDevice *od, int nr, char *string, ...)
{
+ char *s, *output;
+ int i = 0, ret_code = 0, written;
+ size_t output_len = 0, output_max = 0, size_max;
+ va_list arguments;
- char *s;
- int i = 0, ret_code = 0;
- va_list arguments;
+ if (string != NULL)
+ {
+ output_max = 1024;
+ output = malloc(output_max * sizeof (char));
+ *output = 0;
+ va_start(arguments, string);
- if (string == NULL)
- printf("");
- else
- {
- va_start(arguments, string);
+ for (; nr > 0; nr--)
+ {
+ while (string[i] != '\0' && (string[i] != '%' || (string[i] == '%' && (i != 0 && string[i-1] == '\\'))))
+ {
+ if (string[i] != '\\' || string[i+1] != '%')
+ {
+ if (output_len + 1 > output_max)
+ {
+ output_max += 1024;
+ output = realloc(output, output_max * sizeof (char));
+ }
+ output[output_len] = string[i];
+ output_len++;
+ }
+ i++;
+ }
- for (; nr > 0; nr--)
- {
- while (string[i] != '\0' && (string[i] != '%' || (string[i] == '%' && (i != 0 && string[i-1] == '\\'))))
- {
- if (string[i] != '\\' || string[i+1] != '%')
- printf("%c", string[i]);
- i++;
- }
+ if (string[i] != '\0')
+ {
+ s = va_arg(arguments, char *);
+ size_max = output_max - output_len;
+ written = snprintf(output + output_len, size_max, "%s", s);
+ if (written > size_max)
+ {
+ output_max += 1024 + written;
+ output = realloc(output, (output_max + 1) * sizeof (char));
+ sprintf(output + output_len, "%s", s);
+ }
+ output_len += written;
+ i++;
+ }
+ }
+ va_end(arguments);
- if (string[i] != '\0')
- {
- s = va_arg(arguments, char *);
- printf("%s", s);
- i++;
- }
- }
- va_end(arguments);
+ while (string[i] != '\0')
+ {
+ if (string[i] != '\\' || (string[i] == '\\' && string[i+1] != '%'))
+ {
+ if (string[i] != '%' || (string[i] == '%' && (i != 0 && string[i-1] == '\\')))
+ {
+ if (output_len + 1 > output_max)
+ {
+ output_max += 1024;
+ output = realloc(output, output_max * sizeof (char));
+ }
+ output[output_len] = string[i];
+ output_len++;
+ }
+ else
+ ret_code = -1;
+ }
+ i++;
+ }
- while (string[i] != '\0')
- {
- if (string[i] != '\\' || (string[i] == '\\' && string[i+1] != '%'))
- {
- if (string[i] != '%' || (string[i] == '%' && (i != 0 && string[i-1] == '\\')))
- printf("%c", string[i]);
- else
- ret_code = -1;
- }
- i++;
- }
- }
+ if (output_len + 1 > output_max)
+ {
+ output_max += 1;
+ output = realloc(output, output_max * sizeof (char));
+ }
+ output[output_len] = 0;
- return ret_code;
+ od->print(od->data, output, output_len);
+ free(output);
+ }
+
+ return ret_code;
}
/*========================================================================
@@ -731,51 +707,51 @@ safe_printf(int nr, char *string, ...)
* Purpose: See Returns
* Args: String to return and int to put into first parameter.
* Returns: Returns first parameter where first not escaped
- character % is substituted with second parameter.
+ character % is substituted with second parameter.
*=======================================================================*/
char *
assemble_string(char *string, int nr)
{
- char *s, tmp[12];/* Number of characters that can be in int type (including '\0') - AF */
- int i = 0, j = 0;
+ char *s, tmp[12];/* Number of characters that can be in int type (including '\0') - AF */
+ int i = 0, j = 0;
- if (string == NULL)
- return NULL;
- else {
- s = my_malloc(strlen(string) + 1 + 12/* Number of characters that can be in int type (including '\0') - AF */);
- while(string[i] != '\0' && (string[i] != '%' || (string[i] == '%' && (i != 0 && string[i-1] == '\\')))) {
- if (string[i] != '\\' || string[i+1] != '%') {
- s[j] = string[i];
- j++;
- }
- i++;
- }
+ if (string == NULL)
+ return NULL;
+ else {
+ s = unrtf_malloc(strlen(string) + 1 + 12/* Number of characters that can be in int type (including '\0') - AF */);
+ while(string[i] != '\0' && (string[i] != '%' || (string[i] == '%' && (i != 0 && string[i-1] == '\\')))) {
+ if (string[i] != '\\' || string[i+1] != '%') {
+ s[j] = string[i];
+ j++;
+ }
+ i++;
+ }
- if (string[i] != '\0') {
- sprintf(tmp, "%d", nr);
- strcpy(&s[j], tmp);
- j = j + strlen(tmp);
- }
+ if (string[i] != '\0') {
+ sprintf(tmp, "%d", nr);
+ strcpy(&s[j], tmp);
+ j = j + strlen(tmp);
+ }
- while (string[i] != '\0') {
- if (string[i] != '\\' || (string[i] == '\\' && string[i+1] != '%')) {
- if (string[i] != '%' || (string[i] == '%' && (i != 0 && string[i-1] == '\\'))) {
- s[j] = string[i];
- j++;
- }
- else {
- /* More than one char % occured */
- }
- }
- i++;
- }
- }
+ while (string[i] != '\0') {
+ if (string[i] != '\\' || (string[i] == '\\' && string[i+1] != '%')) {
+ if (string[i] != '%' || (string[i] == '%' && (i != 0 && string[i-1] == '\\'))) {
+ s[j] = string[i];
+ j++;
+ }
+ else {
+ /* More than one char % occured */
+ }
+ }
+ i++;
+ }
+ }
- s[j] = '\0';
+ s[j] = '\0';
- return s;
+ return s;
}
@@ -789,39 +765,39 @@ assemble_string(char *string, int nr)
Collection *
add_to_collection(Collection *col, int nr, char *text)
{
- Collection *c = col;
+ Collection *c = col;
- if (col == NULL)
- {
- col = (Collection *)my_malloc(sizeof(Collection));
- col->nr = nr;
- col->text = text;
- col->next = NULL;
- }
- else
- {
- while (c->next != NULL)
- {
- if (c->nr == nr)
- {
-/* Here is a memory leak but not heavy. Do we need to care about this?
- my_free(a->alias.text);
-*/
- c->text = text;
+ if (col == NULL)
+ {
+ col = (Collection *)unrtf_malloc(sizeof(Collection));
+ col->nr = nr;
+ col->text = strdup(text);
+ col->next = NULL;
+ }
+ else
+ {
+ while (c->next != NULL)
+ {
+ if (c->nr == nr)
+ {
+ /* Here is a memory leak but not heavy. Do we need to care about this?
+ unrtf_free(a->alias.text);
+ */
+ c->text = strdup(text);
- return col;
- }
+ return col;
+ }
- c = c->next;
- }
+ c = c->next;
+ }
- c->next = (Collection *)my_malloc(sizeof(Collection));
- c->next->nr = nr;
- c->next->text = text;
- c->next->next = NULL;
- }
+ c->next = (Collection *)unrtf_malloc(sizeof(Collection));
+ c->next->nr = nr;
+ c->next->text = strdup(text);
+ c->next->next = NULL;
+ }
- return col;
+ return col;
}
/*========================================================================
@@ -834,15 +810,15 @@ add_to_collection(Collection *col, int n
char *
get_from_collection(Collection *c, int nr)
{
- while (c != NULL)
- {
- if (c->nr == nr)
- return c->text;
+ while (c != NULL)
+ {
+ if (c->nr == nr)
+ return c->text;
- c = c->next;
- }
+ c = c->next;
+ }
- return NULL;
+ return NULL;
}
/*========================================================================
@@ -855,13 +831,15 @@ get_from_collection(Collection *c, int n
void
free_collection(Collection *c)
{
- Collection *c2;
+ Collection *c2;
- while (c != NULL)
- {
- c2 = c->next;
- my_free((void *)c);
- c = c2;
- }
+ while (c != NULL)
+ {
+ c2 = c->next;
+ if (c->text) {
+ unrtf_free((void *)c->text);
+ }
+ unrtf_free((void *)c);
+ c = c2;
+ }
}
-
diff -durpN unrtf-0.21.2.old/src/attr.h unrtf-0.21.2/src/attr.h
--- unrtf-0.21.2.old/src/attr.h 2010-07-04 04:30:58.000000000 +0200
+++ unrtf-0.21.2/src/attr.h 2013-01-17 02:41:09.681864239 +0100
@@ -1,23 +1,23 @@
/*=============================================================================
- GNU UnRTF, a command-line program to convert RTF documents to other formats.
- Copyright (C) 2000,2001,2004 by Zachary Smith
+ GNU UnRTF, a command-line program to convert RTF documents to other formats.
+ Copyright (C) 2000,2001,2004 by Zachary Smith
- 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 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.
+ 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, write to the Free Software
- Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- The maintainer is reachable by electronic mail at daved@physiol.usyd.edu.au
-=============================================================================*/
+ The maintainer is reachable by electronic mail at daved@physiol.usyd.edu.au
+ =============================================================================*/
/*----------------------------------------------------------------------
@@ -35,69 +35,77 @@
* 09 Nov 08, arkadiusz.firus@gmail.com: adopt safe_printf & collection funcs
*--------------------------------------------------------------------*/
+#ifndef ATTR_H
+#define ATTR_H
+
enum {
- ATTR_NONE=0,
- ATTR_BOLD, ATTR_ITALIC,
+ ATTR_NONE=0,
+ ATTR_BOLD, ATTR_ITALIC,
- ATTR_UNDERLINE, ATTR_DOUBLE_UL, ATTR_WORD_UL,
+ ATTR_UNDERLINE, ATTR_DOUBLE_UL, ATTR_WORD_UL,
- ATTR_THICK_UL, ATTR_WAVE_UL,
+ ATTR_THICK_UL, ATTR_WAVE_UL,
- ATTR_DOT_UL, ATTR_DASH_UL, ATTR_DOT_DASH_UL, ATTR_2DOT_DASH_UL,
+ ATTR_DOT_UL, ATTR_DASH_UL, ATTR_DOT_DASH_UL, ATTR_2DOT_DASH_UL,
- ATTR_FONTSIZE, ATTR_STD_FONTSIZE,
- ATTR_FONTFACE,
- ATTR_FOREGROUND, ATTR_BACKGROUND,
- ATTR_CAPS,
- ATTR_SMALLCAPS,
+ ATTR_FONTSIZE, ATTR_STD_FONTSIZE,
+ ATTR_FONTFACE,
+ ATTR_FOREGROUND, ATTR_BACKGROUND,
+ ATTR_CAPS,
+ ATTR_SMALLCAPS,
- ATTR_SHADOW,
- ATTR_OUTLINE,
- ATTR_EMBOSS,
- ATTR_ENGRAVE,
+ ATTR_SHADOW,
+ ATTR_OUTLINE,
+ ATTR_EMBOSS,
+ ATTR_ENGRAVE,
- ATTR_SUPER, ATTR_SUB,
- ATTR_STRIKE,
- ATTR_DBL_STRIKE,
+ ATTR_SUPER, ATTR_SUB,
+ ATTR_STRIKE,
+ ATTR_DBL_STRIKE,
- ATTR_EXPAND,
- /* ATTR_CONDENSE */
+ ATTR_EXPAND,
+ /* ATTR_CONDENSE */
};
typedef struct _c
{
- int nr;
- char *text;
- struct _c *next;
+ int nr;
+ char *text;
+ struct _c *next;
} Collection;
Collection *add_to_collection(Collection *col, int nr, char *text);
char *get_from_collection(Collection *c, int nr);
void free_collection(Collection *c);
+struct ConversionContext;
+struct OutputContext;
+struct unRTFOutputDevice;
+
extern void attr_push_core (int attr, char* param);
extern void attr_pop_core (int attr);
-extern void attr_push(int attr, char* param);
+extern void attr_push(int attr, char* param, const struct OutputContext *oc);
-extern void attrstack_push();
-extern void attrstack_drop();
+extern void attrstack_push(struct ConversionContext *cc);
+extern void attrstack_drop(const struct OutputContext *oc);
extern void attrstack_express_all();
-extern int attr_pop(int attr);
+extern int attr_pop(int attr, const struct OutputContext *oc);
-extern int attr_read();
+extern int attr_read(const struct ConversionContext *cc);
extern void attr_drop_all ();
-extern void attr_pop_all();
+extern void attr_pop_all(const struct OutputContext *oc);
extern void attr_pop_dump();
-char * attr_get_param(int attr);
+char * attr_get_param(const struct ConversionContext *cc, int attr);
-int safe_printf(int nr, char *string, ...);
+int safe_printf(const struct unRTFOutputDevice *device, int nr, char *string, ...);
char *assemble_string(char *string, int nr);
#define TOO_MANY_ARGS "Tag name \"%s\" do not take so many arguments"
+#endif /* ATTR_H */
diff -durpN unrtf-0.21.2.old/src/convert.c unrtf-0.21.2/src/convert.c
--- unrtf-0.21.2.old/src/convert.c 2011-06-07 14:00:23.000000000 +0200
+++ unrtf-0.21.2/src/convert.c 2013-01-17 02:41:09.685864239 +0100
@@ -1,24 +1,24 @@
/*===========================================================================
- GNU UnRTF, a command-line program to convert RTF documents to other formats.
- Copyright (C) 2000,2001,2004 Zachary Thayer Smith
+ GNU UnRTF, a command-line program to convert RTF documents to other formats.
+ Copyright (C) 2000,2001,2004 Zachary Thayer Smith
- 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 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.
+ 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, write to the Free Software
- Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- The maintainer is reachable by electronic mail at daved@physiol.usyd.edu.au
-===========================================================================*/
+ The maintainer is reachable by electronic mail at daved@physiol.usyd.edu.au
+ ===========================================================================*/
/*----------------------------------------------------------------------
@@ -56,8 +56,8 @@
* 31 Mar 05, daved@physiol.usyd.edu.au: strcat security bug fixed
* 06 Jan 06, marcossamaral@terra.com.br: patch from debian 0.19.3-1.1
* 03 Mar 06, daved@physiol.usyd.edu.au: fixed creation date spelling
- and added support for accented characters in titles from
- Laurent Monin
+ and added support for accented characters in titles from
+ Laurent Monin
* 09 Mar 06, daved@physiol.usyd.edu.au: don't print null post_trans
* 18 Jun 06, daved@physiol.usyd.edu.au: fixed some incorrect comment_end
* 18 Jun 06, frolovs@internet2.ru: codepage support
@@ -68,7 +68,7 @@
* 04 Jan 10, arkadiusz.firus@gmail.com: deal with (faulty) negative unicodes
* 04 Jan 10, daved@physiol.usyd.edu.au: suppress <font face=Symbol>
* 21 Aug 10, daved@physiol.usyd.edu.au: add support for hex char doublet
- representation of special characters output by some rtf writers
+ representation of special characters output by some rtf writers
*--------------------------------------------------------------------*/
#ifdef HAVE_CONFIG_H
@@ -91,15 +91,21 @@
#include <string.h>
#endif
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+
#include "defs.h"
#include "parse.h"
#include "util.h"
#include "malloc.h"
-#include "main.h"
#include "error.h"
#include "word.h"
#include "hash.h"
+#include "output.h"
#include "convert.h"
+#include "user.h"
+#include "unrtf.h"
#ifndef HAVE_ATTR_H
#include "attr.h"
@@ -107,506 +113,460 @@
#endif
static CodepageInfo codepages[14] =
-{
-/*-- cp850 --*/
-{
- 850,
- {
- /* 0x80 */
- 0x00c7, 0x00fc, 0x00e9, 0x00e2, 0x00e4, 0x00e0, 0x00e5, 0x00e7,
- 0x00ea, 0x00eb, 0x00e8, 0x00ef, 0x00ee, 0x00ec, 0x00c4, 0x00c5,
- /* 0x90 */
- 0x00c9, 0x00e6, 0x00c6, 0x00f4, 0x00f6, 0x00f2, 0x00fb, 0x00f9,
- 0x00ff, 0x00d6, 0x00dc, 0x00f8, 0x00a3, 0x00d8, 0x00d7, 0x0192,
- /* 0xa0 */
- 0x00e1, 0x00ed, 0x00f3, 0x00fa, 0x00f1, 0x00d1, 0x00aa, 0x00ba,
- 0x00bf, 0x00ae, 0x00ac, 0x00bd, 0x00bc, 0x00a1, 0x00ab, 0x00bb,
- /* 0xb0 */
- 0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x00c1, 0x00c2, 0x00c0,
- 0x00a9, 0x2563, 0x2551, 0x2557, 0x255d, 0x00a2, 0x00a5, 0x2510,
- /* 0xc0 */
- 0x2514, 0x2534, 0x252c, 0x251c, 0x2500, 0x253c, 0x00e3, 0x00c3,
- 0x255a, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256c, 0x00a4,
- /* 0xd0 */
- 0x00f0, 0x00d0, 0x00ca, 0x00cb, 0x00c8, 0x0131, 0x00cd, 0x00ce,
- 0x00cf, 0x2518, 0x250c, 0x2588, 0x2584, 0x00a6, 0x00cc, 0x2580,
- /* 0xe0 */
- 0x00d3, 0x00df, 0x00d4, 0x00d2, 0x00f5, 0x00d5, 0x00b5, 0x00fe,
- 0x00de, 0x00da, 0x00db, 0x00d9, 0x00fd, 0x00dd, 0x00af, 0x00b4,
- /* 0xf0 */
- 0x00ad, 0x00b1, 0x2017, 0x00be, 0x00b6, 0x00a7, 0x00f7, 0x00b8,
- 0x00b0, 0x00a8, 0x00b7, 0x00b9, 0x00b3, 0x00b2, 0x25a0, 0x00a0,
- }
-},
-/*-- cp866 --*/
-{
- 866,
- {
- /* 0x80 */
- 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0,
- /* 0x90 */
- 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0,
- /* 0xa0 */
- 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0,
- /* 0xb0 */
- 0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x2561, 0x2562, 0x2556,
- 0x2555, 0x2563, 0x2551, 0x2557, 0x255d, 0x255c, 0x255b, 0x2510,
- /* 0xc0 */
- 0x2514, 0x2534, 0x252c, 0x251c, 0x2500, 0x253c, 0x255e, 0x255f,
- 0x255a, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256c, 0x2567,
- /* 0xd0 */
- 0x2568, 0x2564, 0x2565, 0x2559, 0x2558, 0x2552, 0x2553, 0x256b,
- 0x256a, 0x2518, 0x250c, 0x2588, 0x2584, 0x258c, 0x2590, 0x2580,
- /* 0xe0 */
- 0x0440, 0x0441, 0x0442, 0x0443, 0x0444, 0x0445, 0x0446, 0x0447,
- 0x0448, 0x0449, 0x044a, 0x044b, 0x044c, 0x044d, 0x044e, 0x044f,
- /* 0xf0 */
- 0x0401, 0x0451, 0x0404, 0x0454, 0x0407, 0x0457, 0x040e, 0x045e,
- 0x00b0, 0x2219, 0x00b7, 0x221a, 0x2116, 0x00a4, 0x25a0, 0x00a0,
- }
-},
-/*-- cp874 --*/
-{
- 874,
- {
- /* 0x80 */
- 0x20ac, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0x2026, 0xfffd, 0xfffd,
- 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd,
- /* 0x90 */
- 0xfffd, 0x2018, 0x2019, 0x201c, 0x201d, 0x2022, 0x2013, 0x2014,
- 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd,
- /* 0xa0 */
- 0x00a0, 0x0e01, 0x0e02, 0x0e03, 0x0e04, 0x0e05, 0x0e06, 0x0e07,
- 0x0e08, 0x0e09, 0x0e0a, 0x0e0b, 0x0e0c, 0x0e0d, 0x0e0e, 0x0e0f,
- /* 0xb0 */
- 0x0e10, 0x0e11, 0x0e12, 0x0e13, 0x0e14, 0x0e15, 0x0e16, 0x0e17,
- 0x0e18, 0x0e19, 0x0e1a, 0x0e1b, 0x0e1c, 0x0e1d, 0x0e1e, 0x0e1f,
- /* 0xc0 */
- 0x0e20, 0x0e21, 0x0e22, 0x0e23, 0x0e24, 0x0e25, 0x0e26, 0x0e27,
- 0x0e28, 0x0e29, 0x0e2a, 0x0e2b, 0x0e2c, 0x0e2d, 0x0e2e, 0x0e2f,
- /* 0xd0 */
- 0x0e30, 0x0e31, 0x0e32, 0x0e33, 0x0e34, 0x0e35, 0x0e36, 0x0e37,
- 0x0e38, 0x0e39, 0x0e3a, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0x0e3f,
- /* 0xe0 */
- 0x0e40, 0x0e41, 0x0e42, 0x0e43, 0x0e44, 0x0e45, 0x0e46, 0x0e47,
- 0x0e48, 0x0e49, 0x0e4a, 0x0e4b, 0x0e4c, 0x0e4d, 0x0e4e, 0x0e4f,
- /* 0xf0 */
- 0x0e50, 0x0e51, 0x0e52, 0x0e53, 0x0e54, 0x0e55, 0x0e56, 0x0e57,
- 0x0e58, 0x0e59, 0x0e5a, 0x0e5b, 0xfffd, 0xfffd, 0xfffd, 0xfffd,
- }
-},
-/*-- cp1133 --*/
-{
- 1133,
- {
- /* 0x80 */
- 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0,
- /* 0x90 */
- 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0,
- /* 0xa0 */
- 0x00a0, 0x0e81, 0x0e82, 0x0e84, 0x0e87, 0x0e88, 0x0eaa, 0x0e8a,
- 0x0e8d, 0x0e94, 0x0e95, 0x0e96, 0x0e97, 0x0e99, 0x0e9a, 0x0e9b,
- /* 0xb0 */
- 0x0e9c, 0x0e9d, 0x0e9e, 0x0e9f, 0x0ea1, 0x0ea2, 0x0ea3, 0x0ea5,
- 0x0ea7, 0x0eab, 0x0ead, 0x0eae, 0xfffd, 0xfffd, 0xfffd, 0x0eaf,
- /* 0xc0 */
- 0x0eb0, 0x0eb2, 0x0eb3, 0x0eb4, 0x0eb5, 0x0eb6, 0x0eb7, 0x0eb8,
- 0x0eb9, 0x0ebc, 0x0eb1, 0x0ebb, 0x0ebd, 0xfffd, 0xfffd, 0xfffd,
- /* 0xd0 */
- 0x0ec0, 0x0ec1, 0x0ec2, 0x0ec3, 0x0ec4, 0x0ec8, 0x0ec9, 0x0eca,
- 0x0ecb, 0x0ecc, 0x0ecd, 0x0ec6, 0xfffd, 0x0edc, 0x0edd, 0x20ad,
- /* 0xe0 */
- 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0,
- /* 0xf0 */
- 0x0ed0, 0x0ed1, 0x0ed2, 0x0ed3, 0x0ed4, 0x0ed5, 0x0ed6, 0x0ed7,
- 0x0ed8, 0x0ed9, 0xfffd, 0xfffd, 0x00a2, 0x00ac, 0x00a6, 0xfffd,
- }
-},
-/*-- cp1250 --*/
-{
- 1250,
{
- /* 0x80 */
- 0x20ac, 0xfffd, 0x201a, 0xfffd, 0x201e, 0x2026, 0x2020, 0x2021,
- 0xfffd, 0x2030, 0x0160, 0x2039, 0x015a, 0x0164, 0x017d, 0x0179,
- /* 0x90 */
- 0xfffd, 0x2018, 0x2019, 0x201c, 0x201d, 0x2022, 0x2013, 0x2014,
- 0xfffd, 0x2122, 0x0161, 0x203a, 0x015b, 0x0165, 0x017e, 0x017a,
- /* 0xa0 */
- 0x00a0, 0x02c7, 0x02d8, 0x0141, 0x00a4, 0x0104, 0x00a6, 0x00a7,
- 0x00a8, 0x00a9, 0x015e, 0x00ab, 0x00ac, 0x00ad, 0x00ae, 0x017b,
- /* 0xb0 */
- 0x00b0, 0x00b1, 0x02db, 0x0142, 0x00b4, 0x00b5, 0x00b6, 0x00b7,
- 0x00b8, 0x0105, 0x015f, 0x00bb, 0x013d, 0x02dd, 0x013e, 0x017c,
- /* 0xc0 */
- 0x0154, 0x00c1, 0x00c2, 0x0102, 0x00c4, 0x0139, 0x0106, 0x00c7,
- 0x010c, 0x00c9, 0x0118, 0x00cb, 0x011a, 0x00cd, 0x00ce, 0x010e,
- /* 0xd0 */
- 0x0110, 0x0143, 0x0147, 0x00d3, 0x00d4, 0x0150, 0x00d6, 0x00d7,
- 0x0158, 0x016e, 0x00da, 0x0170, 0x00dc, 0x00dd, 0x0162, 0x00df,
- /* 0xe0 */
- 0x0155, 0x00e1, 0x00e2, 0x0103, 0x00e4, 0x013a, 0x0107, 0x00e7,
- 0x010d, 0x00e9, 0x0119, 0x00eb, 0x011b, 0x00ed, 0x00ee, 0x010f,
- /* 0xf0 */
- 0x0111, 0x0144, 0x0148, 0x00f3, 0x00f4, 0x0151, 0x00f6, 0x00f7,
- 0x0159, 0x016f, 0x00fa, 0x0171, 0x00fc, 0x00fd, 0x0163, 0x02d9,
- }
-},
-/*-- cp1251 --*/
-{
- 1251,
- {
- /* 0x80 */
- 0x0402, 0x0403, 0x201a, 0x0453, 0x201e, 0x2026, 0x2020, 0x2021,
- 0x20ac, 0x2030, 0x0409, 0x2039, 0x040a, 0x040c, 0x040b, 0x040f,
- /* 0x90 */
- 0x0452, 0x2018, 0x2019, 0x201c, 0x201d, 0x2022, 0x2013, 0x2014,
- 0xfffd, 0x2122, 0x0459, 0x203a, 0x045a, 0x045c, 0x045b, 0x045f,
- /* 0xa0 */
- 0x00a0, 0x040e, 0x045e, 0x0408, 0x00a4, 0x0490, 0x00a6, 0x00a7,
- 0x0401, 0x00a9, 0x0404, 0x00ab, 0x00ac, 0x00ad, 0x00ae, 0x0407,
- /* 0xb0 */
- 0x00b0, 0x00b1, 0x0406, 0x0456, 0x0491, 0x00b5, 0x00b6, 0x00b7,
- 0x0451, 0x2116, 0x0454, 0x00bb, 0x0458, 0x0405, 0x0455, 0x0457,
- /* 0xc0 */
- 0x0410, 0x0411, 0x0412, 0x0413, 0x0414, 0x0415, 0x0416, 0x0417,
- 0x0418, 0x0419, 0x041a, 0x041b, 0x041c, 0x041d, 0x041e, 0x041f,
- /* 0xd0 */
- 0x0420, 0x0421, 0x0422, 0x0423, 0x0424, 0x0425, 0x0426, 0x0427,
- 0x0428, 0x0429, 0x042a, 0x042b, 0x042c, 0x042d, 0x042e, 0x042f,
- /* 0xe0 */
- 0x0430, 0x0431, 0x0432, 0x0433, 0x0434, 0x0435, 0x0436, 0x0437,
- 0x0438, 0x0439, 0x043a, 0x043b, 0x043c, 0x043d, 0x043e, 0x043f,
- /* 0xf0 */
- 0x0440, 0x0441, 0x0442, 0x0443, 0x0444, 0x0445, 0x0446, 0x0447,
- 0x0448, 0x0449, 0x044a, 0x044b, 0x044c, 0x044d, 0x044e, 0x044f,
- }
-},
-/*-- cp1252 --*/
-{
- 1252,
- {
- /* 0x80 */
- 0x20ac, 0xfffd, 0x201a, 0x0192, 0x201e, 0x2026, 0x2020, 0x2021,
- 0x02c6, 0x2030, 0x0160, 0x2039, 0x0152, 0xfffd, 0x017d, 0xfffd,
- /* 0x90 */
-/* daved - don't process 93 & 94 as we want entities */
- 0xfffd, 0x2018, 0x2019, 0, 0, 0x2022, 0x2013, 0x2014,
- 0x02dc, 0x2122, 0x0161, 0x203a, 0x0153, 0xfffd, 0x017e, 0x0178,
- /* 0xa0 */
- 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0,
- /* 0xb0 */
- 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0,
- /* 0xc0 */
- 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0,
- /* 0xd0 */
- 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0,
- /* 0xe0 */
- 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0,
- /* 0xf0 */
- 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0,
- }
-},
-/*-- cp1253 --*/
-{
- 1253,
- {
- /* 0x80 */
- 0x20ac, 0xfffd, 0x201a, 0x0192, 0x201e, 0x2026, 0x2020, 0x2021,
- 0xfffd, 0x2030, 0xfffd, 0x2039, 0xfffd, 0xfffd, 0xfffd, 0xfffd,
- /* 0x90 */
- 0xfffd, 0x2018, 0x2019, 0x201c, 0x201d, 0x2022, 0x2013, 0x2014,
- 0xfffd, 0x2122, 0xfffd, 0x203a, 0xfffd, 0xfffd, 0xfffd, 0xfffd,
- /* 0xa0 */
- 0x00a0, 0x0385, 0x0386, 0x00a3, 0x00a4, 0x00a5, 0x00a6, 0x00a7,
- 0x00a8, 0x00a9, 0xfffd, 0x00ab, 0x00ac, 0x00ad, 0x00ae, 0x2015,
- /* 0xb0 */
- 0x00b0, 0x00b1, 0x00b2, 0x00b3, 0x0384, 0x00b5, 0x00b6, 0x00b7,
- 0x0388, 0x0389, 0x038a, 0x00bb, 0x038c, 0x00bd, 0x038e, 0x038f,
- /* 0xc0 */
- 0x0390, 0x0391, 0x0392, 0x0393, 0x0394, 0x0395, 0x0396, 0x0397,
- 0x0398, 0x0399, 0x039a, 0x039b, 0x039c, 0x039d, 0x039e, 0x039f,
- /* 0xd0 */
- 0x03a0, 0x03a1, 0xfffd, 0x03a3, 0x03a4, 0x03a5, 0x03a6, 0x03a7,
- 0x03a8, 0x03a9, 0x03aa, 0x03ab, 0x03ac, 0x03ad, 0x03ae, 0x03af,
- /* 0xe0 */
- 0x03b0, 0x03b1, 0x03b2, 0x03b3, 0x03b4, 0x03b5, 0x03b6, 0x03b7,
- 0x03b8, 0x03b9, 0x03ba, 0x03bb, 0x03bc, 0x03bd, 0x03be, 0x03bf,
- /* 0xf0 */
- 0x03c0, 0x03c1, 0x03c2, 0x03c3, 0x03c4, 0x03c5, 0x03c6, 0x03c7,
- 0x03c8, 0x03c9, 0x03ca, 0x03cb, 0x03cc, 0x03cd, 0x03ce, 0xfffd,
- }
-},
-/*-- 1254 --*/
-{
- 1254,
- {
- /* 0x80 */
- 0x20ac, 0xfffd, 0x201a, 0x0192, 0x201e, 0x2026, 0x2020, 0x2021,
- 0x02c6, 0x2030, 0x0160, 0x2039, 0x0152, 0xfffd, 0xfffd, 0xfffd,
- /* 0x90 */
- 0xfffd, 0x2018, 0x2019, 0x201c, 0x201d, 0x2022, 0x2013, 0x2014,
- 0x02dc, 0x2122, 0x0161, 0x203a, 0x0153, 0xfffd, 0xfffd, 0x0178,
- /* 0xa0 */
- 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0,
- /* 0xb0 */
- 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0,
- /* 0xc0 */
- 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0,
- /* 0xd0 */
- 0x011e, 0x00d1, 0x00d2, 0x00d3, 0x00d4, 0x00d5, 0x00d6, 0x00d7,
- 0x00d8, 0x00d9, 0x00da, 0x00db, 0x00dc, 0x0130, 0x015e, 0x00df,
- /* 0xe0 */
- 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0,
- /* 0xf0 */
- 0x011f, 0x00f1, 0x00f2, 0x00f3, 0x00f4, 0x00f5, 0x00f6, 0x00f7,
- 0x00f8, 0x00f9, 0x00fa, 0x00fb, 0x00fc, 0x0131, 0x015f, 0x00ff,
- }
-},
-/*-- cp1255 --*/
-{
- 1255,
- {
- /* 0x80 */
- 0x20ac, 0xfffd, 0x201a, 0x0192, 0x201e, 0x2026, 0x2020, 0x2021,
- 0x02c6, 0x2030, 0xfffd, 0x2039, 0xfffd, 0xfffd, 0xfffd, 0xfffd,
- /* 0x90 */
- 0xfffd, 0x2018, 0x2019, 0x201c, 0x201d, 0x2022, 0x2013, 0x2014,
- 0x02dc, 0x2122, 0xfffd, 0x203a, 0xfffd, 0xfffd, 0xfffd, 0xfffd,
- /* 0xa0 */
- 0x00a0, 0x00a1, 0x00a2, 0x00a3, 0x20aa, 0x00a5, 0x00a6, 0x00a7,
- 0x00a8, 0x00a9, 0x00d7, 0x00ab, 0x00ac, 0x00ad, 0x00ae, 0x00af,
- /* 0xb0 */
- 0x00b0, 0x00b1, 0x00b2, 0x00b3, 0x00b4, 0x00b5, 0x00b6, 0x00b7,
- 0x00b8, 0x00b9, 0x00f7, 0x00bb, 0x00bc, 0x00bd, 0x00be, 0x00bf,
- /* 0xc0 */
- 0x05b0, 0x05b1, 0x05b2, 0x05b3, 0x05b4, 0x05b5, 0x05b6, 0x05b7,
- 0x05b8, 0x05b9, 0xfffd, 0x05bb, 0x05bc, 0x05bd, 0x05be, 0x05bf,
- /* 0xd0 */
- 0x05c0, 0x05c1, 0x05c2, 0x05c3, 0x05f0, 0x05f1, 0x05f2, 0x05f3,
- 0x05f4, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd,
- /* 0xe0 */
- 0x05d0, 0x05d1, 0x05d2, 0x05d3, 0x05d4, 0x05d5, 0x05d6, 0x05d7,
- 0x05d8, 0x05d9, 0x05da, 0x05db, 0x05dc, 0x05dd, 0x05de, 0x05df,
- /* 0xf0 */
- 0x05e0, 0x05e1, 0x05e2, 0x05e3, 0x05e4, 0x05e5, 0x05e6, 0x05e7,
- 0x05e8, 0x05e9, 0x05ea, 0xfffd, 0xfffd, 0x200e, 0x200f, 0xfffd,
- }
-},
-/*-- cp1256 --*/
-{
- 1256,
- {
- /* 0x80 */
- 0x20ac, 0x067e, 0x201a, 0x0192, 0x201e, 0x2026, 0x2020, 0x2021,
- 0x02c6, 0x2030, 0x0679, 0x2039, 0x0152, 0x0686, 0x0698, 0x0688,
- /* 0x90 */
- 0x06af, 0x2018, 0x2019, 0x201c, 0x201d, 0x2022, 0x2013, 0x2014,
- 0x06a9, 0x2122, 0x0691, 0x203a, 0x0153, 0x200c, 0x200d, 0x06ba,
- /* 0xa0 */
- 0x00a0, 0x060c, 0x00a2, 0x00a3, 0x00a4, 0x00a5, 0x00a6, 0x00a7,
- 0x00a8, 0x00a9, 0x06be, 0x00ab, 0x00ac, 0x00ad, 0x00ae, 0x00af,
- /* 0xb0 */
- 0x00b0, 0x00b1, 0x00b2, 0x00b3, 0x00b4, 0x00b5, 0x00b6, 0x00b7,
- 0x00b8, 0x00b9, 0x061b, 0x00bb, 0x00bc, 0x00bd, 0x00be, 0x061f,
- /* 0xc0 */
- 0x06c1, 0x0621, 0x0622, 0x0623, 0x0624, 0x0625, 0x0626, 0x0627,
- 0x0628, 0x0629, 0x062a, 0x062b, 0x062c, 0x062d, 0x062e, 0x062f,
- /* 0xd0 */
- 0x0630, 0x0631, 0x0632, 0x0633, 0x0634, 0x0635, 0x0636, 0x00d7,
- 0x0637, 0x0638, 0x0639, 0x063a, 0x0640, 0x0641, 0x0642, 0x0643,
- /* 0xe0 */
- 0x00e0, 0x0644, 0x00e2, 0x0645, 0x0646, 0x0647, 0x0648, 0x00e7,
- 0x00e8, 0x00e9, 0x00ea, 0x00eb, 0x0649, 0x064a, 0x00ee, 0x00ef,
- /* 0xf0 */
- 0x064b, 0x064c, 0x064d, 0x064e, 0x00f4, 0x064f, 0x0650, 0x00f7,
- 0x0651, 0x00f9, 0x0652, 0x00fb, 0x00fc, 0x200e, 0x200f, 0x06d2,
- }
-},
-{
- 1257,
- {
- /* 0x80 */
- 0x20ac, 0xfffd, 0x201a, 0xfffd, 0x201e, 0x2026, 0x2020, 0x2021,
- 0xfffd, 0x2030, 0xfffd, 0x2039, 0xfffd, 0x00a8, 0x02c7, 0x00b8,
- /* 0x90 */
- 0xfffd, 0x2018, 0x2019, 0x201c, 0x201d, 0x2022, 0x2013, 0x2014,
- 0xfffd, 0x2122, 0xfffd, 0x203a, 0xfffd, 0x00af, 0x02db, 0xfffd,
- /* 0xa0 */
- 0x00a0, 0xfffd, 0x00a2, 0x00a3, 0x00a4, 0xfffd, 0x00a6, 0x00a7,
- 0x00d8, 0x00a9, 0x0156, 0x00ab, 0x00ac, 0x00ad, 0x00ae, 0x00c6,
- /* 0xb0 */
- 0x00b0, 0x00b1, 0x00b2, 0x00b3, 0x00b4, 0x00b5, 0x00b6, 0x00b7,
- 0x00f8, 0x00b9, 0x0157, 0x00bb, 0x00bc, 0x00bd, 0x00be, 0x00e6,
- /* 0xc0 */
- 0x0104, 0x012e, 0x0100, 0x0106, 0x00c4, 0x00c5, 0x0118, 0x0112,
- 0x010c, 0x00c9, 0x0179, 0x0116, 0x0122, 0x0136, 0x012a, 0x013b,
- /* 0xd0 */
- 0x0160, 0x0143, 0x0145, 0x00d3, 0x014c, 0x00d5, 0x00d6, 0x00d7,
- 0x0172, 0x0141, 0x015a, 0x016a, 0x00dc, 0x017b, 0x017d, 0x00df,
- /* 0xe0 */
- 0x0105, 0x012f, 0x0101, 0x0107, 0x00e4, 0x00e5, 0x0119, 0x0113,
- 0x010d, 0x00e9, 0x017a, 0x0117, 0x0123, 0x0137, 0x012b, 0x013c,
- /* 0xf0 */
- 0x0161, 0x0144, 0x0146, 0x00f3, 0x014d, 0x00f5, 0x00f6, 0x00f7,
- 0x0173, 0x0142, 0x015b, 0x016b, 0x00fc, 0x017c, 0x017e, 0x02d9,
- }
-},
-{
- 1258,
- {
- /* 0x80 */
- 0x20ac, 0xfffd, 0x201a, 0x0192, 0x201e, 0x2026, 0x2020, 0x2021,
- 0x02c6, 0x2030, 0xfffd, 0x2039, 0x0152, 0xfffd, 0xfffd, 0xfffd,
- /* 0x90 */
- 0xfffd, 0x2018, 0x2019, 0x201c, 0x201d, 0x2022, 0x2013, 0x2014,
- 0x02dc, 0x2122, 0xfffd, 0x203a, 0x0153, 0xfffd, 0xfffd, 0x0178,
- /* 0xa0 */
- 0x00a0, 0x00a1, 0x00a2, 0x00a3, 0x00a4, 0x00a5, 0x00a6, 0x00a7,
- 0x00a8, 0x00a9, 0x00aa, 0x00ab, 0x00ac, 0x00ad, 0x00ae, 0x00af,
- /* 0xb0 */
- 0x00b0, 0x00b1, 0x00b2, 0x00b3, 0x00b4, 0x00b5, 0x00b6, 0x00b7,
- 0x00b8, 0x00b9, 0x00ba, 0x00bb, 0x00bc, 0x00bd, 0x00be, 0x00bf,
- /* 0xc0 */
- 0x00c0, 0x00c1, 0x00c2, 0x0102, 0x00c4, 0x00c5, 0x00c6, 0x00c7,
- 0x00c8, 0x00c9, 0x00ca, 0x00cb, 0x0300, 0x00cd, 0x00ce, 0x00cf,
- /* 0xd0 */
- 0x0110, 0x00d1, 0x0309, 0x00d3, 0x00d4, 0x01a0, 0x00d6, 0x00d7,
- 0x00d8, 0x00d9, 0x00da, 0x00db, 0x00dc, 0x01af, 0x0303, 0x00df,
- /* 0xe0 */
- 0x00e0, 0x00e1, 0x00e2, 0x0103, 0x00e4, 0x00e5, 0x00e6, 0x00e7,
- 0x00e8, 0x00e9, 0x00ea, 0x00eb, 0x0301, 0x00ed, 0x00ee, 0x00ef,
- /* 0xf0 */
- 0x0111, 0x00f1, 0x0323, 0x00f3, 0x00f4, 0x01a1, 0x00f6, 0x00f7,
- 0x00f8, 0x00f9, 0x00fa, 0x00fb, 0x00fc, 0x01b0, 0x20ab, 0x00ff,
- }
-},
-/*-- null --*/
-{
- 0,
- {
- /* 0x80 */
- 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0,
- /* 0x90 */
- 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0,
- /* 0xa0 */
- 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0,
- /* 0xb0 */
- 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0,
- /* 0xc0 */
- 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0,
- /* 0xd0 */
- 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0,
- /* 0xe0 */
- 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0,
- /* 0xf0 */
- 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0,
- }
-},
-};
-
+ /*-- cp850 --*/
+ {
+ 850,
+ {
+ /* 0x80 */
+ 0x00c7, 0x00fc, 0x00e9, 0x00e2, 0x00e4, 0x00e0, 0x00e5, 0x00e7,
+ 0x00ea, 0x00eb, 0x00e8, 0x00ef, 0x00ee, 0x00ec, 0x00c4, 0x00c5,
+ /* 0x90 */
+ 0x00c9, 0x00e6, 0x00c6, 0x00f4, 0x00f6, 0x00f2, 0x00fb, 0x00f9,
+ 0x00ff, 0x00d6, 0x00dc, 0x00f8, 0x00a3, 0x00d8, 0x00d7, 0x0192,
+ /* 0xa0 */
+ 0x00e1, 0x00ed, 0x00f3, 0x00fa, 0x00f1, 0x00d1, 0x00aa, 0x00ba,
+ 0x00bf, 0x00ae, 0x00ac, 0x00bd, 0x00bc, 0x00a1, 0x00ab, 0x00bb,
+ /* 0xb0 */
+ 0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x00c1, 0x00c2, 0x00c0,
+ 0x00a9, 0x2563, 0x2551, 0x2557, 0x255d, 0x00a2, 0x00a5, 0x2510,
+ /* 0xc0 */
+ 0x2514, 0x2534, 0x252c, 0x251c, 0x2500, 0x253c, 0x00e3, 0x00c3,
+ 0x255a, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256c, 0x00a4,
+ /* 0xd0 */
+ 0x00f0, 0x00d0, 0x00ca, 0x00cb, 0x00c8, 0x0131, 0x00cd, 0x00ce,
+ 0x00cf, 0x2518, 0x250c, 0x2588, 0x2584, 0x00a6, 0x00cc, 0x2580,
+ /* 0xe0 */
+ 0x00d3, 0x00df, 0x00d4, 0x00d2, 0x00f5, 0x00d5, 0x00b5, 0x00fe,
+ 0x00de, 0x00da, 0x00db, 0x00d9, 0x00fd, 0x00dd, 0x00af, 0x00b4,
+ /* 0xf0 */
+ 0x00ad, 0x00b1, 0x2017, 0x00be, 0x00b6, 0x00a7, 0x00f7, 0x00b8,
+ 0x00b0, 0x00a8, 0x00b7, 0x00b9, 0x00b3, 0x00b2, 0x25a0, 0x00a0,
+ }
+ },
+ /*-- cp866 --*/
+ {
+ 866,
+ {
+ /* 0x80 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ /* 0x90 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ /* 0xa0 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ /* 0xb0 */
+ 0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x2561, 0x2562, 0x2556,
+ 0x2555, 0x2563, 0x2551, 0x2557, 0x255d, 0x255c, 0x255b, 0x2510,
+ /* 0xc0 */
+ 0x2514, 0x2534, 0x252c, 0x251c, 0x2500, 0x253c, 0x255e, 0x255f,
+ 0x255a, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256c, 0x2567,
+ /* 0xd0 */
+ 0x2568, 0x2564, 0x2565, 0x2559, 0x2558, 0x2552, 0x2553, 0x256b,
+ 0x256a, 0x2518, 0x250c, 0x2588, 0x2584, 0x258c, 0x2590, 0x2580,
+ /* 0xe0 */
+ 0x0440, 0x0441, 0x0442, 0x0443, 0x0444, 0x0445, 0x0446, 0x0447,
+ 0x0448, 0x0449, 0x044a, 0x044b, 0x044c, 0x044d, 0x044e, 0x044f,
+ /* 0xf0 */
+ 0x0401, 0x0451, 0x0404, 0x0454, 0x0407, 0x0457, 0x040e, 0x045e,
+ 0x00b0, 0x2219, 0x00b7, 0x221a, 0x2116, 0x00a4, 0x25a0, 0x00a0,
+ }
+ },
+ /*-- cp874 --*/
+ {
+ 874,
+ {
+ /* 0x80 */
+ 0x20ac, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0x2026, 0xfffd, 0xfffd,
+ 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd,
+ /* 0x90 */
+ 0xfffd, 0x2018, 0x2019, 0x201c, 0x201d, 0x2022, 0x2013, 0x2014,
+ 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd,
+ /* 0xa0 */
+ 0x00a0, 0x0e01, 0x0e02, 0x0e03, 0x0e04, 0x0e05, 0x0e06, 0x0e07,
+ 0x0e08, 0x0e09, 0x0e0a, 0x0e0b, 0x0e0c, 0x0e0d, 0x0e0e, 0x0e0f,
+ /* 0xb0 */
+ 0x0e10, 0x0e11, 0x0e12, 0x0e13, 0x0e14, 0x0e15, 0x0e16, 0x0e17,
+ 0x0e18, 0x0e19, 0x0e1a, 0x0e1b, 0x0e1c, 0x0e1d, 0x0e1e, 0x0e1f,
+ /* 0xc0 */
+ 0x0e20, 0x0e21, 0x0e22, 0x0e23, 0x0e24, 0x0e25, 0x0e26, 0x0e27,
+ 0x0e28, 0x0e29, 0x0e2a, 0x0e2b, 0x0e2c, 0x0e2d, 0x0e2e, 0x0e2f,
+ /* 0xd0 */
+ 0x0e30, 0x0e31, 0x0e32, 0x0e33, 0x0e34, 0x0e35, 0x0e36, 0x0e37,
+ 0x0e38, 0x0e39, 0x0e3a, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0x0e3f,
+ /* 0xe0 */
+ 0x0e40, 0x0e41, 0x0e42, 0x0e43, 0x0e44, 0x0e45, 0x0e46, 0x0e47,
+ 0x0e48, 0x0e49, 0x0e4a, 0x0e4b, 0x0e4c, 0x0e4d, 0x0e4e, 0x0e4f,
+ /* 0xf0 */
+ 0x0e50, 0x0e51, 0x0e52, 0x0e53, 0x0e54, 0x0e55, 0x0e56, 0x0e57,
+ 0x0e58, 0x0e59, 0x0e5a, 0x0e5b, 0xfffd, 0xfffd, 0xfffd, 0xfffd,
+ }
+ },
+ /*-- cp1133 --*/
+ {
+ 1133,
+ {
+ /* 0x80 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ /* 0x90 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ /* 0xa0 */
+ 0x00a0, 0x0e81, 0x0e82, 0x0e84, 0x0e87, 0x0e88, 0x0eaa, 0x0e8a,
+ 0x0e8d, 0x0e94, 0x0e95, 0x0e96, 0x0e97, 0x0e99, 0x0e9a, 0x0e9b,
+ /* 0xb0 */
+ 0x0e9c, 0x0e9d, 0x0e9e, 0x0e9f, 0x0ea1, 0x0ea2, 0x0ea3, 0x0ea5,
+ 0x0ea7, 0x0eab, 0x0ead, 0x0eae, 0xfffd, 0xfffd, 0xfffd, 0x0eaf,
+ /* 0xc0 */
+ 0x0eb0, 0x0eb2, 0x0eb3, 0x0eb4, 0x0eb5, 0x0eb6, 0x0eb7, 0x0eb8,
+ 0x0eb9, 0x0ebc, 0x0eb1, 0x0ebb, 0x0ebd, 0xfffd, 0xfffd, 0xfffd,
+ /* 0xd0 */
+ 0x0ec0, 0x0ec1, 0x0ec2, 0x0ec3, 0x0ec4, 0x0ec8, 0x0ec9, 0x0eca,
+ 0x0ecb, 0x0ecc, 0x0ecd, 0x0ec6, 0xfffd, 0x0edc, 0x0edd, 0x20ad,
+ /* 0xe0 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ /* 0xf0 */
+ 0x0ed0, 0x0ed1, 0x0ed2, 0x0ed3, 0x0ed4, 0x0ed5, 0x0ed6, 0x0ed7,
+ 0x0ed8, 0x0ed9, 0xfffd, 0xfffd, 0x00a2, 0x00ac, 0x00a6, 0xfffd,
+ }
+ },
+ /*-- cp1250 --*/
+ {
+ 1250,
+ {
+ /* 0x80 */
+ 0x20ac, 0xfffd, 0x201a, 0xfffd, 0x201e, 0x2026, 0x2020, 0x2021,
+ 0xfffd, 0x2030, 0x0160, 0x2039, 0x015a, 0x0164, 0x017d, 0x0179,
+ /* 0x90 */
+ 0xfffd, 0x2018, 0x2019, 0x201c, 0x201d, 0x2022, 0x2013, 0x2014,
+ 0xfffd, 0x2122, 0x0161, 0x203a, 0x015b, 0x0165, 0x017e, 0x017a,
+ /* 0xa0 */
+ 0x00a0, 0x02c7, 0x02d8, 0x0141, 0x00a4, 0x0104, 0x00a6, 0x00a7,
+ 0x00a8, 0x00a9, 0x015e, 0x00ab, 0x00ac, 0x00ad, 0x00ae, 0x017b,
+ /* 0xb0 */
+ 0x00b0, 0x00b1, 0x02db, 0x0142, 0x00b4, 0x00b5, 0x00b6, 0x00b7,
+ 0x00b8, 0x0105, 0x015f, 0x00bb, 0x013d, 0x02dd, 0x013e, 0x017c,
+ /* 0xc0 */
+ 0x0154, 0x00c1, 0x00c2, 0x0102, 0x00c4, 0x0139, 0x0106, 0x00c7,
+ 0x010c, 0x00c9, 0x0118, 0x00cb, 0x011a, 0x00cd, 0x00ce, 0x010e,
+ /* 0xd0 */
+ 0x0110, 0x0143, 0x0147, 0x00d3, 0x00d4, 0x0150, 0x00d6, 0x00d7,
+ 0x0158, 0x016e, 0x00da, 0x0170, 0x00dc, 0x00dd, 0x0162, 0x00df,
+ /* 0xe0 */
+ 0x0155, 0x00e1, 0x00e2, 0x0103, 0x00e4, 0x013a, 0x0107, 0x00e7,
+ 0x010d, 0x00e9, 0x0119, 0x00eb, 0x011b, 0x00ed, 0x00ee, 0x010f,
+ /* 0xf0 */
+ 0x0111, 0x0144, 0x0148, 0x00f3, 0x00f4, 0x0151, 0x00f6, 0x00f7,
+ 0x0159, 0x016f, 0x00fa, 0x0171, 0x00fc, 0x00fd, 0x0163, 0x02d9,
+ }
+ },
+ /*-- cp1251 --*/
+ {
+ 1251,
+ {
+ /* 0x80 */
+ 0x0402, 0x0403, 0x201a, 0x0453, 0x201e, 0x2026, 0x2020, 0x2021,
+ 0x20ac, 0x2030, 0x0409, 0x2039, 0x040a, 0x040c, 0x040b, 0x040f,
+ /* 0x90 */
+ 0x0452, 0x2018, 0x2019, 0x201c, 0x201d, 0x2022, 0x2013, 0x2014,
+ 0xfffd, 0x2122, 0x0459, 0x203a, 0x045a, 0x045c, 0x045b, 0x045f,
+ /* 0xa0 */
+ 0x00a0, 0x040e, 0x045e, 0x0408, 0x00a4, 0x0490, 0x00a6, 0x00a7,
+ 0x0401, 0x00a9, 0x0404, 0x00ab, 0x00ac, 0x00ad, 0x00ae, 0x0407,
+ /* 0xb0 */
+ 0x00b0, 0x00b1, 0x0406, 0x0456, 0x0491, 0x00b5, 0x00b6, 0x00b7,
+ 0x0451, 0x2116, 0x0454, 0x00bb, 0x0458, 0x0405, 0x0455, 0x0457,
+ /* 0xc0 */
+ 0x0410, 0x0411, 0x0412, 0x0413, 0x0414, 0x0415, 0x0416, 0x0417,
+ 0x0418, 0x0419, 0x041a, 0x041b, 0x041c, 0x041d, 0x041e, 0x041f,
+ /* 0xd0 */
+ 0x0420, 0x0421, 0x0422, 0x0423, 0x0424, 0x0425, 0x0426, 0x0427,
+ 0x0428, 0x0429, 0x042a, 0x042b, 0x042c, 0x042d, 0x042e, 0x042f,
+ /* 0xe0 */
+ 0x0430, 0x0431, 0x0432, 0x0433, 0x0434, 0x0435, 0x0436, 0x0437,
+ 0x0438, 0x0439, 0x043a, 0x043b, 0x043c, 0x043d, 0x043e, 0x043f,
+ /* 0xf0 */
+ 0x0440, 0x0441, 0x0442, 0x0443, 0x0444, 0x0445, 0x0446, 0x0447,
+ 0x0448, 0x0449, 0x044a, 0x044b, 0x044c, 0x044d, 0x044e, 0x044f,
+ }
+ },
+ /*-- cp1252 --*/
+ {
+ 1252,
+ {
+ /* 0x80 */
+ 0x20ac, 0xfffd, 0x201a, 0x0192, 0x201e, 0x2026, 0x2020, 0x2021,
+ 0x02c6, 0x2030, 0x0160, 0x2039, 0x0152, 0xfffd, 0x017d, 0xfffd,
+ /* 0x90 */
+ /* daved - don't process 93 & 94 as we want entities */
+ 0xfffd, 0x2018, 0x2019, 0, 0, 0x2022, 0x2013, 0x2014,
+ 0x02dc, 0x2122, 0x0161, 0x203a, 0x0153, 0xfffd, 0x017e, 0x0178,
+ /* 0xa0 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ /* 0xb0 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ /* 0xc0 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ /* 0xd0 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ /* 0xe0 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ /* 0xf0 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ }
+ },
+ /*-- cp1253 --*/
+ {
+ 1253,
+ {
+ /* 0x80 */
+ 0x20ac, 0xfffd, 0x201a, 0x0192, 0x201e, 0x2026, 0x2020, 0x2021,
+ 0xfffd, 0x2030, 0xfffd, 0x2039, 0xfffd, 0xfffd, 0xfffd, 0xfffd,
+ /* 0x90 */
+ 0xfffd, 0x2018, 0x2019, 0x201c, 0x201d, 0x2022, 0x2013, 0x2014,
+ 0xfffd, 0x2122, 0xfffd, 0x203a, 0xfffd, 0xfffd, 0xfffd, 0xfffd,
+ /* 0xa0 */
+ 0x00a0, 0x0385, 0x0386, 0x00a3, 0x00a4, 0x00a5, 0x00a6, 0x00a7,
+ 0x00a8, 0x00a9, 0xfffd, 0x00ab, 0x00ac, 0x00ad, 0x00ae, 0x2015,
+ /* 0xb0 */
+ 0x00b0, 0x00b1, 0x00b2, 0x00b3, 0x0384, 0x00b5, 0x00b6, 0x00b7,
+ 0x0388, 0x0389, 0x038a, 0x00bb, 0x038c, 0x00bd, 0x038e, 0x038f,
+ /* 0xc0 */
+ 0x0390, 0x0391, 0x0392, 0x0393, 0x0394, 0x0395, 0x0396, 0x0397,
+ 0x0398, 0x0399, 0x039a, 0x039b, 0x039c, 0x039d, 0x039e, 0x039f,
+ /* 0xd0 */
+ 0x03a0, 0x03a1, 0xfffd, 0x03a3, 0x03a4, 0x03a5, 0x03a6, 0x03a7,
+ 0x03a8, 0x03a9, 0x03aa, 0x03ab, 0x03ac, 0x03ad, 0x03ae, 0x03af,
+ /* 0xe0 */
+ 0x03b0, 0x03b1, 0x03b2, 0x03b3, 0x03b4, 0x03b5, 0x03b6, 0x03b7,
+ 0x03b8, 0x03b9, 0x03ba, 0x03bb, 0x03bc, 0x03bd, 0x03be, 0x03bf,
+ /* 0xf0 */
+ 0x03c0, 0x03c1, 0x03c2, 0x03c3, 0x03c4, 0x03c5, 0x03c6, 0x03c7,
+ 0x03c8, 0x03c9, 0x03ca, 0x03cb, 0x03cc, 0x03cd, 0x03ce, 0xfffd,
+ }
+ },
+ /*-- 1254 --*/
+ {
+ 1254,
+ {
+ /* 0x80 */
+ 0x20ac, 0xfffd, 0x201a, 0x0192, 0x201e, 0x2026, 0x2020, 0x2021,
+ 0x02c6, 0x2030, 0x0160, 0x2039, 0x0152, 0xfffd, 0xfffd, 0xfffd,
+ /* 0x90 */
+ 0xfffd, 0x2018, 0x2019, 0x201c, 0x201d, 0x2022, 0x2013, 0x2014,
+ 0x02dc, 0x2122, 0x0161, 0x203a, 0x0153, 0xfffd, 0xfffd, 0x0178,
+ /* 0xa0 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ /* 0xb0 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ /* 0xc0 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ /* 0xd0 */
+ 0x011e, 0x00d1, 0x00d2, 0x00d3, 0x00d4, 0x00d5, 0x00d6, 0x00d7,
+ 0x00d8, 0x00d9, 0x00da, 0x00db, 0x00dc, 0x0130, 0x015e, 0x00df,
+ /* 0xe0 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ /* 0xf0 */
+ 0x011f, 0x00f1, 0x00f2, 0x00f3, 0x00f4, 0x00f5, 0x00f6, 0x00f7,
+ 0x00f8, 0x00f9, 0x00fa, 0x00fb, 0x00fc, 0x0131, 0x015f, 0x00ff,
+ }
+ },
+ /*-- cp1255 --*/
+ {
+ 1255,
+ {
+ /* 0x80 */
+ 0x20ac, 0xfffd, 0x201a, 0x0192, 0x201e, 0x2026, 0x2020, 0x2021,
+ 0x02c6, 0x2030, 0xfffd, 0x2039, 0xfffd, 0xfffd, 0xfffd, 0xfffd,
+ /* 0x90 */
+ 0xfffd, 0x2018, 0x2019, 0x201c, 0x201d, 0x2022, 0x2013, 0x2014,
+ 0x02dc, 0x2122, 0xfffd, 0x203a, 0xfffd, 0xfffd, 0xfffd, 0xfffd,
+ /* 0xa0 */
+ 0x00a0, 0x00a1, 0x00a2, 0x00a3, 0x20aa, 0x00a5, 0x00a6, 0x00a7,
+ 0x00a8, 0x00a9, 0x00d7, 0x00ab, 0x00ac, 0x00ad, 0x00ae, 0x00af,
+ /* 0xb0 */
+ 0x00b0, 0x00b1, 0x00b2, 0x00b3, 0x00b4, 0x00b5, 0x00b6, 0x00b7,
+ 0x00b8, 0x00b9, 0x00f7, 0x00bb, 0x00bc, 0x00bd, 0x00be, 0x00bf,
+ /* 0xc0 */
+ 0x05b0, 0x05b1, 0x05b2, 0x05b3, 0x05b4, 0x05b5, 0x05b6, 0x05b7,
+ 0x05b8, 0x05b9, 0xfffd, 0x05bb, 0x05bc, 0x05bd, 0x05be, 0x05bf,
+ /* 0xd0 */
+ 0x05c0, 0x05c1, 0x05c2, 0x05c3, 0x05f0, 0x05f1, 0x05f2, 0x05f3,
+ 0x05f4, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd,
+ /* 0xe0 */
+ 0x05d0, 0x05d1, 0x05d2, 0x05d3, 0x05d4, 0x05d5, 0x05d6, 0x05d7,
+ 0x05d8, 0x05d9, 0x05da, 0x05db, 0x05dc, 0x05dd, 0x05de, 0x05df,
+ /* 0xf0 */
+ 0x05e0, 0x05e1, 0x05e2, 0x05e3, 0x05e4, 0x05e5, 0x05e6, 0x05e7,
+ 0x05e8, 0x05e9, 0x05ea, 0xfffd, 0xfffd, 0x200e, 0x200f, 0xfffd,
+ }
+ },
+ /*-- cp1256 --*/
+ {
+ 1256,
+ {
+ /* 0x80 */
+ 0x20ac, 0x067e, 0x201a, 0x0192, 0x201e, 0x2026, 0x2020, 0x2021,
+ 0x02c6, 0x2030, 0x0679, 0x2039, 0x0152, 0x0686, 0x0698, 0x0688,
+ /* 0x90 */
+ 0x06af, 0x2018, 0x2019, 0x201c, 0x201d, 0x2022, 0x2013, 0x2014,
+ 0x06a9, 0x2122, 0x0691, 0x203a, 0x0153, 0x200c, 0x200d, 0x06ba,
+ /* 0xa0 */
+ 0x00a0, 0x060c, 0x00a2, 0x00a3, 0x00a4, 0x00a5, 0x00a6, 0x00a7,
+ 0x00a8, 0x00a9, 0x06be, 0x00ab, 0x00ac, 0x00ad, 0x00ae, 0x00af,
+ /* 0xb0 */
+ 0x00b0, 0x00b1, 0x00b2, 0x00b3, 0x00b4, 0x00b5, 0x00b6, 0x00b7,
+ 0x00b8, 0x00b9, 0x061b, 0x00bb, 0x00bc, 0x00bd, 0x00be, 0x061f,
+ /* 0xc0 */
+ 0x06c1, 0x0621, 0x0622, 0x0623, 0x0624, 0x0625, 0x0626, 0x0627,
+ 0x0628, 0x0629, 0x062a, 0x062b, 0x062c, 0x062d, 0x062e, 0x062f,
+ /* 0xd0 */
+ 0x0630, 0x0631, 0x0632, 0x0633, 0x0634, 0x0635, 0x0636, 0x00d7,
+ 0x0637, 0x0638, 0x0639, 0x063a, 0x0640, 0x0641, 0x0642, 0x0643,
+ /* 0xe0 */
+ 0x00e0, 0x0644, 0x00e2, 0x0645, 0x0646, 0x0647, 0x0648, 0x00e7,
+ 0x00e8, 0x00e9, 0x00ea, 0x00eb, 0x0649, 0x064a, 0x00ee, 0x00ef,
+ /* 0xf0 */
+ 0x064b, 0x064c, 0x064d, 0x064e, 0x00f4, 0x064f, 0x0650, 0x00f7,
+ 0x0651, 0x00f9, 0x0652, 0x00fb, 0x00fc, 0x200e, 0x200f, 0x06d2,
+ }
+ },
+ {
+ 1257,
+ {
+ /* 0x80 */
+ 0x20ac, 0xfffd, 0x201a, 0xfffd, 0x201e, 0x2026, 0x2020, 0x2021,
+ 0xfffd, 0x2030, 0xfffd, 0x2039, 0xfffd, 0x00a8, 0x02c7, 0x00b8,
+ /* 0x90 */
+ 0xfffd, 0x2018, 0x2019, 0x201c, 0x201d, 0x2022, 0x2013, 0x2014,
+ 0xfffd, 0x2122, 0xfffd, 0x203a, 0xfffd, 0x00af, 0x02db, 0xfffd,
+ /* 0xa0 */
+ 0x00a0, 0xfffd, 0x00a2, 0x00a3, 0x00a4, 0xfffd, 0x00a6, 0x00a7,
+ 0x00d8, 0x00a9, 0x0156, 0x00ab, 0x00ac, 0x00ad, 0x00ae, 0x00c6,
+ /* 0xb0 */
+ 0x00b0, 0x00b1, 0x00b2, 0x00b3, 0x00b4, 0x00b5, 0x00b6, 0x00b7,
+ 0x00f8, 0x00b9, 0x0157, 0x00bb, 0x00bc, 0x00bd, 0x00be, 0x00e6,
+ /* 0xc0 */
+ 0x0104, 0x012e, 0x0100, 0x0106, 0x00c4, 0x00c5, 0x0118, 0x0112,
+ 0x010c, 0x00c9, 0x0179, 0x0116, 0x0122, 0x0136, 0x012a, 0x013b,
+ /* 0xd0 */
+ 0x0160, 0x0143, 0x0145, 0x00d3, 0x014c, 0x00d5, 0x00d6, 0x00d7,
+ 0x0172, 0x0141, 0x015a, 0x016a, 0x00dc, 0x017b, 0x017d, 0x00df,
+ /* 0xe0 */
+ 0x0105, 0x012f, 0x0101, 0x0107, 0x00e4, 0x00e5, 0x0119, 0x0113,
+ 0x010d, 0x00e9, 0x017a, 0x0117, 0x0123, 0x0137, 0x012b, 0x013c,
+ /* 0xf0 */
+ 0x0161, 0x0144, 0x0146, 0x00f3, 0x014d, 0x00f5, 0x00f6, 0x00f7,
+ 0x0173, 0x0142, 0x015b, 0x016b, 0x00fc, 0x017c, 0x017e, 0x02d9,
+ }
+ },
+ {
+ 1258,
+ {
+ /* 0x80 */
+ 0x20ac, 0xfffd, 0x201a, 0x0192, 0x201e, 0x2026, 0x2020, 0x2021,
+ 0x02c6, 0x2030, 0xfffd, 0x2039, 0x0152, 0xfffd, 0xfffd, 0xfffd,
+ /* 0x90 */
+ 0xfffd, 0x2018, 0x2019, 0x201c, 0x201d, 0x2022, 0x2013, 0x2014,
+ 0x02dc, 0x2122, 0xfffd, 0x203a, 0x0153, 0xfffd, 0xfffd, 0x0178,
+ /* 0xa0 */
+ 0x00a0, 0x00a1, 0x00a2, 0x00a3, 0x00a4, 0x00a5, 0x00a6, 0x00a7,
+ 0x00a8, 0x00a9, 0x00aa, 0x00ab, 0x00ac, 0x00ad, 0x00ae, 0x00af,
+ /* 0xb0 */
+ 0x00b0, 0x00b1, 0x00b2, 0x00b3, 0x00b4, 0x00b5, 0x00b6, 0x00b7,
+ 0x00b8, 0x00b9, 0x00ba, 0x00bb, 0x00bc, 0x00bd, 0x00be, 0x00bf,
+ /* 0xc0 */
+ 0x00c0, 0x00c1, 0x00c2, 0x0102, 0x00c4, 0x00c5, 0x00c6, 0x00c7,
+ 0x00c8, 0x00c9, 0x00ca, 0x00cb, 0x0300, 0x00cd, 0x00ce, 0x00cf,
+ /* 0xd0 */
+ 0x0110, 0x00d1, 0x0309, 0x00d3, 0x00d4, 0x01a0, 0x00d6, 0x00d7,
+ 0x00d8, 0x00d9, 0x00da, 0x00db, 0x00dc, 0x01af, 0x0303, 0x00df,
+ /* 0xe0 */
+ 0x00e0, 0x00e1, 0x00e2, 0x0103, 0x00e4, 0x00e5, 0x00e6, 0x00e7,
+ 0x00e8, 0x00e9, 0x00ea, 0x00eb, 0x0301, 0x00ed, 0x00ee, 0x00ef,
+ /* 0xf0 */
+ 0x0111, 0x00f1, 0x0323, 0x00f3, 0x00f4, 0x01a1, 0x00f6, 0x00f7,
+ 0x00f8, 0x00f9, 0x00fa, 0x00fb, 0x00fc, 0x01b0, 0x20ab, 0x00ff,
+ }
+ },
+ /*-- null --*/
+ {
+ 0,
+ {
+ /* 0x80 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ /* 0x90 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ /* 0xa0 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ /* 0xb0 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ /* 0xc0 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ /* 0xd0 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ /* 0xe0 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ /* 0xf0 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ }
+ },
+ };
-extern int nopict_mode;
/*
-#define BINARY_ATTRS
+ #define BINARY_ATTRS
*/
-my_iconv_t desc = MY_ICONV_T_CLEAR, desc2 = MY_ICONV_T_CLEAR;
-
/* Nested tables aren't supported.
*/
-static int coming_pars_that_are_tabular = 0;
-static int within_table = FALSE;
-static int have_printed_row_begin=FALSE;
-static int have_printed_cell_begin=FALSE;
-static int have_printed_row_end=FALSE;
-static int have_printed_cell_end=FALSE;
-
-
-/* Previously in word_print_core function
- */
-static int total_chars_this_line=0; /* for simulating \tab */
-
/* Paragraph alignment (kludge)
*/
enum {
- ALIGN_LEFT=0,
- ALIGN_RIGHT,
- ALIGN_CENTER,
- ALIGN_JUSTIFY
+ ALIGN_LEFT=0,
+ ALIGN_RIGHT,
+ ALIGN_CENTER,
+ ALIGN_JUSTIFY
};
-
-
-/* This value is set by attr_push and attr_pop
- */
-int simulate_smallcaps;
-int simulate_allcaps;
-
-
/* Most pictures must be written to files. */
enum {
- PICT_UNKNOWN=0,
- PICT_WM,
- PICT_MAC,
- PICT_PM,
- PICT_DI,
- PICT_WB,
- PICT_JPEG,
- PICT_PNG,
+ PICT_UNKNOWN=0,
+ PICT_WM,
+ PICT_MAC,
+ PICT_PM,
+ PICT_DI,
+ PICT_WB,
+ PICT_JPEG,
+ PICT_PNG,
};
-static int within_picture=FALSE;
-static int picture_file_number=1;
-static char picture_path[255];
-static int picture_width;
-static int picture_height;
-static int picture_bits_per_pixel=1;
-static int picture_type=PICT_UNKNOWN;
-static int picture_wmetafile_type;
-static char *picture_wmetafile_type_str;
-
-
-static int have_printed_body=FALSE;
-static int within_header=TRUE;
-
-
-
-static char *hyperlink_base = NULL;
-
-
-
-void starting_body();
-void starting_text();
-void print_with_special_exprs (char *s);
-
-static int banner_printed=FALSE;
+void starting_body(const struct OutputContext *oc);
+void starting_text(const struct OutputContext *oc);
+void print_with_special_exprs (const struct OutputContext *oc, char *s);
/*========================================================================
* Name: print_banner
@@ -616,15 +576,17 @@ static int banner_printed=FALSE;
*=======================================================================*/
void
-print_banner () {
- if (!banner_printed) {
- if (safe_printf(0, op->comment_begin)) fprintf(stderr, TOO_MANY_ARGS, "comment_begin");
- printf(" Translation from RTF performed by ");
- printf("UnRTF, version ");
- printf("%s ", PACKAGE_VERSION);
- if (safe_printf(0, op->comment_end)) fprintf(stderr, TOO_MANY_ARGS, "comment_end");
- }
- banner_printed=TRUE;
+print_banner (const struct OutputContext *oc) {
+ const struct unRTFOutputDevice *device = &oc->conversion->options->device;
+
+ if (!oc->conversion->banner_printed) {
+ if (safe_printf(device, 0, oc->personality->comment_begin)) fprintf(stderr, TOO_MANY_ARGS, "comment_begin");
+ printf(" Translation from RTF performed by ");
+ printf("UnRTF, version ");
+ printf("%s ", PACKAGE_VERSION);
+ if (safe_printf(device, 0, oc->personality->comment_end)) fprintf(stderr, TOO_MANY_ARGS, "comment_end");
+ }
+ oc->conversion->banner_printed=TRUE;
}
@@ -636,16 +598,18 @@ print_banner () {
*=======================================================================*/
void
-starting_body ()
+starting_body (const struct OutputContext *oc)
{
- if (!have_printed_body) {
- if (!inline_mode) {
- if (safe_printf(0, op->header_end)) fprintf(stderr, TOO_MANY_ARGS, "header_end");
- if (safe_printf(0, op->body_begin)) fprintf(stderr, TOO_MANY_ARGS, "body_begin");
- }
- within_header = FALSE;
- have_printed_body = TRUE;
- }
+ const struct unRTFOutputDevice *device = &oc->conversion->options->device;
+
+ if (!oc->conversion->have_printed_body) {
+ if (!oc->conversion->options->inline_mode) {
+ if (safe_printf(device, 0, oc->personality->header_end)) fprintf(stderr, TOO_MANY_ARGS, "header_end");
+ if (safe_printf(device, 0, oc->personality->body_begin)) fprintf(stderr, TOO_MANY_ARGS, "body_begin");
+ }
+ oc->conversion->within_header = FALSE;
+ oc->conversion->have_printed_body = TRUE;
+ }
}
@@ -691,55 +655,44 @@ static char *month_strings[12]= {
*=======================================================================*/
void
-word_dump_date (Word *w)
+word_dump_date (const struct ConversionContext *cc, Word *w)
{
- int year=0, month=0, day=0, hour=0, minute=0;
- CHECK_PARAM_NOT_NULL(w);
- while (w) {
- char *s = word_string (w);
- if (*s == '\\') {
- ++s;
- if (!strncmp (s, "yr", 2) && isdigit(s[2])) {
- year = atoi (&s[2]);
- }
- else if (!strncmp (s, "mo", 2) && isdigit(s[2])) {
- month= atoi (&s[2]);
- }
- else if (!strncmp (s, "dy", 2) && isdigit(s[2])) {
- day= atoi (&s[2]);
- }
- else if (!strncmp (s, "min", 3) && isdigit(s[3])) {
- minute= atoi (&s[3]);
- }
- else if (!strncmp (s, "hr", 2) && isdigit(s[2])) {
- hour= atoi (&s[2]);
- }
- }
- w=w->next;
- }
- if (year && month && day) {
- printf("%d %s %d ", day, month_strings[month-1], year);
- }
- if (hour && minute) {
- printf("%02d:%02d ", hour, minute);
- }
+ int year=0, month=0, day=0, hour=0, minute=0;
+ CHECK_PARAM_NOT_NULL(w);
+ while (w) {
+ char *s = word_string (cc, w);
+ if (*s == '\\') {
+ ++s;
+ if (!strncmp (s, "yr", 2) && isdigit(s[2])) {
+ year = atoi (&s[2]);
+ }
+ else if (!strncmp (s, "mo", 2) && isdigit(s[2])) {
+ month= atoi (&s[2]);
+ }
+ else if (!strncmp (s, "dy", 2) && isdigit(s[2])) {
+ day= atoi (&s[2]);
+ }
+ else if (!strncmp (s, "min", 3) && isdigit(s[3])) {
+ minute= atoi (&s[3]);
+ }
+ else if (!strncmp (s, "hr", 2) && isdigit(s[2])) {
+ hour= atoi (&s[2]);
+ }
+ }
+ w=w->next;
+ }
+ if (year && month && day) {
+ printf("%d %s %d ", day, month_strings[month-1], year);
+ }
+ if (hour && minute) {
+ printf("%02d:%02d ", hour, minute);
+ }
}
/*-------------------------------------------------------------------*/
-typedef struct {
- int num;
- char *name;
-} FontEntry;
-
-#define MAX_FONTS (8192)
-static FontEntry font_table[MAX_FONTS];
-static int total_fonts=0;
-
-
-
/*========================================================================
* Name: lookup_fontname
* Purpose: Fetches the name of a font from the already-read font table.
@@ -748,14 +701,14 @@ static int total_fonts=0;
*=======================================================================*/
char*
-lookup_fontname (int num) {
- int i;
- if (total_fonts)
- for(i=0;i<total_fonts;i++) {
- if (font_table[i].num==num)
- return font_table[i].name;
- }
- return NULL;
+lookup_fontname (const struct ConversionContext *cc, int num) {
+ int i;
+ if (cc->total_fonts)
+ for(i=0;i<cc->total_fonts;i++) {
+ if (cc->font_table[i].num==num)
+ return cc->font_table[i].name;
+ }
+ return NULL;
}
@@ -767,73 +720,87 @@ lookup_fontname (int num) {
*=======================================================================*/
void
-process_font_table (Word *w)
+process_font_table (const struct OutputContext *oc, Word *w)
{
- Word *w2;
+ Word *w2;
+ const struct unRTFOutputDevice *device = &oc->conversion->options->device;
- CHECK_PARAM_NOT_NULL(w);
+ CHECK_PARAM_NOT_NULL(w);
- if (safe_printf(0, op->fonttable_begin)) fprintf(stderr, TOO_MANY_ARGS, "fonttable_begin");
+ if (safe_printf(device, 0, oc->personality->fonttable_begin)) fprintf(stderr, TOO_MANY_ARGS, "fonttable_begin");
- while (w) {
- int num;
- char name[BUFSIZ];
- char *tmp;
+ while (w) {
+ int num;
+ char name[BUFSIZ];
+ char *tmp;
- if ((w2 = w->child)) {
- tmp = word_string(w2);
- if (!strncmp("\\f", tmp, 2)) {
- num = atoi(&tmp[2]);
- name[0] = 0;
+ if ((w2 = w->child)) {
+ tmp = word_string (oc->conversion, w2);
+ if (!strncmp("\\f", tmp, 2)) {
+ num = atoi(&tmp[2]);
+ name[0] = 0;
- w2 = w2->next;
- while (w2) {
- tmp = word_string (w2);
- if (tmp && tmp[0] != '\\') {
- if (strlen(tmp) + strlen(name) > BUFSIZ - 1) {
- printf("Invalid font table entry\n");
- name[0] = 0;
- }
- else
- strncat(name,tmp,sizeof(name) - strlen(name) - 1);
- }
- w2 = w2->next;
- }
+ w2 = w2->next;
+ while (w2) {
+ tmp = word_string (oc->conversion, w2);
+ if (tmp && tmp[0] != '\\') {
+ if (strlen(tmp) + strlen(name) > BUFSIZ - 1) {
+ printf("Invalid font table entry\n");
+ name[0] = 0;
+ }
+ else
+ strncat(name,tmp,sizeof(name) - strlen(name) - 1);
+ }
+ w2 = w2->next;
+ }
- /* Chop the gall-derned semicolon. */
- if ((tmp = strchr(name, ';')))
- *tmp = 0;
+ /* Chop the gall-derned semicolon. */
+ if ((tmp = strchr(name, ';')))
+ *tmp = 0;
- font_table[total_fonts].num=num;
- font_table[total_fonts].name=my_strdup(name);
- if (safe_printf(0, assemble_string(op->fonttable_fontnr, num))) fprintf(stderr, TOO_MANY_ARGS, "fonttable_fontnr");
- if (safe_printf(1, op->fonttable_fontname, name)) fprintf(stderr, TOO_MANY_ARGS, "fonttable_fontname");
- total_fonts++;
- }
- }
- w=w->next;
- }
+ oc->conversion->font_table[oc->conversion->total_fonts].num=num;
+ oc->conversion->font_table[oc->conversion->total_fonts].name=unrtf_strdup(oc->conversion, name);
+ if (safe_printf(device, 0, assemble_string(oc->personality->fonttable_fontnr, num))) fprintf(stderr, TOO_MANY_ARGS, "fonttable_fontnr");
+ if (safe_printf(device, 1, oc->personality->fonttable_fontname, name)) fprintf(stderr, TOO_MANY_ARGS, "fonttable_fontname");
+ oc->conversion->total_fonts++;
+ }
+ }
+ w=w->next;
+ }
- if (safe_printf(0, op->fonttable_end)) fprintf(stderr, TOO_MANY_ARGS, "fonttable_end");
+ if (safe_printf(device, 0, oc->personality->fonttable_end)) fprintf(stderr, TOO_MANY_ARGS, "fonttable_end");
- if (safe_printf(0, op->comment_begin)) fprintf(stderr, TOO_MANY_ARGS, "comment_begin");
- printf("font table contains %d fonts total",total_fonts);
- if (safe_printf(0, op->comment_end)) fprintf(stderr, TOO_MANY_ARGS, "comment_end");
+ if (safe_printf(device, 0, oc->personality->comment_begin)) fprintf(stderr, TOO_MANY_ARGS, "comment_begin");
+ printf("font table contains %d fonts total", oc->conversion->total_fonts);
+ if (safe_printf(device, 0, oc->personality->comment_end)) fprintf(stderr, TOO_MANY_ARGS, "comment_end");
- if (debug_mode) {
- int i;
+ if (oc->conversion->options->debug_mode) {
+ int i;
- if (safe_printf(0, op->comment_begin)) fprintf(stderr, TOO_MANY_ARGS, "comment_begin");
- printf("font table dump: \n");
- for (i=0; i<total_fonts; i++) {
- printf(" font %d = %s\n", font_table[i].num,
- font_table[i].name);
- }
+ if (safe_printf(device, 0, oc->personality->comment_begin)) fprintf(stderr, TOO_MANY_ARGS, "comment_begin");
+ printf("font table dump: \n");
+ for (i=0; i< oc->conversion->total_fonts; i++) {
+ printf(" font %d = %s\n", oc->conversion->font_table[i].num,
+ oc->conversion->font_table[i].name);
+ }
- if (safe_printf(0, op->comment_end)) fprintf(stderr, TOO_MANY_ARGS, "comment_end");
- }
+ if (safe_printf(device, 0, oc->personality->comment_end)) fprintf(stderr, TOO_MANY_ARGS, "comment_end");
+ }
}
+static void
+fonttable_free(struct ConversionContext *cc)
+{
+ int i;
+
+ for (i = 0; i < cc->total_fonts; i++) {
+ if (cc->font_table[i].name) {
+ unrtf_free(cc->font_table[i].name);
+ cc->font_table[i].name = NULL;
+ }
+ }
+ cc->total_fonts = 0;
+}
/*========================================================================
* Name: process_index_entry
@@ -843,24 +810,25 @@ process_font_table (Word *w)
*=======================================================================*/
void
-process_index_entry (Word *w)
+process_index_entry (const struct OutputContext *oc, Word *w)
{
- Word *w2;
+ Word *w2;
+ const struct unRTFOutputDevice *device = &oc->conversion->options->device;
- CHECK_PARAM_NOT_NULL(w);
+ CHECK_PARAM_NOT_NULL(w);
- while(w) {
- if ((w2=w->child)) {
- char *str = word_string (w2);
+ while(w) {
+ if ((w2=w->child)) {
+ char *str = word_string (oc->conversion, w2);
- if (debug_mode && str) {
- if (safe_printf(0, op->comment_begin)) fprintf(stderr, TOO_MANY_ARGS, "comment_begin");
- printf("index entry word: %s ", str);
- if (safe_printf(0, op->comment_end)) fprintf(stderr, TOO_MANY_ARGS, "comment_end");
- }
- }
- w=w->next;
- }
+ if (oc->conversion->options->debug_mode && str) {
+ if (safe_printf(device, 0, oc->personality->comment_begin)) fprintf(stderr, TOO_MANY_ARGS, "comment_begin");
+ printf("index entry word: %s ", str);
+ if (safe_printf(device, 0, oc->personality->comment_end)) fprintf(stderr, TOO_MANY_ARGS, "comment_end");
+ }
+ }
+ w=w->next;
+ }
}
@@ -872,27 +840,28 @@ process_index_entry (Word *w)
*=======================================================================*/
void
-process_toc_entry (Word *w, int include_page_num)
+process_toc_entry (const struct OutputContext *oc, Word *w, int include_page_num)
{
- Word *w2;
+ Word *w2;
+ const struct unRTFOutputDevice *device = &oc->conversion->options->device;
- CHECK_PARAM_NOT_NULL(w);
+ CHECK_PARAM_NOT_NULL(w);
- while(w) {
- if ((w2=w->child)) {
- char *str = word_string (w2);
+ while(w) {
+ if ((w2=w->child)) {
+ char *str = word_string (oc->conversion, w2);
- if (debug_mode && str) {
+ if (oc->conversion->options->debug_mode && str) {
- if (safe_printf(0, op->comment_begin)) fprintf(stderr, TOO_MANY_ARGS, "comment_begin");
- printf("toc %s entry word: %s ",
- include_page_num ? "page#":"no page#",
- str);
- if (safe_printf(0, op->comment_end)) fprintf(stderr, TOO_MANY_ARGS, "comment_end");
- }
- }
- w=w->next;
- }
+ if (safe_printf(device, 0, oc->personality->comment_begin)) fprintf(stderr, TOO_MANY_ARGS, "comment_begin");
+ printf("toc %s entry word: %s ",
+ include_page_num ? "page#":"no page#",
+ str);
+ if (safe_printf(device, 0, oc->personality->comment_end)) fprintf(stderr, TOO_MANY_ARGS, "comment_end");
+ }
+ }
+ w=w->next;
+ }
}
@@ -904,183 +873,173 @@ process_toc_entry (Word *w, int include_
*=======================================================================*/
void
-process_info_group (Word *w)
+process_info_group (const struct OutputContext *oc, Word *w)
{
- Word *child;
+ Word *child;
+ const struct unRTFOutputDevice *device = &oc->conversion->options->device;
- /* amaral - 0.19.2 */
- /* CHECK_PARAM_NOT_NULL(w); */
- if (!w) printf("AUTHOR'S COMMENT: \\info command is null!\n");
+ /* amaral - 0.19.2 */
+ /* CHECK_PARAM_NOT_NULL(w); */
+ if (!w) printf("AUTHOR'S COMMENT: \\info command is null!\n");
- while(w) {
- child = w->child;
- if (child) {
- Word *w2;
- char *s;
+ while(w) {
+ child = w->child;
+ if (child) {
+ Word *w2;
+ char *s;
- s = word_string(child);
+ s = word_string (oc->conversion, child);
- if (!inline_mode) {
- if (!strcmp("\\title", s)) {
+ if (!oc->conversion->options->inline_mode) {
+ if (!strcmp("\\title", s)) {
- if (safe_printf(0, op->document_title_begin)) fprintf(stderr, TOO_MANY_ARGS, "document_title_begin");
- w2=child->next;
- while (w2) {
- char *s2 = word_string(w2);
- if (s2[0] != '\\')
- {
- print_with_special_exprs (s2);
- }
- else
- {
- if (s2[1] == '\'')
- {
- int ch = h2toi (&s2[2]);
+ if (safe_printf(device, 0, oc->personality->document_title_begin)) fprintf(stderr, TOO_MANY_ARGS, "document_title_begin");
+ w2=child->next;
+ while (w2) {
+ char *s2 = word_string (oc->conversion, w2);
+ if (s2[0] != '\\')
+ {
+ print_with_special_exprs (oc, s2);
+ }
+ else
+ {
+ if (s2[1] == '\'')
+ {
+ int ch = h2toi (&s2[2]);
- char *s3;
- s3 = op_translate_char (op, desc, ch);
- if (!s3 || !*s3)
- {
- if (safe_printf(0, op->comment_begin))
- fprintf(stderr, TOO_MANY_ARGS, "comment_begin");
- printf("char 0x%02x",ch);
- if (safe_printf(0, op->comment_end))
- fprintf(stderr, TOO_MANY_ARGS, "comment_begin");
- }
- else
- {
- if (op->word_begin)
- if (safe_printf(0, op->word_begin))
- fprintf(stderr, TOO_MANY_ARGS, "word_begin");
- printf("%s", s3);
- if (op->word_end)
- if (safe_printf(0, op->word_end))
- fprintf(stderr, TOO_MANY_ARGS, "word_end");
- }
- }
- }
+ char *s3;
+ s3 = op_translate_char (oc->conversion, oc->personality, ch);
+ if (!s3 || !*s3)
+ {
+ if (safe_printf(device, 0, oc->personality->comment_begin))
+ fprintf(stderr, TOO_MANY_ARGS, "comment_begin");
+ printf("char 0x%02x",ch);
+ if (safe_printf(device, 0, oc->personality->comment_end))
+ fprintf(stderr, TOO_MANY_ARGS, "comment_begin");
+ }
+ else
+ {
+ if (oc->personality->word_begin)
+ if (safe_printf(device, 0, oc->personality->word_begin))
+ fprintf(stderr, TOO_MANY_ARGS, "word_begin");
+ printf("%s", s3);
+ if (oc->personality->word_end)
+ if (safe_printf(device, 0, oc->personality->word_end))
+ fprintf(stderr, TOO_MANY_ARGS, "word_end");
+ }
+ }
+ }
- w2 = w2->next;
- }
- if (safe_printf(0, op->document_title_end)) fprintf(stderr, TOO_MANY_ARGS, "document_title_end");
- }
- else if (!strcmp("\\keywords", s)) {
- if (safe_printf(0, op->document_keywords_begin)) fprintf(stderr, TOO_MANY_ARGS, "document_keywords_begin");
- w2=child->next;
- while (w2) {
- char *s2 = word_string(w2);
- if (s2[0] != '\\')
- printf("%s,", s2);
- w2 = w2->next;
- }
- if (safe_printf(0, op->document_keywords_end)) fprintf(stderr, TOO_MANY_ARGS, "document_keywords_end");
- }
- else if (!strcmp("\\author", s)) {
- if (safe_printf(0, op->document_author_begin)) fprintf(stderr, TOO_MANY_ARGS, "document_author_begin");
- w2=child->next;
- while (w2) {
- char *s2 = word_string(w2);
- if (s2[0] != '\\')
- printf("%s", s2);
- w2 = w2->next;
- }
- if (safe_printf(0, op->document_author_end)) fprintf(stderr, TOO_MANY_ARGS, "document_author_end");
- }
- else if (!strcmp("\\comment", s)) {
- if (safe_printf(0, op->comment_begin)) fprintf(stderr, TOO_MANY_ARGS, "comment_begin");
- printf("comments: ");
- w2=child->next;
- while (w2) {
- char *s2 = word_string(w2);
- if (s2[0] != '\\')
- printf("%s", s2);
- w2 = w2->next;
- }
- if (safe_printf(0, op->comment_end)) fprintf(stderr, TOO_MANY_ARGS, "comment_end");
- }
- else if (!strncmp("\\nofpages", s, 9)) {
- if (safe_printf(0, op->comment_begin)) fprintf(stderr, TOO_MANY_ARGS, "comment_begin");
- printf("total pages: %s",&s[9]);
- if (safe_printf(0, op->comment_end)) fprintf(stderr, TOO_MANY_ARGS, "comment_end");
- }
- else if (!strncmp("\\nofwords", s, 9)) {
- if (safe_printf(0, op->comment_begin)) fprintf(stderr, TOO_MANY_ARGS, "comment_begin");
- printf("total words: %s",&s[9]);
- if (safe_printf(0, op->comment_end)) fprintf(stderr, TOO_MANY_ARGS, "comment_end");
- }
- else if (!strncmp("\\nofchars", s, 9) && isdigit(s[9])) {
- if (safe_printf(0, op->comment_begin)) fprintf(stderr, TOO_MANY_ARGS, "comment_begin");
- printf("total chars: %s",&s[9]);
- if (safe_printf(0, op->comment_end)) fprintf(stderr, TOO_MANY_ARGS, "comment_end");
- }
- else if (!strcmp("\\creatim", s)) {
- if (safe_printf(0, op->comment_begin)) fprintf(stderr, TOO_MANY_ARGS, "comment_begin");
- printf("creation date: ");
- if (child->next) word_dump_date (child->next);
- if (safe_printf(0, op->comment_end)) fprintf(stderr, TOO_MANY_ARGS, "comment_end");
- }
- else if (!strcmp("\\printim", s)) {
- if (safe_printf(0, op->comment_begin)) fprintf(stderr, TOO_MANY_ARGS, "comment_begin");
- printf("last printed: ");
- if (child->next) word_dump_date (child->next);
- if (safe_printf(0, op->comment_end)) fprintf(stderr, TOO_MANY_ARGS, "comment_end");
- }
- else if (!strcmp("\\buptim", s)) {
- if (safe_printf(0, op->comment_begin)) fprintf(stderr, TOO_MANY_ARGS, "comment_begin");
- printf("last backup: ");
- if (child->next) word_dump_date (child->next);
- if (safe_printf(0, op->comment_end)) fprintf(stderr, TOO_MANY_ARGS, "comment_end");
- }
- else if (!strcmp("\\revtim", s)) {
- if (safe_printf(0, op->comment_begin)) fprintf(stderr, TOO_MANY_ARGS, "comment_begin");
- printf("revision date: ");
- if (child->next) word_dump_date (child->next);
- if (safe_printf(0, op->comment_end)) fprintf(stderr, TOO_MANY_ARGS, "comment_end");
- }
- }
+ w2 = w2->next;
+ }
+ if (safe_printf(device, 0, oc->personality->document_title_end)) fprintf(stderr, TOO_MANY_ARGS, "document_title_end");
+ }
+ else if (!strcmp("\\keywords", s)) {
+ if (safe_printf(device, 0, oc->personality->document_keywords_begin)) fprintf(stderr, TOO_MANY_ARGS, "document_keywords_begin");
+ w2=child->next;
+ while (w2) {
+ char *s2 = word_string (oc->conversion, w2);
+ if (s2[0] != '\\')
+ printf("%s,", s2);
+ w2 = w2->next;
+ }
+ if (safe_printf(device, 0, oc->personality->document_keywords_end)) fprintf(stderr, TOO_MANY_ARGS, "document_keywords_end");
+ }
+ else if (!strcmp("\\author", s)) {
+ if (safe_printf(device, 0, oc->personality->document_author_begin)) fprintf(stderr, TOO_MANY_ARGS, "document_author_begin");
+ w2=child->next;
+ while (w2) {
+ char *s2 = word_string (oc->conversion, w2);
+ if (s2[0] != '\\')
+ printf("%s", s2);
+ w2 = w2->next;
+ }
+ if (safe_printf(device, 0, oc->personality->document_author_end)) fprintf(stderr, TOO_MANY_ARGS, "document_author_end");
+ }
+ else if (!strcmp("\\comment", s)) {
+ if (safe_printf(device, 0, oc->personality->comment_begin)) fprintf(stderr, TOO_MANY_ARGS, "comment_begin");
+ printf("comments: ");
+ w2=child->next;
+ while (w2) {
+ char *s2 = word_string (oc->conversion, w2);
+ if (s2[0] != '\\')
+ printf("%s", s2);
+ w2 = w2->next;
+ }
+ if (safe_printf(device, 0, oc->personality->comment_end)) fprintf(stderr, TOO_MANY_ARGS, "comment_end");
+ }
+ else if (!strncmp("\\nofpages", s, 9)) {
+ if (safe_printf(device, 0, oc->personality->comment_begin)) fprintf(stderr, TOO_MANY_ARGS, "comment_begin");
+ printf("total pages: %s",&s[9]);
+ if (safe_printf(device, 0, oc->personality->comment_end)) fprintf(stderr, TOO_MANY_ARGS, "comment_end");
+ }
+ else if (!strncmp("\\nofwords", s, 9)) {
+ if (safe_printf(device, 0, oc->personality->comment_begin)) fprintf(stderr, TOO_MANY_ARGS, "comment_begin");
+ printf("total words: %s",&s[9]);
+ if (safe_printf(device, 0, oc->personality->comment_end)) fprintf(stderr, TOO_MANY_ARGS, "comment_end");
+ }
+ else if (!strncmp("\\nofchars", s, 9) && isdigit(s[9])) {
+ if (safe_printf(device, 0, oc->personality->comment_begin)) fprintf(stderr, TOO_MANY_ARGS, "comment_begin");
+ printf("total chars: %s",&s[9]);
+ if (safe_printf(device, 0, oc->personality->comment_end)) fprintf(stderr, TOO_MANY_ARGS, "comment_end");
+ }
+ else if (!strcmp("\\creatim", s)) {
+ if (safe_printf(device, 0, oc->personality->comment_begin)) fprintf(stderr, TOO_MANY_ARGS, "comment_begin");
+ printf("creation date: ");
+ if (child->next) word_dump_date (oc->conversion, child->next);
+ if (safe_printf(device, 0, oc->personality->comment_end)) fprintf(stderr, TOO_MANY_ARGS, "comment_end");
+ }
+ else if (!strcmp("\\printim", s)) {
+ if (safe_printf(device, 0, oc->personality->comment_begin)) fprintf(stderr, TOO_MANY_ARGS, "comment_begin");
+ printf("last printed: ");
+ if (child->next) word_dump_date (oc->conversion, child->next);
+ if (safe_printf(device, 0, oc->personality->comment_end)) fprintf(stderr, TOO_MANY_ARGS, "comment_end");
+ }
+ else if (!strcmp("\\buptim", s)) {
+ if (safe_printf(device, 0, oc->personality->comment_begin)) fprintf(stderr, TOO_MANY_ARGS, "comment_begin");
+ printf("last backup: ");
+ if (child->next) word_dump_date (oc->conversion, child->next);
+ if (safe_printf(device, 0, oc->personality->comment_end)) fprintf(stderr, TOO_MANY_ARGS, "comment_end");
+ }
+ else if (!strcmp("\\revtim", s)) {
+ if (safe_printf(device, 0, oc->personality->comment_begin)) fprintf(stderr, TOO_MANY_ARGS, "comment_begin");
+ printf("revision date: ");
+ if (child->next) word_dump_date (oc->conversion, child->next);
+ if (safe_printf(device, 0, oc->personality->comment_end)) fprintf(stderr, TOO_MANY_ARGS, "comment_end");
+ }
+ }
- /* Irregardless of whether we're in inline mode,
- * we want to process the following.
- */
- if (!strcmp("\\hlinkbase", s)) {
- char *linkstr = NULL;
+ /* Irregardless of whether we're in inline mode,
+ * we want to process the following.
+ */
+ if (!strcmp("\\hlinkbase", s)) {
+ char *linkstr = NULL;
- if (safe_printf(0, op->comment_begin)) fprintf(stderr, TOO_MANY_ARGS, "comment_begin");
- printf("hyperlink base: ");
- if (child->next) {
- Word *nextword = child->next;
+ if (safe_printf(device, 0, oc->personality->comment_begin)) fprintf(stderr, TOO_MANY_ARGS, "comment_begin");
+ printf("hyperlink base: ");
+ if (child->next) {
+ Word *nextword = child->next;
- if (nextword)
- linkstr=word_string (nextword);
- }
+ if (nextword)
+ linkstr=word_string (oc->conversion, nextword);
+ }
- if (linkstr)
- printf("%s", linkstr);
- else
- printf("(none)");
- if (safe_printf(0, op->comment_end)) fprintf(stderr, TOO_MANY_ARGS, "comment_end");
+ if (linkstr)
+ printf("%s", linkstr);
+ else
+ printf("(none)");
+ if (safe_printf(device, 0, oc->personality->comment_end)) fprintf(stderr, TOO_MANY_ARGS, "comment_end");
- /* Store the pointer, it will remain good. */
- hyperlink_base = linkstr;
- }
- }
- w = w->next;
- }
+ /* Store the pointer, it will remain good. */
+ oc->conversion->hyperlink_base = linkstr;
+ }
+ }
+ w = w->next;
+ }
}
/*-------------------------------------------------------------------*/
-/* RTF color table colors are RGB */
-
-typedef struct {
- unsigned char r,g,b;
-} Color;
-
-#define MAX_COLORS (1024)
-static Color color_table[MAX_COLORS];
-static int total_colors=0;
-
-
/*========================================================================
* Name: process_color_table
* Purpose: Processes the color table of an RTF file.
@@ -1089,59 +1048,60 @@ static int total_colors=0;
*=======================================================================*/
void
-process_color_table (Word *w)
+process_color_table (const struct OutputContext *oc, Word *w)
{
- int r,g,b;
+ int r,g,b;
+ const struct unRTFOutputDevice *device = &oc->conversion->options->device;
- CHECK_PARAM_NOT_NULL(w);
+ CHECK_PARAM_NOT_NULL(w);
- /* Sometimes, RTF color tables begin with a semicolon,
- * i.e. an empty color entry. This seems to indicate that color 0
- * will not be used, so here I set it to black.
- */
- r=g=b=0;
+ /* Sometimes, RTF color tables begin with a semicolon,
+ * i.e. an empty color entry. This seems to indicate that color 0
+ * will not be used, so here I set it to black.
+ */
+ r=g=b=0;
- while(w) {
- char *s = word_string (w);
+ while(w) {
+ char *s = word_string (oc->conversion, w);
- if (!strncmp("\\red",s,4)) {
- r = atoi(&s[4]);
- while(r>255) r>>=8;
- }
- else if (!strncmp("\\green",s,6)) {
- g = atoi(&s[6]);
- while(g>255) g>>=8;
- }
- else if (!strncmp("\\blue",s,5)) {
- b = atoi(&s[5]);
- while(b>255) b>>=8;
- }
- else
- /* If we find the semicolon which denotes the end of
- * a color entry then store the color, even if we don't
- * have all of it.
- */
- if (!strcmp (";", s)) {
- color_table[total_colors].r = r;
- color_table[total_colors].g = g;
- color_table[total_colors++].b = b;
- if (debug_mode) {
- if (safe_printf(0, op->comment_begin)) fprintf(stderr, TOO_MANY_ARGS, "comment_begin");
- printf("storing color entry %d: %02x%02x%02x",
- total_colors-1, r,g,b);
- if (safe_printf(0, op->comment_end)) fprintf(stderr, TOO_MANY_ARGS, "comment_end");
- }
- r=g=b=0;
- }
+ if (!strncmp("\\red",s,4)) {
+ r = atoi(&s[4]);
+ while(r>255) r>>=8;
+ }
+ else if (!strncmp("\\green",s,6)) {
+ g = atoi(&s[6]);
+ while(g>255) g>>=8;
+ }
+ else if (!strncmp("\\blue",s,5)) {
+ b = atoi(&s[5]);
+ while(b>255) b>>=8;
+ }
+ else
+ /* If we find the semicolon which denotes the end of
+ * a color entry then store the color, even if we don't
+ * have all of it.
+ */
+ if (!strcmp (";", s)) {
+ oc->conversion->color_table[oc->conversion->total_colors].r = r;
+ oc->conversion->color_table[oc->conversion->total_colors].g = g;
+ oc->conversion->color_table[oc->conversion->total_colors++].b = b;
+ if (oc->conversion->options->debug_mode) {
+ if (safe_printf(device, 0, oc->personality->comment_begin)) fprintf(stderr, TOO_MANY_ARGS, "comment_begin");
+ printf("storing color entry %d: %02x%02x%02x",
+ oc->conversion->total_colors-1, r,g,b);
+ if (safe_printf(device, 0, oc->personality->comment_end)) fprintf(stderr, TOO_MANY_ARGS, "comment_end");
+ }
+ r=g=b=0;
+ }
- w=w->next;
- }
+ w=w->next;
+ }
- if (debug_mode) {
- if (safe_printf(0, op->comment_begin)) fprintf(stderr, TOO_MANY_ARGS, "comment_begin");
- printf("color table had %d entries -->\n", total_colors);
- if (safe_printf(0, op->comment_end)) fprintf(stderr, TOO_MANY_ARGS, "comment_end");
- }
+ if (oc->conversion->options->debug_mode) {
+ if (safe_printf(device, 0, oc->personality->comment_begin)) fprintf(stderr, TOO_MANY_ARGS, "comment_begin");
+ printf("color table had %d entries -->\n", oc->conversion->total_colors);
+ if (safe_printf(device, 0, oc->personality->comment_end)) fprintf(stderr, TOO_MANY_ARGS, "comment_end");
+ }
}
/*========================================================================
@@ -1152,21 +1112,21 @@ process_color_table (Word *w)
*=======================================================================*/
static int
-cmd_cf (Word *w, int align, char has_param, int num) {
- char str[40];
+cmd_cf (const struct OutputContext *oc, Word *w, int align, char has_param, int num) {
+ char str[40];
- if (!has_param || num>=total_colors) {
- warning_handler ("font color change attempted is invalid");
- }
- else
- {
- sprintf(str,"#%02x%02x%02x",
- color_table[num].r,
- color_table[num].g,
- color_table[num].b);
- attr_push(ATTR_FOREGROUND,str);
- }
- return FALSE;
+ if (!has_param || num>=oc->conversion->total_colors) {
+ warning_handler ("font color change attempted is invalid");
+ }
+ else
+ {
+ sprintf(str,"#%02x%02x%02x",
+ oc->conversion->color_table[num].r,
+ oc->conversion->color_table[num].g,
+ oc->conversion->color_table[num].b);
+ attr_push(ATTR_FOREGROUND,str, oc);
+ }
+ return FALSE;
}
@@ -1179,21 +1139,21 @@ cmd_cf (Word *w, int align, char has_par
*=======================================================================*/
static int
-cmd_cb (Word *w, int align, char has_param, int num) {
- char str[40];
+cmd_cb (const struct OutputContext *oc, Word *w, int align, char has_param, int num) {
+ char str[40];
- if (!has_param || num>=total_colors) {
- warning_handler ("font color change attempted is invalid");
- }
- else
- {
- sprintf(str,"#%02x%02x%02x",
- color_table[num].r,
- color_table[num].g,
- color_table[num].b);
- attr_push(ATTR_BACKGROUND,str);
- }
- return FALSE;
+ if (!has_param || num>=oc->conversion->total_colors) {
+ warning_handler ("font color change attempted is invalid");
+ }
+ else
+ {
+ sprintf(str,"#%02x%02x%02x",
+ oc->conversion->color_table[num].r,
+ oc->conversion->color_table[num].g,
+ oc->conversion->color_table[num].b);
+ attr_push(ATTR_BACKGROUND,str, oc);
+ }
+ return FALSE;
}
@@ -1204,18 +1164,18 @@ cmd_cb (Word *w, int align, char has_par
* Returns: Flag, true only if rest of Words on line should be ignored.
*=======================================================================*/
static int
-cmd_fs (Word *w, int align, char has_param, int points) {
- char str[20];
+cmd_fs (const struct OutputContext *oc, Word *w, int align, char has_param, int points) {
+ char str[20];
- if (!has_param) return FALSE;
+ if (!has_param) return FALSE;
- /* Note, fs20 means 10pt */
- points /= 2;
+ /* Note, fs20 means 10pt */
+ points /= 2;
- sprintf(str,"%d",points);
- attr_push(ATTR_FONTSIZE,str);
+ sprintf(str,"%d",points);
+ attr_push(ATTR_FONTSIZE,str, oc);
- return FALSE;
+ return FALSE;
}
@@ -1229,95 +1189,99 @@ cmd_fs (Word *w, int align, char has_par
*=======================================================================*/
static int
-cmd_field (Word *w, int align, char has_param, int num) {
- Word *child;
+cmd_field (const struct OutputContext *oc, Word *w, int align, char has_param, int num) {
+ Word *child;
+ const struct unRTFOutputDevice *device = &oc->conversion->options->device;
- CHECK_PARAM_NOT_NULL(w);
+ CHECK_PARAM_NOT_NULL(w);
- while(w) {
- child = w->child;
- if (child) {
- Word *w2;
- char *s;
+ while(w) {
+ child = w->child;
+ if (child) {
+ Word *w2;
+ char *s;
- s = word_string(child);
+ s = word_string (oc->conversion, child);
#if 1 /* daved experimenting with fldrslt */
- if(!strcmp("\\fldrslt", s))
- return FALSE;
+ if(!strcmp("\\fldrslt", s))
+ return FALSE;
#endif
- if (!strcmp("\\*", s))
- {
- w2=child->next;
- while (w2)
- {
- char *s2 = word_string(w2);
- if (s2 && !strcmp("\\fldinst", s2))
- {
- Word *w3;
- char *s;
- char *s4;
- Word *w4;
- w3=w2->next;
- s = word_string(w3);
- if (s && !strcmp(s, "SYMBOL") )
- {
- w4=w3->next;
- while(w4 && !strcmp(word_string(w4), " "))
- w4 = w4->next;
- s4 = word_string(w4);
- if (s4)
- {
- int char_num;
- char *string;
- my_iconv_t d;
- char_num = atoi(s4);
+ if (!strcmp("\\*", s))
+ {
+ w2=child->next;
+ while (w2)
+ {
+ char *s2 = word_string (oc->conversion, w2);
+ if (s2 && !strcmp("\\fldinst", s2))
+ {
+ Word *w3;
+ char *s;
+ char *s4;
+ Word *w4;
+ w3=w2->next;
+ s = word_string (oc->conversion, w3);
+ if (s && !strcmp(s, "SYMBOL") )
+ {
+ w4=w3->next;
+ while(w4 && !strcmp(word_string (oc->conversion, w4), " "))
+ w4 = w4->next;
+ s4 = word_string (oc->conversion, w4);
+ if (s4)
+ {
+ int char_num;
+ char *string;
+ my_iconv_t d, olddesc;
+ char_num = atoi(s4);
- if (my_iconv_is_valid((d = my_iconv_open("utf8", FONT_SYMBOL))))
- {
- string = op_translate_char (op, d, char_num);
- if (string != NULL)
- printf("%s", string);
- my_iconv_close(d);
- }
- else
- fprintf(stderr, "unrtf: Error in translation SYMBOL character\n");
- }
- }
- while (w3 && !w3->child) {
- w3=w3->next;
- }
- if (w3) w3=w3->child;
- while (w3)
- {
- char *s3=word_string(w3);
- if (s3 && !strcmp("HYPERLINK",s3)) {
- Word *w4;
- char *s4;
- w4=w3->next;
- while (w4 && !strcmp(" ", word_string(w4)))
- w4=w4->next;
- if (w4) {
- s4=word_string(w4);
- if (safe_printf(0, op->hyperlink_begin)) fprintf(stderr, TOO_MANY_ARGS, "hyperlink_begin");
- printf("%s", s4);
- if (safe_printf(0, op->hyperlink_end)) fprintf(stderr, TOO_MANY_ARGS, "hyperlink_end");
- return TRUE;
- }
+ if (my_iconv_is_valid((d = my_iconv_open(oc->conversion, "utf8", FONT_SYMBOL))))
+ {
+ olddesc = oc->conversion->desc;
+ oc->conversion->desc = d;
+ string = op_translate_char (oc->conversion, oc->personality/* , d */, char_num);
+ if (string != NULL)
+ printf("%s", string);
+ my_iconv_close(d);
+ oc->conversion->desc = olddesc;
+ }
+ else
+ fprintf(stderr, "unrtf: Error in translation SYMBOL character\n");
+ }
+ }
+ while (w3 && !w3->child) {
+ w3=w3->next;
+ }
+ if (w3) w3=w3->child;
+ while (w3)
+ {
+ char *s3=word_string (oc->conversion, w3);
+ if (s3 && !strcmp("HYPERLINK",s3)) {
+ Word *w4;
+ char *s4;
+ w4=w3->next;
+ while (w4 && !strcmp(" ", word_string (oc->conversion, w4)))
+ w4=w4->next;
+ if (w4) {
+ s4=word_string (oc->conversion, w4);
+ if (safe_printf(device, 0, oc->personality->hyperlink_begin)) fprintf(stderr, TOO_MANY_ARGS, "hyperlink_begin");
+ printf("%s", s4);
+ if (safe_printf(device, 0, oc->personality->hyperlink_end)) fprintf(stderr, TOO_MANY_ARGS, "hyperlink_end");
+ return TRUE;
+ }
- }
- w3=w3->next;
- }
- }
- w2 = w2->next;
- }
+ }
+ w3=w3->next;
+ }
+ }
+ w2 = w2->next;
+ }
- }
- }
- w=w->next;
- }
- return TRUE;
+ }
+ }
+ w=w->next;
+ }
+ return TRUE;
}
/*========================================================================
@@ -1327,59 +1291,60 @@ cmd_field (Word *w, int align, char has_
* Returns: Flag, true only if rest of Words on line should be ignored.
*=======================================================================*/
static int
-cmd_f (Word *w, int align, char has_param, int num) {
- char *name;
+cmd_f (const struct OutputContext *oc, Word *w, int align, char has_param, int num) {
+ char *name;
+ const struct unRTFOutputDevice *device = &oc->conversion->options->device;
- /* no param exit early XX */
- if (!has_param)
- return FALSE;
+ /* no param exit early XX */
+ if (!has_param)
+ return FALSE;
- name = lookup_fontname(num);
- if (!name) {
- if (safe_printf(0, op->comment_begin)) fprintf(stderr, TOO_MANY_ARGS, "comment_begin");
- printf("invalid font number %d",num);
- if (safe_printf(0, op->comment_end)) fprintf(stderr, TOO_MANY_ARGS, "comment_end");
- } else {
- if (op->fonttable_begin != NULL)
- {
- name = my_malloc(12);
- sprintf(name, "%d", num);
- }
+ name = lookup_fontname(oc->conversion, num);
+ if (!name) {
+ if (safe_printf(device, 0, oc->personality->comment_begin)) fprintf(stderr, TOO_MANY_ARGS, "comment_begin");
+ printf("invalid font number %d",num);
+ if (safe_printf(device, 0, oc->personality->comment_end)) fprintf(stderr, TOO_MANY_ARGS, "comment_end");
+ } else {
+ if (oc->personality->fonttable_begin != NULL)
+ {
+ name = unrtf_malloc(12);
+ sprintf(name, "%d", num);
+ }
#if 1 /* daved 0.21.1 */
- /* we are going to output entities, so should not output font */
- if(strstr(name,"Symbol") == NULL)
+ /* we are going to output entities, so should not output font */
+ if(strstr(name,"Symbol") == NULL)
#endif
- attr_push(ATTR_FONTFACE,name);
- if (strstr(name,"Symbol") != NULL)
- {
- if (!my_iconv_is_valid(desc2))
- desc2 = desc;
- else
- my_iconv_close(desc);
+ attr_push(ATTR_FONTFACE,name, oc);
+ if (strstr(name,"Symbol") != NULL)
+ {
+ if (!my_iconv_is_valid(oc->conversion->desc2))
+ oc->conversion->desc2 = oc->conversion->desc;
+ else
+ my_iconv_close(oc->conversion->desc);
- desc = my_iconv_open("UTF-8", FONT_SYMBOL);
- }
- else if (strstr(name,"Greek") != NULL)
- {
- if (!my_iconv_is_valid(desc2))
- desc2 = desc;
- else
- my_iconv_close(desc);
+ oc->conversion->desc = my_iconv_open(oc->conversion, "UTF-8", FONT_SYMBOL);
+ }
+ else if (strstr(name,"Greek") != NULL)
+ {
+ if (!my_iconv_is_valid(oc->conversion->desc2))
+ oc->conversion->desc2 = oc->conversion->desc;
+ else
+ my_iconv_close(oc->conversion->desc);
- desc = my_iconv_open("UTF-8", FONT_GREEK);
- }
- else
- {
- if (my_iconv_is_valid(desc2))
- {
- desc = my_iconv_close(desc);
- desc = desc2;
- my_iconv_t_make_invalid(&desc2);
- }
- }
- }
+ oc->conversion->desc = my_iconv_open(oc->conversion, "UTF-8", FONT_GREEK);
+ }
+ else
+ {
+ if (my_iconv_is_valid(oc->conversion->desc2))
+ {
+ oc->conversion->desc = my_iconv_close(oc->conversion->desc);
+ oc->conversion->desc = oc->conversion->desc2;
+ my_iconv_t_make_invalid(&oc->conversion->desc2);
+ }
+ }
+ }
- return FALSE;
+ return FALSE;
}
@@ -1391,22 +1356,22 @@ cmd_f (Word *w, int align, char has_para
*=======================================================================*/
static int
-cmd_highlight (Word *w, int align, char has_param, int num)
+cmd_highlight (const struct OutputContext *oc, Word *w, int align, char has_param, int num)
{
- char str[40];
+ char str[40];
- if (!has_param || num>=total_colors) {
- warning_handler ("font background color change attempted is invalid");
- }
- else
- {
- sprintf(str,"#%02x%02x%02x",
- color_table[num].r,
- color_table[num].g,
- color_table[num].b);
- attr_push(ATTR_BACKGROUND,str);
- }
- return FALSE;
+ if (!has_param || num>=oc->conversion->total_colors) {
+ warning_handler ("font background color change attempted is invalid");
+ }
+ else
+ {
+ sprintf(str,"#%02x%02x%02x",
+ oc->conversion->color_table[num].r,
+ oc->conversion->color_table[num].g,
+ oc->conversion->color_table[num].b);
+ attr_push(ATTR_BACKGROUND,str, oc);
+ }
+ return FALSE;
}
@@ -1419,22 +1384,24 @@ cmd_highlight (Word *w, int align, char
*=======================================================================*/
static int
-cmd_tab (Word *w, int align, char has_param, int param)
+cmd_tab (const struct OutputContext *oc, Word *w, int align, char has_param, int param)
{
- /* Tab presents a genuine problem
- * since some output formats don't have
- * an equivalent. As a kludge fix, I shall
- * assume the font is fixed width and that
- * the tabstops are 8 characters apart.
- */
- int need= 8-(total_chars_this_line%8);
- total_chars_this_line += need;
- while(need>0) {
- if (safe_printf(0, op->forced_space)) fprintf(stderr, TOO_MANY_ARGS, "forced_space");
- need--;
- }
- printf("\n");
- return FALSE;
+ /* Tab presents a genuine problem
+ * since some output formats don't have
+ * an equivalent. As a kludge fix, I shall
+ * assume the font is fixed width and that
+ * the tabstops are 8 characters apart.
+ */
+ int need= 8-(oc->conversion->total_chars_this_line%8);
+ const struct unRTFOutputDevice *device = &oc->conversion->options->device;
+
+ oc->conversion->total_chars_this_line += need;
+ while(need>0) {
+ if (safe_printf(device, 0, oc->personality->forced_space)) fprintf(stderr, TOO_MANY_ARGS, "forced_space");
+ need--;
+ }
+ printf("\n");
+ return FALSE;
}
@@ -1446,9 +1413,9 @@ cmd_tab (Word *w, int align, char has_pa
*=======================================================================*/
static int
-cmd_plain (Word *w, int align, char has_param, int param) {
- attr_pop_all();
- return FALSE;
+cmd_plain (const struct OutputContext *oc, Word *w, int align, char has_param, int param) {
+ attr_pop_all(oc);
+ return FALSE;
}
@@ -1459,9 +1426,9 @@ cmd_plain (Word *w, int align, char has_
* Returns: Flag, true only if rest of Words on line should be ignored.
*=======================================================================*/
static int
-cmd_fnil (Word *w, int align, char has_param, int param) {
- attr_push(ATTR_FONTFACE,FONTNIL_STR);
- return FALSE;
+cmd_fnil (const struct OutputContext *oc, Word *w, int align, char has_param, int param) {
+ attr_push(ATTR_FONTFACE,FONTNIL_STR, oc);
+ return FALSE;
}
@@ -1473,9 +1440,9 @@ cmd_fnil (Word *w, int align, char has_p
* Returns: Flag, true only if rest of Words on line should be ignored.
*=======================================================================*/
static int
-cmd_froman (Word *w, int align, char has_param, int param) {
- attr_push(ATTR_FONTFACE,FONTROMAN_STR);
- return FALSE;
+cmd_froman (const struct OutputContext *oc, Word *w, int align, char has_param, int param) {
+ attr_push(ATTR_FONTFACE,FONTROMAN_STR, oc);
+ return FALSE;
}
@@ -1487,9 +1454,9 @@ cmd_froman (Word *w, int align, char has
*=======================================================================*/
static int
-cmd_fswiss (Word *w, int align, char has_param, int param) {
- attr_push(ATTR_FONTFACE,FONTSWISS_STR);
- return FALSE;
+cmd_fswiss (const struct OutputContext *oc, Word *w, int align, char has_param, int param) {
+ attr_push(ATTR_FONTFACE,FONTSWISS_STR, oc);
+ return FALSE;
}
@@ -1501,9 +1468,9 @@ cmd_fswiss (Word *w, int align, char has
*=======================================================================*/
static int
-cmd_fmodern (Word *w, int align, char has_param, int param) {
- attr_push(ATTR_FONTFACE,FONTMODERN_STR);
- return FALSE;
+cmd_fmodern (const struct OutputContext *oc, Word *w, int align, char has_param, int param) {
+ attr_push(ATTR_FONTFACE,FONTMODERN_STR, oc);
+ return FALSE;
}
@@ -1515,9 +1482,9 @@ cmd_fmodern (Word *w, int align, char ha
*=======================================================================*/
static int
-cmd_fscript (Word *w, int align, char has_param, int param) {
- attr_push(ATTR_FONTFACE,FONTSCRIPT_STR);
- return FALSE;
+cmd_fscript (const struct OutputContext *oc, Word *w, int align, char has_param, int param) {
+ attr_push(ATTR_FONTFACE,FONTSCRIPT_STR, oc);
+ return FALSE;
}
/*========================================================================
@@ -1528,9 +1495,9 @@ cmd_fscript (Word *w, int align, char ha
*=======================================================================*/
static int
-cmd_fdecor (Word *w, int align, char has_param, int param) {
- attr_push(ATTR_FONTFACE,FONTDECOR_STR);
- return FALSE;
+cmd_fdecor (const struct OutputContext *oc, Word *w, int align, char has_param, int param) {
+ attr_push(ATTR_FONTFACE,FONTDECOR_STR, oc);
+ return FALSE;
}
/*========================================================================
@@ -1541,9 +1508,9 @@ cmd_fdecor (Word *w, int align, char has
*=======================================================================*/
static int
-cmd_ftech (Word *w, int align, char has_param, int param) {
- attr_push(ATTR_FONTFACE,FONTTECH_STR);
- return FALSE;
+cmd_ftech (const struct OutputContext *oc, Word *w, int align, char has_param, int param) {
+ attr_push(ATTR_FONTFACE,FONTTECH_STR, oc);
+ return FALSE;
}
/*========================================================================
@@ -1554,16 +1521,16 @@ cmd_ftech (Word *w, int align, char has_
*=======================================================================*/
static int
-cmd_expand (Word *w, int align, char has_param, int param) {
- char str[10];
- if (has_param) {
- sprintf(str, "%d", param/4);
- if (!param)
- attr_pop(ATTR_EXPAND);
- else
- attr_push(ATTR_EXPAND, str);
- }
- return FALSE;
+cmd_expand (const struct OutputContext *oc, Word *w, int align, char has_param, int param) {
+ char str[10];
+ if (has_param) {
+ sprintf(str, "%d", param/4);
+ if (!param)
+ attr_pop(ATTR_EXPAND, oc);
+ else
+ attr_push(ATTR_EXPAND, str, oc);
+ }
+ return FALSE;
}
@@ -1575,16 +1542,16 @@ cmd_expand (Word *w, int align, char has
*=======================================================================*/
static int
-cmd_emboss (Word *w, int align, char has_param, int param) {
- char str[10];
- if (has_param && !param)
- attr_pop(ATTR_EMBOSS);
- else
- {
- sprintf(str, "%d", param);
- attr_push(ATTR_EMBOSS, str);
- }
- return FALSE;
+cmd_emboss (const struct OutputContext *oc, Word *w, int align, char has_param, int param) {
+ char str[10];
+ if (has_param && !param)
+ attr_pop(ATTR_EMBOSS, oc);
+ else
+ {
+ sprintf(str, "%d", param);
+ attr_push(ATTR_EMBOSS, str, oc);
+ }
+ return FALSE;
}
@@ -1596,16 +1563,16 @@ cmd_emboss (Word *w, int align, char has
*=======================================================================*/
static int
-cmd_engrave (Word *w, int align, char has_param, int param) {
- char str[10];
- if (has_param && !param)
- attr_pop(ATTR_ENGRAVE);
- else
- {
- sprintf(str, "%d", param);
- attr_push(ATTR_ENGRAVE, str);
- }
- return FALSE;
+cmd_engrave (const struct OutputContext *oc, Word *w, int align, char has_param, int param) {
+ char str[10];
+ if (has_param && !param)
+ attr_pop(ATTR_ENGRAVE, oc);
+ else
+ {
+ sprintf(str, "%d", param);
+ attr_push(ATTR_ENGRAVE, str, oc);
+ }
+ return FALSE;
}
/*========================================================================
@@ -1616,12 +1583,12 @@ cmd_engrave (Word *w, int align, char ha
*=======================================================================*/
static int
-cmd_caps (Word *w, int align, char has_param, int param) {
- if (has_param && !param)
- attr_pop(ATTR_CAPS);
- else
- attr_push(ATTR_CAPS,NULL);
- return FALSE;
+cmd_caps (const struct OutputContext *oc, Word *w, int align, char has_param, int param) {
+ if (has_param && !param)
+ attr_pop(ATTR_CAPS, oc);
+ else
+ attr_push(ATTR_CAPS,NULL, oc);
+ return FALSE;
}
@@ -1632,12 +1599,12 @@ cmd_caps (Word *w, int align, char has_p
* Returns: Flag, true only if rest of Words on line should be ignored.
*=======================================================================*/
static int
-cmd_scaps (Word *w, int align, char has_param, int param) {
- if (has_param && !param)
- attr_pop(ATTR_SMALLCAPS);
- else
- attr_push(ATTR_SMALLCAPS,NULL);
- return FALSE;
+cmd_scaps (const struct OutputContext *oc, Word *w, int align, char has_param, int param) {
+ if (has_param && !param)
+ attr_pop(ATTR_SMALLCAPS, oc);
+ else
+ attr_push(ATTR_SMALLCAPS,NULL, oc);
+ return FALSE;
}
@@ -1648,12 +1615,14 @@ cmd_scaps (Word *w, int align, char has_
* Returns: Flag, true only if rest of Words on line should be ignored.
*=======================================================================*/
static int
-cmd_bullet (Word *w, int align, char has_param, int param) {
- if (op->chars.bullet) {
- if (safe_printf(0, op->chars.bullet)) fprintf(stderr, TOO_MANY_ARGS, "chars.bullet");
- ++total_chars_this_line; /* \tab */
- }
- return FALSE;
+cmd_bullet (const struct OutputContext *oc, Word *w, int align, char has_param, int param) {
+ const struct unRTFOutputDevice *device = &oc->conversion->options->device;
+
+ if (oc->personality->chars.bullet) {
+ if (safe_printf(device, 0, oc->personality->chars.bullet)) fprintf(stderr, TOO_MANY_ARGS, "chars.bullet");
+ ++oc->conversion->total_chars_this_line; /* \tab */
+ }
+ return FALSE;
}
/*========================================================================
@@ -1663,12 +1632,14 @@ cmd_bullet (Word *w, int align, char has
* Returns: Flag, true only if rest of Words on line should be ignored.
*=======================================================================*/
static int
-cmd_ldblquote (Word *w, int align, char has_param, int param) {
- if (op->chars.left_dbl_quote) {
- if (safe_printf(0, op->chars.left_dbl_quote)) fprintf(stderr, TOO_MANY_ARGS, "chars.left_dbl_quote");
- ++total_chars_this_line; /* \tab */
- }
- return FALSE;
+cmd_ldblquote (const struct OutputContext *oc, Word *w, int align, char has_param, int param) {
+ const struct unRTFOutputDevice *device = &oc->conversion->options->device;
+
+ if (oc->personality->chars.left_dbl_quote) {
+ if (safe_printf(device, 0, oc->personality->chars.left_dbl_quote)) fprintf(stderr, TOO_MANY_ARGS, "chars.left_dbl_quote");
+ ++oc->conversion->total_chars_this_line; /* \tab */
+ }
+ return FALSE;
}
@@ -1680,12 +1651,14 @@ cmd_ldblquote (Word *w, int align, char
*=======================================================================*/
static int
-cmd_rdblquote (Word *w, int align, char has_param, int param) {
- if (op->chars.right_dbl_quote) {
- if (safe_printf(0, op->chars.right_dbl_quote)) fprintf(stderr, TOO_MANY_ARGS, "chars.right_dbl_quote");
- ++total_chars_this_line; /* \tab */
- }
- return FALSE;
+cmd_rdblquote (const struct OutputContext *oc, Word *w, int align, char has_param, int param) {
+ const struct unRTFOutputDevice *device = &oc->conversion->options->device;
+
+ if (oc->personality->chars.right_dbl_quote) {
+ if (safe_printf(device, 0, oc->personality->chars.right_dbl_quote)) fprintf(stderr, TOO_MANY_ARGS, "chars.right_dbl_quote");
+ ++oc->conversion->total_chars_this_line; /* \tab */
+ }
+ return FALSE;
}
@@ -1696,12 +1669,14 @@ cmd_rdblquote (Word *w, int align, char
* Returns: Flag, true only if rest of Words on line should be ignored.
*=======================================================================*/
static int
-cmd_lquote (Word *w, int align, char has_param, int param) {
- if (op->chars.left_quote) {
- if (safe_printf(0, op->chars.left_quote)) fprintf(stderr, TOO_MANY_ARGS, "chars.left_quote");
- ++total_chars_this_line; /* \tab */
- }
- return FALSE;
+cmd_lquote (const struct OutputContext *oc, Word *w, int align, char has_param, int param) {
+ const struct unRTFOutputDevice *device = &oc->conversion->options->device;
+
+ if (oc->personality->chars.left_quote) {
+ if (safe_printf(device, 0, oc->personality->chars.left_quote)) fprintf(stderr, TOO_MANY_ARGS, "chars.left_quote");
+ ++oc->conversion->total_chars_this_line; /* \tab */
+ }
+ return FALSE;
}
@@ -1713,12 +1688,14 @@ cmd_lquote (Word *w, int align, char has
*=======================================================================*/
static int
-cmd_nonbreaking_space (Word *w, int align, char has_param, int param) {
- if (op->chars.nonbreaking_space) {
- if (safe_printf(0, op->chars.nonbreaking_space)) fprintf(stderr, TOO_MANY_ARGS, "chars.nonbreaking_space");
- ++total_chars_this_line; /* \tab */
- }
- return FALSE;
+cmd_nonbreaking_space (const struct OutputContext *oc, Word *w, int align, char has_param, int param) {
+ const struct unRTFOutputDevice *device = &oc->conversion->options->device;
+
+ if (oc->personality->chars.nonbreaking_space) {
+ if (safe_printf(device, 0, oc->personality->chars.nonbreaking_space)) fprintf(stderr, TOO_MANY_ARGS, "chars.nonbreaking_space");
+ ++oc->conversion->total_chars_this_line; /* \tab */
+ }
+ return FALSE;
}
@@ -1730,12 +1707,14 @@ cmd_nonbreaking_space (Word *w, int alig
*=======================================================================*/
static int
-cmd_nonbreaking_hyphen (Word *w, int align, char has_param, int param) {
- if (op->chars.nonbreaking_hyphen) {
- if (safe_printf(0, op->chars.nonbreaking_hyphen)) fprintf(stderr, TOO_MANY_ARGS, "chars.nonbreaking_hyphen");
- ++total_chars_this_line; /* \tab */
- }
- return FALSE;
+cmd_nonbreaking_hyphen (const struct OutputContext *oc, Word *w, int align, char has_param, int param) {
+ const struct unRTFOutputDevice *device = &oc->conversion->options->device;
+
+ if (oc->personality->chars.nonbreaking_hyphen) {
+ if (safe_printf(device, 0, oc->personality->chars.nonbreaking_hyphen)) fprintf(stderr, TOO_MANY_ARGS, "chars.nonbreaking_hyphen");
+ ++oc->conversion->total_chars_this_line; /* \tab */
+ }
+ return FALSE;
}
@@ -1747,12 +1726,14 @@ cmd_nonbreaking_hyphen (Word *w, int ali
*=======================================================================*/
static int
-cmd_optional_hyphen (Word *w, int align, char has_param, int param) {
- if (op->chars.optional_hyphen) {
- if (safe_printf(0, op->chars.optional_hyphen)) fprintf(stderr, TOO_MANY_ARGS, "chars.optional_hyphen");
- ++total_chars_this_line; /* \tab */
- }
- return FALSE;
+cmd_optional_hyphen (const struct OutputContext *oc, Word *w, int align, char has_param, int param) {
+ const struct unRTFOutputDevice *device = &oc->conversion->options->device;
+
+ if (oc->personality->chars.optional_hyphen) {
+ if (safe_printf(device, 0, oc->personality->chars.optional_hyphen)) fprintf(stderr, TOO_MANY_ARGS, "chars.optional_hyphen");
+ ++oc->conversion->total_chars_this_line; /* \tab */
+ }
+ return FALSE;
}
@@ -1763,12 +1744,14 @@ cmd_optional_hyphen (Word *w, int align,
* Returns: Flag, true only if rest of Words on line should be ignored.
*=======================================================================*/
static int
-cmd_emdash (Word *w, int align, char has_param, int param) {
- if (op->chars.emdash) {
- if (safe_printf(0, op->chars.emdash)) fprintf(stderr, TOO_MANY_ARGS, "chars.emdash");
- ++total_chars_this_line; /* \tab */
- }
- return FALSE;
+cmd_emdash (const struct OutputContext *oc, Word *w, int align, char has_param, int param) {
+ const struct unRTFOutputDevice *device = &oc->conversion->options->device;
+
+ if (oc->personality->chars.emdash) {
+ if (safe_printf(device, 0, oc->personality->chars.emdash)) fprintf(stderr, TOO_MANY_ARGS, "chars.emdash");
+ ++oc->conversion->total_chars_this_line; /* \tab */
+ }
+ return FALSE;
}
@@ -1780,12 +1763,14 @@ cmd_emdash (Word *w, int align, char has
*=======================================================================*/
static int
-cmd_endash (Word *w, int align, char has_param, int param) {
- if (op->chars.endash) {
- if (safe_printf(0, op->chars.endash)) fprintf(stderr, TOO_MANY_ARGS, "chars.endash");
- ++total_chars_this_line; /* \tab */
- }
- return FALSE;
+cmd_endash (const struct OutputContext *oc, Word *w, int align, char has_param, int param) {
+ const struct unRTFOutputDevice *device = &oc->conversion->options->device;
+
+ if (oc->personality->chars.endash) {
+ if (safe_printf(device, 0, oc->personality->chars.endash)) fprintf(stderr, TOO_MANY_ARGS, "chars.endash");
+ ++oc->conversion->total_chars_this_line; /* \tab */
+ }
+ return FALSE;
}
@@ -1797,12 +1782,14 @@ cmd_endash (Word *w, int align, char has
*=======================================================================*/
static int
-cmd_rquote (Word *w, int align, char has_param, int param) {
- if (op->chars.right_quote) {
- if (safe_printf(0, op->chars.right_quote)) fprintf(stderr, TOO_MANY_ARGS, "chars.right_quote");
- ++total_chars_this_line; /* \tab */
- }
- return FALSE;
+cmd_rquote (const struct OutputContext *oc, Word *w, int align, char has_param, int param) {
+ const struct unRTFOutputDevice *device = &oc->conversion->options->device;
+
+ if (oc->personality->chars.right_quote) {
+ if (safe_printf(device, 0, oc->personality->chars.right_quote)) fprintf(stderr, TOO_MANY_ARGS, "chars.right_quote");
+ ++oc->conversion->total_chars_this_line; /* \tab */
+ }
+ return FALSE;
}
@@ -1813,12 +1800,14 @@ cmd_rquote (Word *w, int align, char has
* Returns: Flag, true only if rest of Words on line should be ignored.
*=======================================================================*/
static int
-cmd_par (Word *w, int align, char has_param, int param) {
- if (op->line_break) {
- if (safe_printf(0, op->line_break)) fprintf(stderr, TOO_MANY_ARGS, "line_break");
- total_chars_this_line = 0; /* \tab */
- }
- return FALSE;
+cmd_par (const struct OutputContext *oc, Word *w, int align, char has_param, int param) {
+ const struct unRTFOutputDevice *device = &oc->conversion->options->device;
+
+ if (oc->personality->line_break) {
+ if (safe_printf(device, 0, oc->personality->line_break)) fprintf(stderr, TOO_MANY_ARGS, "line_break");
+ oc->conversion->total_chars_this_line = 0; /* \tab */
+ }
+ return FALSE;
}
@@ -1830,12 +1819,14 @@ cmd_par (Word *w, int align, char has_pa
*=======================================================================*/
static int
-cmd_line (Word *w, int align, char has_param, int param) {
- if (op->line_break) {
- if (safe_printf(0, op->line_break)) fprintf(stderr, TOO_MANY_ARGS, "line_break");
- total_chars_this_line = 0; /* \tab */
- }
- return FALSE;
+cmd_line (const struct OutputContext *oc, Word *w, int align, char has_param, int param) {
+ const struct unRTFOutputDevice *device = &oc->conversion->options->device;
+
+ if (oc->personality->line_break) {
+ if (safe_printf(device, 0, oc->personality->line_break)) fprintf(stderr, TOO_MANY_ARGS, "line_break");
+ oc->conversion->total_chars_this_line = 0; /* \tab */
+ }
+ return FALSE;
}
@@ -1846,12 +1837,14 @@ cmd_line (Word *w, int align, char has_p
* Returns: Flag, true only if rest of Words on line should be ignored.
*=======================================================================*/
-static int cmd_page (Word *w, int align, char has_param, int param) {
- if (op->page_break) {
- if (safe_printf(0, op->page_break)) fprintf(stderr, TOO_MANY_ARGS, "page_break");
- total_chars_this_line = 0; /* \tab */
- }
- return FALSE;
+static int cmd_page (const struct OutputContext *oc, Word *w, int align, char has_param, int param) {
+ const struct unRTFOutputDevice *device = &oc->conversion->options->device;
+
+ if (oc->personality->page_break) {
+ if (safe_printf(device, 0, oc->personality->page_break)) fprintf(stderr, TOO_MANY_ARGS, "page_break");
+ oc->conversion->total_chars_this_line = 0; /* \tab */
+ }
+ return FALSE;
}
@@ -1862,9 +1855,9 @@ static int cmd_page (Word *w, int align,
* Returns: Flag, true only if rest of Words on line should be ignored.
*=======================================================================*/
-static int cmd_intbl (Word *w, int align, char has_param, int param) {
- ++coming_pars_that_are_tabular;
- return FALSE;
+static int cmd_intbl (const struct OutputContext *oc, Word *w, int align, char has_param, int param) {
+ ++oc->conversion->coming_pars_that_are_tabular;
+ return FALSE;
}
@@ -1875,31 +1868,31 @@ static int cmd_intbl (Word *w, int align
* Returns: Flag, true only if rest of Words on line should be ignored.
*=======================================================================*/
-static int cmd_ulnone (Word *w, int align, char has_param, int param) {
- int attr, more=TRUE;
-
+static int cmd_ulnone (const struct OutputContext *oc, Word *w, int align, char has_param, int param) {
+ int attr, more=TRUE;
+
#ifdef BINARY_ATTRS
- attr_remove_underlining()) fprintf(stderr, TOO_MANY_ARGS, );
+ attr_remove_underlining() fprintf(stderr, TOO_MANY_ARGS, );
#else
- do {
- attr = attr_read();
- if (attr==ATTR_UNDERLINE ||
- attr==ATTR_DOT_UL ||
- attr==ATTR_DASH_UL ||
- attr==ATTR_DOT_DASH_UL ||
- attr==ATTR_2DOT_DASH_UL ||
- attr==ATTR_WORD_UL ||
- attr==ATTR_WAVE_UL ||
- attr==ATTR_THICK_UL ||
- attr==ATTR_DOUBLE_UL)
- {
- if (!attr_pop(ATTR_UNDERLINE))
- ;
- } else
- more=FALSE;
- } while(more);
+ do {
+ attr = attr_read(oc->conversion);
+ if (attr==ATTR_UNDERLINE ||
+ attr==ATTR_DOT_UL ||
+ attr==ATTR_DASH_UL ||
+ attr==ATTR_DOT_DASH_UL ||
+ attr==ATTR_2DOT_DASH_UL ||
+ attr==ATTR_WORD_UL ||
+ attr==ATTR_WAVE_UL ||
+ attr==ATTR_THICK_UL ||
+ attr==ATTR_DOUBLE_UL)
+ {
+ if (!attr_pop(ATTR_UNDERLINE, oc))
+ ;
+ } else
+ more=FALSE;
+ } while(more);
#endif
- return FALSE;
+ return FALSE;
}
/*========================================================================
@@ -1909,13 +1902,13 @@ static int cmd_ulnone (Word *w, int alig
* Returns: Flag, true only if rest of Words on line should be ignored.
*=======================================================================*/
-static int cmd_ul (Word *w, int align, char has_param, int param) {
- if (has_param && param == 0) {
- cmd_ulnone(w, align, has_param, param);
- } else {
- attr_push(ATTR_UNDERLINE, NULL);
- }
- return FALSE;
+static int cmd_ul (const struct OutputContext *oc, Word *w, int align, char has_param, int param) {
+ if (has_param && param == 0) {
+ cmd_ulnone(oc, w, align, has_param, param);
+ } else {
+ attr_push(ATTR_UNDERLINE, NULL, oc);
+ }
+ return FALSE;
}
/*========================================================================
@@ -1925,9 +1918,9 @@ static int cmd_ul (Word *w, int align, c
* Returns: Flag, true only if rest of Words on line should be ignored.
*=======================================================================*/
-static int cmd_uld (Word *w, int align, char has_param, int param) {
- attr_push(ATTR_DOUBLE_UL, NULL);
- return FALSE;
+static int cmd_uld (const struct OutputContext *oc, Word *w, int align, char has_param, int param) {
+ attr_push(ATTR_DOUBLE_UL, NULL, oc);
+ return FALSE;
}
/*========================================================================
@@ -1937,9 +1930,9 @@ static int cmd_uld (Word *w, int align,
* Returns: Flag, true only if rest of Words on line should be ignored.
*=======================================================================*/
-static int cmd_uldb (Word *w, int align, char has_param, int param) {
- attr_push(ATTR_DOT_UL, NULL);
- return FALSE;
+static int cmd_uldb (const struct OutputContext *oc, Word *w, int align, char has_param, int param) {
+ attr_push(ATTR_DOT_UL, NULL, oc);
+ return FALSE;
}
@@ -1950,9 +1943,9 @@ static int cmd_uldb (Word *w, int align,
* Returns: Flag, true only if rest of Words on line should be ignored.
*=======================================================================*/
-static int cmd_uldash (Word *w, int align, char has_param, int param) {
- attr_push(ATTR_DASH_UL, NULL);
- return FALSE;
+static int cmd_uldash (const struct OutputContext *oc, Word *w, int align, char has_param, int param) {
+ attr_push(ATTR_DASH_UL, NULL, oc);
+ return FALSE;
}
@@ -1963,9 +1956,9 @@ static int cmd_uldash (Word *w, int alig
* Returns: Flag, true only if rest of Words on line should be ignored.
*=======================================================================*/
-static int cmd_uldashd (Word *w, int align, char has_param, int param) {
- attr_push(ATTR_DOT_DASH_UL,NULL);
- return FALSE;
+static int cmd_uldashd (const struct OutputContext *oc, Word *w, int align, char has_param, int param) {
+ attr_push(ATTR_DOT_DASH_UL,NULL, oc);
+ return FALSE;
}
@@ -1976,9 +1969,9 @@ static int cmd_uldashd (Word *w, int ali
* Returns: Flag, true only if rest of Words on line should be ignored.
*=======================================================================*/
-static int cmd_uldashdd (Word *w, int align, char has_param, int param) {
- attr_push(ATTR_2DOT_DASH_UL,NULL);
- return FALSE;
+static int cmd_uldashdd (const struct OutputContext *oc, Word *w, int align, char has_param, int param) {
+ attr_push(ATTR_2DOT_DASH_UL,NULL, oc);
+ return FALSE;
}
@@ -1989,9 +1982,9 @@ static int cmd_uldashdd (Word *w, int al
* Returns: Flag, true only if rest of Words on line should be ignored.
*=======================================================================*/
-static int cmd_ulw (Word *w, int align, char has_param, int param) {
- attr_push(ATTR_WORD_UL,NULL);
- return FALSE;
+static int cmd_ulw (const struct OutputContext *oc, Word *w, int align, char has_param, int param) {
+ attr_push(ATTR_WORD_UL,NULL, oc);
+ return FALSE;
}
@@ -2002,9 +1995,9 @@ static int cmd_ulw (Word *w, int align,
* Returns: Flag, true only if rest of Words on line should be ignored.
*=======================================================================*/
-static int cmd_ulth (Word *w, int align, char has_param, int param) {
- attr_push(ATTR_THICK_UL,NULL);
- return FALSE;
+static int cmd_ulth (const struct OutputContext *oc, Word *w, int align, char has_param, int param) {
+ attr_push(ATTR_THICK_UL,NULL, oc);
+ return FALSE;
}
@@ -2015,9 +2008,9 @@ static int cmd_ulth (Word *w, int align,
* Returns: Flag, true only if rest of Words on line should be ignored.
*=======================================================================*/
-static int cmd_ulthd (Word *w, int align, char has_param, int param) {
- attr_push(ATTR_THICK_UL, NULL);
- return FALSE;
+static int cmd_ulthd (const struct OutputContext *oc, Word *w, int align, char has_param, int param) {
+ attr_push(ATTR_THICK_UL, NULL, oc);
+ return FALSE;
}
@@ -2028,9 +2021,9 @@ static int cmd_ulthd (Word *w, int align
* Returns: Flag, true only if rest of Words on line should be ignored.
*=======================================================================*/
-static int cmd_ulthdash (Word *w, int align, char has_param, int param) {
- attr_push(ATTR_THICK_UL, NULL);
- return FALSE;
+static int cmd_ulthdash (const struct OutputContext *oc, Word *w, int align, char has_param, int param) {
+ attr_push(ATTR_THICK_UL, NULL, oc);
+ return FALSE;
}
@@ -2041,9 +2034,9 @@ static int cmd_ulthdash (Word *w, int al
* Returns: Flag, true only if rest of Words on line should be ignored.
*=======================================================================*/
-static int cmd_ulwave (Word *w, int align, char has_param, int param) {
- attr_push(ATTR_WAVE_UL,NULL);
- return FALSE;
+static int cmd_ulwave (const struct OutputContext *oc, Word *w, int align, char has_param, int param) {
+ attr_push(ATTR_WAVE_UL,NULL, oc);
+ return FALSE;
}
@@ -2054,12 +2047,12 @@ static int cmd_ulwave (Word *w, int alig
* Returns: Flag, true only if rest of Words on line should be ignored.
*=======================================================================*/
-static int cmd_strike (Word *w, int align, char has_param, int param) {
- if (has_param && param==0)
- attr_pop(ATTR_STRIKE);
- else
- attr_push(ATTR_STRIKE,NULL);
- return FALSE;
+static int cmd_strike (const struct OutputContext *oc, Word *w, int align, char has_param, int param) {
+ if (has_param && param==0)
+ attr_pop(ATTR_STRIKE, oc);
+ else
+ attr_push(ATTR_STRIKE,NULL, oc);
+ return FALSE;
}
/*========================================================================
@@ -2069,12 +2062,12 @@ static int cmd_strike (Word *w, int alig
* Returns: Flag, true only if rest of Words on line should be ignored.
*=======================================================================*/
-static int cmd_strikedl (Word *w, int align, char has_param, int param) {
- if (has_param && param==0)
- attr_pop(ATTR_DBL_STRIKE);
- else
- attr_push(ATTR_DBL_STRIKE,NULL);
- return FALSE;
+static int cmd_strikedl (const struct OutputContext *oc, Word *w, int align, char has_param, int param) {
+ if (has_param && param==0)
+ attr_pop(ATTR_DBL_STRIKE, oc);
+ else
+ attr_push(ATTR_DBL_STRIKE,NULL, oc);
+ return FALSE;
}
@@ -2085,12 +2078,12 @@ static int cmd_strikedl (Word *w, int al
* Returns: Flag, true only if rest of Words on line should be ignored.
*=======================================================================*/
-static int cmd_striked (Word *w, int align, char has_param, int param) {
- if (has_param && param==0)
- attr_pop(ATTR_DBL_STRIKE);
- else
- attr_push(ATTR_DBL_STRIKE,NULL);
- return FALSE;
+static int cmd_striked (const struct OutputContext *oc, Word *w, int align, char has_param, int param) {
+ if (has_param && param==0)
+ attr_pop(ATTR_DBL_STRIKE, oc);
+ else
+ attr_push(ATTR_DBL_STRIKE,NULL, oc);
+ return FALSE;
}
@@ -2101,8 +2094,8 @@ static int cmd_striked (Word *w, int ali
* Returns: Flag, true only if rest of Words on line should be ignored.
*=======================================================================*/
-static int cmd_rtf (Word *w, int align, char has_param, int param) {
- return FALSE;
+static int cmd_rtf (const struct OutputContext *oc, Word *w, int align, char has_param, int param) {
+ return FALSE;
}
@@ -2113,12 +2106,12 @@ static int cmd_rtf (Word *w, int align,
* Returns: Flag, true only if rest of Words on line should be ignored.
*=======================================================================*/
-static int cmd_up (Word *w, int align, char has_param, int param) {
- if (has_param && param==0)
- attr_pop(ATTR_SUPER);
- else
- attr_push(ATTR_SUPER,NULL);
- return FALSE;
+static int cmd_up (const struct OutputContext *oc, Word *w, int align, char has_param, int param) {
+ if (has_param && param==0)
+ attr_pop(ATTR_SUPER, oc);
+ else
+ attr_push(ATTR_SUPER,NULL, oc);
+ return FALSE;
}
/*========================================================================
@@ -2128,61 +2121,63 @@ static int cmd_up (Word *w, int align, c
* Returns: Flag, always false
*=======================================================================*/
-static int cmd_u (Word *w, int align, char has_param, int param) {
-/* TODO: Unicode characters won't be correctly preprocessed if sizeof(int) < 4
- * and document have unicode character which value is greater than 65536
- */
+static int cmd_u (const struct OutputContext *oc, Word *w, int align, char has_param, int param) {
+ /* TODO: Unicode characters won't be correctly preprocessed if sizeof(int) < 4
+ * and document have unicode character which value is greater than 65536
+ */
- short done=0;
- long unicode_number = (long) param; /* On 16bit architectures int is too small to store unicode characters. - AF */
- char tmp[12]; /* Number of characters that can be in int type (including '\0'). If int size is greater than 4 bytes change this value. - AF */
- char *alias;
+ const struct unRTFOutputDevice *device = &oc->conversion->options->device;
+ short done=0;
+ long unicode_number = (long) param; /* On 16bit architectures int is too small to store unicode characters. - AF */
+ char tmp[12]; /* Number of characters that can be in int type (including '\0'). If int size is greater than 4 bytes change this value. - AF */
+ char *alias;
#if DEBUG
- char *str;
- if (has_param == TRUE)
- {
- fprintf(stderr,"param is %d (x%x) (0%o)\n", param,
- param, param);
- }
- if (w->hash_index)
- {
- str=hash_get_string (w->hash_index);
- fprintf(stderr,"string is %s\n", str);
- }
+ char *str;
+
+ if (has_param == TRUE)
+ {
+ fprintf(stderr,"param is %d (x%x) (0%o)\n", param,
+ param, param);
+ }
+ if (w->hash_index)
+ {
+ str=hash_get_string (oc->conversion, w->hash_index);
+ fprintf(stderr,"string is %s\n", str);
+ }
#endif
- /* 0.20.3 - daved added missing function call for unprocessed chars */
- if ((alias = get_alias(op, param)) != NULL)
- {
- printf("%s", alias);
- done++;
- }
- else
- if(!done && op->unisymbol_print)
- {
- if (unicode_number < 0)
- {
+ /* 0.20.3 - daved added missing function call for unprocessed chars */
+ if ((alias = get_alias(oc->personality, param)) != NULL)
+ {
+ printf("%s", alias);
+ done++;
+ }
+ else
+ if(!done && oc->personality->unisymbol_print)
+ {
+ if (unicode_number < 0)
+ {
#if DEBUG
- fprintf(stderr, "Invalid unicode character number accured: %ld\n", unicode_number);
+ fprintf(stderr, "Invalid unicode character number accured: %ld\n", unicode_number);
#endif
- unicode_number += 65536;
+ unicode_number += 65536;
#if DEBUG
- fprintf(stderr, "Assumes it should be: %ld\n", unicode_number);
+ fprintf(stderr, "Assumes it should be: %ld\n", unicode_number);
#endif
- }
- sprintf(tmp, "%ld", unicode_number);
-
- if (safe_printf(1, op->unisymbol_print, tmp)) fprintf(stderr, TOO_MANY_ARGS, "unisymbol_print");
- done++;
- }
-
- /*
- ** if we know how to represent the unicode character in the
- ** output language, we need to skip the next word, otherwise
- ** we will output that alternative.
- */
- if (done)
- return(SKIP_ONE_WORD);
- return(FALSE);
+ }
+ sprintf(tmp, "%ld", unicode_number);
+
+ if (safe_printf(device, 1, oc->personality->unisymbol_print, tmp)) fprintf(stderr, TOO_MANY_ARGS, "unisymbol_print");
+ done++;
+ }
+
+ /*
+ ** if we know how to represent the unicode character in the
+ ** output language, we need to skip the next word, otherwise
+ ** we will output that alternative.
+ */
+ if (done)
+ return(SKIP_ONE_WORD);
+ return(FALSE);
}
/*========================================================================
@@ -2192,12 +2187,12 @@ static int cmd_u (Word *w, int align, ch
* Returns: Flag, true only if rest of Words on line should be ignored.
*=======================================================================*/
-static int cmd_dn (Word *w, int align, char has_param, int param) {
- if (has_param && param==0)
- attr_pop(ATTR_SUB);
- else
- attr_push(ATTR_SUB,NULL);
- return FALSE;
+static int cmd_dn (const struct OutputContext *oc, Word *w, int align, char has_param, int param) {
+ if (has_param && param==0)
+ attr_pop(ATTR_SUB, oc);
+ else
+ attr_push(ATTR_SUB,NULL, oc);
+ return FALSE;
}
/*========================================================================
@@ -2207,10 +2202,10 @@ static int cmd_dn (Word *w, int align, c
* Returns: Flag, true only if rest of Words on line should be ignored.
*=======================================================================*/
-static int cmd_nosupersub (Word *w, int align, char has_param, int param) {
- attr_pop(ATTR_SUPER);
- attr_pop(ATTR_SUB);
- return FALSE;
+static int cmd_nosupersub (const struct OutputContext *oc, Word *w, int align, char has_param, int param) {
+ attr_pop(ATTR_SUPER, oc);
+ attr_pop(ATTR_SUB, oc);
+ return FALSE;
}
/*========================================================================
@@ -2220,12 +2215,12 @@ static int cmd_nosupersub (Word *w, int
* Returns: Flag, true only if rest of Words on line should be ignored.
*=======================================================================*/
-static int cmd_super (Word *w, int align, char has_param, int param) {
- if (has_param && param==0)
- attr_pop(ATTR_SUPER);
- else
- attr_push(ATTR_SUPER,NULL);
- return FALSE;
+static int cmd_super (const struct OutputContext *oc, Word *w, int align, char has_param, int param) {
+ if (has_param && param==0)
+ attr_pop(ATTR_SUPER, oc);
+ else
+ attr_push(ATTR_SUPER,NULL, oc);
+ return FALSE;
}
/*========================================================================
@@ -2235,12 +2230,12 @@ static int cmd_super (Word *w, int align
* Returns: Flag, true only if rest of Words on line should be ignored.
*=======================================================================*/
-static int cmd_sub (Word *w, int align, char has_param, int param) {
- if (has_param && param==0)
- attr_pop(ATTR_SUB);
- else
- attr_push(ATTR_SUB,NULL);
- return FALSE;
+static int cmd_sub (const struct OutputContext *oc, Word *w, int align, char has_param, int param) {
+ if (has_param && param==0)
+ attr_pop(ATTR_SUB, oc);
+ else
+ attr_push(ATTR_SUB,NULL, oc);
+ return FALSE;
}
/*========================================================================
@@ -2250,12 +2245,12 @@ static int cmd_sub (Word *w, int align,
* Returns: Flag, true only if rest of Words on line should be ignored.
*=======================================================================*/
-static int cmd_shad (Word *w, int align, char has_param, int param) {
- if (has_param && param==0)
- attr_pop(ATTR_SHADOW);
- else
- attr_push(ATTR_SHADOW,NULL);
- return FALSE;
+static int cmd_shad (const struct OutputContext *oc, Word *w, int align, char has_param, int param) {
+ if (has_param && param==0)
+ attr_pop(ATTR_SHADOW, oc);
+ else
+ attr_push(ATTR_SHADOW,NULL, oc);
+ return FALSE;
}
/*========================================================================
@@ -2266,13 +2261,13 @@ static int cmd_shad (Word *w, int align,
*=======================================================================*/
static int
-cmd_b (Word *w, int align, char has_param, int param) {
- if (has_param && param==0) {
- attr_pop(ATTR_BOLD);
- }
- else
- attr_push(ATTR_BOLD,NULL);
- return FALSE;
+cmd_b (const struct OutputContext *oc, Word *w, int align, char has_param, int param) {
+ if (has_param && param==0) {
+ attr_pop(ATTR_BOLD, oc);
+ }
+ else
+ attr_push(ATTR_BOLD,NULL, oc);
+ return FALSE;
}
/*========================================================================
@@ -2282,12 +2277,12 @@ cmd_b (Word *w, int align, char has_para
* Returns: Flag, true only if rest of Words on line should be ignored.
*=======================================================================*/
-static int cmd_i (Word *w, int align, char has_param, int param) {
- if (has_param && param==0)
- attr_pop(ATTR_ITALIC);
- else
- attr_push(ATTR_ITALIC,NULL);
- return FALSE;
+static int cmd_i (const struct OutputContext *oc, Word *w, int align, char has_param, int param) {
+ if (has_param && param==0)
+ attr_pop(ATTR_ITALIC, oc);
+ else
+ attr_push(ATTR_ITALIC,NULL, oc);
+ return FALSE;
}
/*========================================================================
@@ -2296,8 +2291,8 @@ static int cmd_i (Word *w, int align, ch
* Args: Word, paragraph align info, and numeric param if any.
* Returns: Flag, true only if rest of Words on line should be ignored.
*=======================================================================*/
-static int cmd_s (Word *w, int align, char has_param, int param) {
- return FALSE;
+static int cmd_s (const struct OutputContext *oc, Word *w, int align, char has_param, int param) {
+ return FALSE;
}
/*========================================================================
@@ -2307,12 +2302,14 @@ static int cmd_s (Word *w, int align, ch
* Returns: Flag, true only if rest of Words on line should be ignored.
*=======================================================================*/
-static int cmd_sect (Word *w, int align, char has_param, int param) {
- /* XX kludge */
- if (op->paragraph_begin) {
- if (safe_printf(0, op->paragraph_begin)) fprintf(stderr, TOO_MANY_ARGS, "paragraph_begin");
- }
- return FALSE;
+static int cmd_sect (const struct OutputContext *oc, Word *w, int align, char has_param, int param) {
+ const struct unRTFOutputDevice *device = &oc->conversion->options->device;
+
+ /* XX kludge */
+ if (oc->personality->paragraph_begin) {
+ if (safe_printf(device, 0, oc->personality->paragraph_begin)) fprintf(stderr, TOO_MANY_ARGS, "paragraph_begin");
+ }
+ return FALSE;
}
/*========================================================================
@@ -2322,14 +2319,16 @@ static int cmd_sect (Word *w, int align,
* Returns: Flag, true only if rest of Words on line should be ignored.
*=======================================================================*/
-static int cmd_shp (Word *w, int align, char has_param, int param) {
- if (op->comment_begin) {
- if (safe_printf(0, op->comment_begin)) fprintf(stderr, TOO_MANY_ARGS, "comment_begin");
- printf("Drawn Shape (ignored--not implemented yet)");
- if (safe_printf(0, op->comment_end)) fprintf(stderr, TOO_MANY_ARGS, "comment_end");
- }
+static int cmd_shp (const struct OutputContext *oc, Word *w, int align, char has_param, int param) {
+ const struct unRTFOutputDevice *device = &oc->conversion->options->device;
- return FALSE;
+ if (oc->personality->comment_begin) {
+ if (safe_printf(device, 0, oc->personality->comment_begin)) fprintf(stderr, TOO_MANY_ARGS, "comment_begin");
+ printf("Drawn Shape (ignored--not implemented yet)");
+ if (safe_printf(device, 0, oc->personality->comment_end)) fprintf(stderr, TOO_MANY_ARGS, "comment_end");
+ }
+
+ return FALSE;
}
/*========================================================================
@@ -2339,12 +2338,12 @@ static int cmd_shp (Word *w, int align,
* Returns: Flag, true only if rest of Words on line should be ignored.
*=======================================================================*/
-static int cmd_outl (Word *w, int align, char has_param, int param) {
- if (has_param && param==0)
- attr_pop(ATTR_OUTLINE);
- else
- attr_push(ATTR_OUTLINE,NULL);
- return FALSE;
+static int cmd_outl (const struct OutputContext *oc, Word *w, int align, char has_param, int param) {
+ if (has_param && param==0)
+ attr_pop(ATTR_OUTLINE, oc);
+ else
+ attr_push(ATTR_OUTLINE,NULL, oc);
+ return FALSE;
}
/*========================================================================
@@ -2354,12 +2353,12 @@ static int cmd_outl (Word *w, int align,
* Returns: Flag, true only if rest of Words on line should be ignored.
*=======================================================================*/
-static int cmd_ansi (Word *w, int align, char has_param, int param) {
- if (my_iconv_is_valid(desc))
- desc = my_iconv_close(desc);
+static int cmd_ansi (const struct OutputContext *oc, Word *w, int align, char has_param, int param) {
+ if (my_iconv_is_valid(oc->conversion->desc))
+ oc->conversion->desc = my_iconv_close(oc->conversion->desc);
- desc = my_iconv_open("UTF-8", "cp1252");
- return FALSE;
+ oc->conversion->desc = my_iconv_open(oc->conversion, "UTF-8", "cp1252");
+ return FALSE;
}
/*========================================================================
@@ -2369,18 +2368,18 @@ static int cmd_ansi (Word *w, int align,
* Returns: Flag, true only if rest of Words on line should be ignored.
*=======================================================================*/
-static int cmd_ansicpg (Word *w, int align, char has_param, int param)
+static int cmd_ansicpg (const struct OutputContext *oc, Word *w, int align, char has_param, int param)
{
- char tmp[8];
+ char tmp[8];
- snprintf(tmp, 8, "cp%d", param);
+ snprintf(tmp, 8, "cp%d", param);
- if (my_iconv_is_valid(desc))
- desc = my_iconv_close(desc);
+ if (my_iconv_is_valid(oc->conversion->desc))
+ oc->conversion->desc = my_iconv_close(oc->conversion->desc);
- desc = my_iconv_open("UTF-8", tmp);
+ oc->conversion->desc = my_iconv_open(oc->conversion, "UTF-8", tmp);
- return FALSE;
+ return FALSE;
}
/*========================================================================
@@ -2390,13 +2389,13 @@ static int cmd_ansicpg (Word *w, int ali
* Returns: Flag, true only if rest of Words on line should be ignored.
*=======================================================================*/
-static int cmd_pc (Word *w, int align, char has_param, int param) {
- if (my_iconv_is_valid(desc))
- desc = my_iconv_close(desc);
+static int cmd_pc (const struct OutputContext *oc, Word *w, int align, char has_param, int param) {
+ if (my_iconv_is_valid(oc->conversion->desc))
+ oc->conversion->desc = my_iconv_close(oc->conversion->desc);
- desc = my_iconv_open("UTF-8", "cp437");
+ oc->conversion->desc = my_iconv_open(oc->conversion, "UTF-8", "cp437");
- return FALSE;
+ return FALSE;
}
/*========================================================================
@@ -2406,14 +2405,14 @@ static int cmd_pc (Word *w, int align, c
* Returns: Flag, true only if rest of Words on line should be ignored.
*=======================================================================*/
-static int cmd_pca (Word *w, int align, char has_param, int param) {
+static int cmd_pca (const struct OutputContext *oc, Word *w, int align, char has_param, int param) {
- if (my_iconv_is_valid(desc))
- my_iconv_close(desc);
+ if (my_iconv_is_valid(oc->conversion->desc))
+ my_iconv_close(oc->conversion->desc);
- desc = my_iconv_open("UTF-8", "cp850");
+ oc->conversion->desc = my_iconv_open(oc->conversion, "UTF-8", "cp850");
- return FALSE;
+ return FALSE;
}
/*========================================================================
@@ -2423,13 +2422,13 @@ static int cmd_pca (Word *w, int align,
* Returns: Flag, true only if rest of Words on line should be ignored.
*=======================================================================*/
-static int cmd_mac (Word *w, int align, char has_param, int param) {
+static int cmd_mac (const struct OutputContext *oc, Word *w, int align, char has_param, int param) {
- if (my_iconv_is_valid(desc))
- my_iconv_close(desc);
+ if (my_iconv_is_valid(oc->conversion->desc))
+ my_iconv_close(oc->conversion->desc);
- desc = my_iconv_open("UTF-8", "mac");
- return FALSE;
+ oc->conversion->desc = my_iconv_open(oc->conversion, "UTF-8", "mac");
+ return FALSE;
}
/*========================================================================
@@ -2439,11 +2438,11 @@ static int cmd_mac (Word *w, int align,
* Returns: Flag, true only if rest of Words on line should be ignored.
*=======================================================================*/
-static int cmd_colortbl (Word *w, int align, char has_param, int param) {
- if (w->next) {
- process_color_table(w->next);
- }
- return TRUE;
+static int cmd_colortbl (const struct OutputContext *oc, Word *w, int align, char has_param, int param) {
+ if (w->next) {
+ process_color_table (oc, w->next);
+ }
+ return TRUE;
}
/*========================================================================
@@ -2453,11 +2452,11 @@ static int cmd_colortbl (Word *w, int al
* Returns: Flag, true only if rest of Words on line should be ignored.
*=======================================================================*/
-static int cmd_fonttbl (Word *w, int align, char has_param, int param) {
- if (w->next) {
- process_font_table(w->next);
- }
- return TRUE;
+static int cmd_fonttbl (const struct OutputContext *oc, Word *w, int align, char has_param, int param) {
+ if (w->next) {
+ process_font_table (oc, w->next);
+ }
+ return TRUE;
}
/*========================================================================
@@ -2467,8 +2466,8 @@ static int cmd_fonttbl (Word *w, int ali
* Returns: Flag, true only if rest of Words on line should be ignored.
*=======================================================================*/
-static int cmd_header (Word *w, int align, char has_param, int param) {
- return TRUE;
+static int cmd_header (const struct OutputContext *oc, Word *w, int align, char has_param, int param) {
+ return TRUE;
}
/*========================================================================
@@ -2478,8 +2477,8 @@ static int cmd_header (Word *w, int alig
* Returns: Flag, true only if rest of Words on line should be ignored.
*=======================================================================*/
-static int cmd_headerl (Word *w, int align, char has_param, int param) {
- return TRUE;
+static int cmd_headerl (const struct OutputContext *oc, Word *w, int align, char has_param, int param) {
+ return TRUE;
}
/*========================================================================
@@ -2489,8 +2488,8 @@ static int cmd_headerl (Word *w, int ali
* Returns: Flag, true only if rest of Words on line should be ignored.
*=======================================================================*/
-static int cmd_headerr (Word *w, int align, char has_param, int param) {
- return TRUE;
+static int cmd_headerr (const struct OutputContext *oc, Word *w, int align, char has_param, int param) {
+ return TRUE;
}
/*========================================================================
@@ -2500,8 +2499,8 @@ static int cmd_headerr (Word *w, int ali
* Returns: Flag, true only if rest of Words on line should be ignored.
*=======================================================================*/
-static int cmd_headerf (Word *w, int align, char has_param, int param) {
- return TRUE;
+static int cmd_headerf (const struct OutputContext *oc, Word *w, int align, char has_param, int param) {
+ return TRUE;
}
/*========================================================================
@@ -2511,8 +2510,8 @@ static int cmd_headerf (Word *w, int ali
* Returns: Flag, true only if rest of Words on line should be ignored.
*=======================================================================*/
-static int cmd_footer (Word *w, int align, char has_param, int param) {
- return TRUE;
+static int cmd_footer (const struct OutputContext *oc, Word *w, int align, char has_param, int param) {
+ return TRUE;
}
/*========================================================================
@@ -2522,8 +2521,8 @@ static int cmd_footer (Word *w, int alig
* Returns: Flag, true only if rest of Words on line should be ignored.
*=======================================================================*/
-static int cmd_footerl (Word *w, int align, char has_param, int param) {
- return TRUE;
+static int cmd_footerl (const struct OutputContext *oc, Word *w, int align, char has_param, int param) {
+ return TRUE;
}
/*========================================================================
@@ -2533,8 +2532,8 @@ static int cmd_footerl (Word *w, int ali
* Returns: Flag, true only if rest of Words on line should be ignored.
*=======================================================================*/
-static int cmd_footerr (Word *w, int align, char has_param, int param) {
- return TRUE;
+static int cmd_footerr (const struct OutputContext *oc, Word *w, int align, char has_param, int param) {
+ return TRUE;
}
/*========================================================================
@@ -2544,8 +2543,8 @@ static int cmd_footerr (Word *w, int ali
* Returns: Flag, true only if rest of Words on line should be ignored.
*=======================================================================*/
-static int cmd_footerf (Word *w, int align, char has_param, int param) {
- return TRUE;
+static int cmd_footerf (const struct OutputContext *oc, Word *w, int align, char has_param, int param) {
+ return TRUE;
}
/*========================================================================
@@ -2555,8 +2554,8 @@ static int cmd_footerf (Word *w, int ali
* Returns: Flag, true only if rest of Words on line should be ignored.
*=======================================================================*/
-static int cmd_ignore (Word *w, int align, char has_param, int param) {
- return TRUE;
+static int cmd_ignore (const struct OutputContext *oc, Word *w, int align, char has_param, int param) {
+ return TRUE;
}
/*========================================================================
@@ -2566,9 +2565,9 @@ static int cmd_ignore (Word *w, int alig
* Returns: Flag, true only if rest of Words on line should be ignored.
*=======================================================================*/
-static int cmd_info (Word *w, int align, char has_param, int param) {
- process_info_group (w->next);
- return TRUE;
+static int cmd_info (const struct OutputContext *oc, Word *w, int align, char has_param, int param) {
+ process_info_group (oc, w->next);
+ return TRUE;
}
/*========================================================================
@@ -2578,11 +2577,11 @@ static int cmd_info (Word *w, int align,
* Returns: Flag, true only if rest of Words on line should be ignored.
*=======================================================================*/
-static int cmd_pict (Word *w, int align, char has_param, int param) {
- within_picture=TRUE;
- picture_width = picture_height = 0;
- picture_type = PICT_WB;
- return FALSE;
+static int cmd_pict (const struct OutputContext *oc, Word *w, int align, char has_param, int param) {
+ oc->conversion->within_picture=TRUE;
+ oc->conversion->picture_width = oc->conversion->picture_height = 0;
+ oc->conversion->picture_type = PICT_WB;
+ return FALSE;
}
/*========================================================================
@@ -2592,8 +2591,8 @@ static int cmd_pict (Word *w, int align,
* Returns: Flag, true only if rest of Words on line should be ignored.
*=======================================================================*/
-static int cmd_bin (Word *w, int align, char has_param, int param) {
- return FALSE;
+static int cmd_bin (const struct OutputContext *oc, Word *w, int align, char has_param, int param) {
+ return FALSE;
}
@@ -2604,9 +2603,9 @@ static int cmd_bin (Word *w, int align,
* Returns: Flag, true only if rest of Words on line should be ignored.
*=======================================================================*/
-static int cmd_macpict (Word *w, int align, char has_param, int param) {
- picture_type = PICT_MAC;
- return FALSE;
+static int cmd_macpict (const struct OutputContext *oc, Word *w, int align, char has_param, int param) {
+ oc->conversion->picture_type = PICT_MAC;
+ return FALSE;
}
/*========================================================================
@@ -2616,9 +2615,9 @@ static int cmd_macpict (Word *w, int ali
* Returns: Flag, true only if rest of Words on line should be ignored.
*=======================================================================*/
-static int cmd_jpegblip (Word *w, int align, char has_param, int param) {
- picture_type = PICT_JPEG;
- return FALSE;
+static int cmd_jpegblip (const struct OutputContext *oc, Word *w, int align, char has_param, int param) {
+ oc->conversion->picture_type = PICT_JPEG;
+ return FALSE;
}
/*========================================================================
@@ -2628,9 +2627,9 @@ static int cmd_jpegblip (Word *w, int al
* Returns: Flag, true only if rest of Words on line should be ignored.
*=======================================================================*/
-static int cmd_pngblip (Word *w, int align, char has_param, int param) {
- picture_type = PICT_PNG;
- return FALSE;
+static int cmd_pngblip (const struct OutputContext *oc, Word *w, int align, char has_param, int param) {
+ oc->conversion->picture_type = PICT_PNG;
+ return FALSE;
}
/*========================================================================
@@ -2640,9 +2639,9 @@ static int cmd_pngblip (Word *w, int ali
* Returns: Flag, true only if rest of Words on line should be ignored.
*=======================================================================*/
-static int cmd_pnmetafile (Word *w, int align, char has_param, int param) {
- picture_type = PICT_PM;
- return FALSE;
+static int cmd_pnmetafile (const struct OutputContext *oc, Word *w, int align, char has_param, int param) {
+ oc->conversion->picture_type = PICT_PM;
+ return FALSE;
}
/*========================================================================
@@ -2652,23 +2651,23 @@ static int cmd_pnmetafile (Word *w, int
* Returns: Flag, true only if rest of Words on line should be ignored.
*=======================================================================*/
-static int cmd_wmetafile (Word *w, int align, char has_param, int param) {
- picture_type = PICT_WM;
- if (within_picture && has_param) {
- picture_wmetafile_type=param;
- switch(param) {
- case 1: picture_wmetafile_type_str="MM_TEXT"; break;
- case 2: picture_wmetafile_type_str="MM_LOMETRIC"; break;
- case 3: picture_wmetafile_type_str="MM_HIMETRIC"; break;
- case 4: picture_wmetafile_type_str="MM_LOENGLISH"; break;
- case 5: picture_wmetafile_type_str="MM_HIENGLISH"; break;
- case 6: picture_wmetafile_type_str="MM_TWIPS"; break;
- case 7: picture_wmetafile_type_str="MM_ISOTROPIC"; break;
- case 8: picture_wmetafile_type_str="MM_ANISOTROPIC"; break;
- default: picture_wmetafile_type_str="default:MM_TEXT"; break;
- }
- }
- return FALSE;
+static int cmd_wmetafile (const struct OutputContext *oc, Word *w, int align, char has_param, int param) {
+ oc->conversion->picture_type = PICT_WM;
+ if (oc->conversion->within_picture && has_param) {
+ oc->conversion->picture_wmetafile_type=param;
+ switch(param) {
+ case 1: oc->conversion->picture_wmetafile_type_str="MM_TEXT"; break;
+ case 2: oc->conversion->picture_wmetafile_type_str="MM_LOMETRIC"; break;
+ case 3: oc->conversion->picture_wmetafile_type_str="MM_HIMETRIC"; break;
+ case 4: oc->conversion->picture_wmetafile_type_str="MM_LOENGLISH"; break;
+ case 5: oc->conversion->picture_wmetafile_type_str="MM_HIENGLISH"; break;
+ case 6: oc->conversion->picture_wmetafile_type_str="MM_TWIPS"; break;
+ case 7: oc->conversion->picture_wmetafile_type_str="MM_ISOTROPIC"; break;
+ case 8: oc->conversion->picture_wmetafile_type_str="MM_ANISOTROPIC"; break;
+ default: oc->conversion->picture_wmetafile_type_str="default:MM_TEXT"; break;
+ }
+ }
+ return FALSE;
}
/*========================================================================
@@ -2678,10 +2677,10 @@ static int cmd_wmetafile (Word *w, int a
* Returns: Flag, true only if rest of Words on line should be ignored.
*=======================================================================*/
-static int cmd_wbmbitspixel (Word *w, int align, char has_param, int param) {
- if (within_picture && has_param)
- picture_bits_per_pixel = param;
- return FALSE;
+static int cmd_wbmbitspixel (const struct OutputContext *oc, Word *w, int align, char has_param, int param) {
+ if (oc->conversion->within_picture && has_param)
+ oc->conversion->picture_bits_per_pixel = param;
+ return FALSE;
}
/*========================================================================
@@ -2691,10 +2690,10 @@ static int cmd_wbmbitspixel (Word *w, in
* Returns: Flag, true only if rest of Words on line should be ignored.
*=======================================================================*/
-static int cmd_picw (Word *w, int align, char has_param, int param) {
- if (within_picture && has_param)
- picture_width = param;
- return FALSE;
+static int cmd_picw (const struct OutputContext *oc, Word *w, int align, char has_param, int param) {
+ if (oc->conversion->within_picture && has_param)
+ oc->conversion->picture_width = param;
+ return FALSE;
}
/*========================================================================
@@ -2704,10 +2703,10 @@ static int cmd_picw (Word *w, int align,
* Returns: Flag, true only if rest of Words on line should be ignored.
*=======================================================================*/
-static int cmd_pich (Word *w, int align, char has_param, int param) {
- if (within_picture && has_param)
- picture_height = param;
- return FALSE;
+static int cmd_pich (const struct OutputContext *oc, Word *w, int align, char has_param, int param) {
+ if (oc->conversion->within_picture && has_param)
+ oc->conversion->picture_height = param;
+ return FALSE;
}
@@ -2718,9 +2717,9 @@ static int cmd_pich (Word *w, int align,
* Returns: Flag, true only if rest of Words on line should be ignored.
*=======================================================================*/
-static int cmd_xe (Word *w, int align, char has_param, int param) {
- process_index_entry (w);
- return TRUE;
+static int cmd_xe (const struct OutputContext *oc, Word *w, int align, char has_param, int param) {
+ process_index_entry (oc, w);
+ return TRUE;
}
/*========================================================================
@@ -2730,9 +2729,9 @@ static int cmd_xe (Word *w, int align, c
* Returns: Flag, true only if rest of Words on line should be ignored.
*=======================================================================*/
-static int cmd_tc (Word *w, int align, char has_param, int param) {
- process_toc_entry (w, TRUE);
- return TRUE;
+static int cmd_tc (const struct OutputContext *oc, Word *w, int align, char has_param, int param) {
+ process_toc_entry (oc, w, TRUE);
+ return TRUE;
}
/*========================================================================
@@ -2742,282 +2741,282 @@ static int cmd_tc (Word *w, int align, c
* Returns: Flag, true only if rest of Words on line should be ignored.
*=======================================================================*/
-static int cmd_tcn (Word *w, int align, char has_param, int param) {
- process_toc_entry (w, FALSE);
- return TRUE;
+static int cmd_tcn (const struct OutputContext *oc, Word *w, int align, char has_param, int param) {
+ process_toc_entry (oc, w, FALSE);
+ return TRUE;
}
typedef struct {
- char *name;
- int (*func)(Word*, int, char, int);
- char *debug_print;
-} HashItem;
+ char *name;
+ int (*func)(const struct OutputContext *, Word*, int, char, int);
+ char *debug_print;
+} CmdHashItem;
/* All of the possible commands that RTF might recognize. */
-static HashItem hashArray_other [] = {
- { "*", cmd_ignore, NULL },
- { "-", cmd_optional_hyphen, "optional hyphen" },
- { "_", cmd_nonbreaking_hyphen, "nonbreaking hyphen" },
- { "~", cmd_nonbreaking_space, NULL },
- { NULL, NULL, NULL}
+static CmdHashItem hashArray_other [] = {
+ { "*", cmd_ignore, NULL },
+ { "-", cmd_optional_hyphen, "optional hyphen" },
+ { "_", cmd_nonbreaking_hyphen, "nonbreaking hyphen" },
+ { "~", cmd_nonbreaking_space, NULL },
+ { NULL, NULL, NULL}
};
-static HashItem hashArray_a [] = {
- { "ansi", &cmd_ansi , NULL },
- { "ansicpg", &cmd_ansicpg , NULL },
- { NULL, NULL, NULL}
+static CmdHashItem hashArray_a [] = {
+ { "ansi", &cmd_ansi , NULL },
+ { "ansicpg", &cmd_ansicpg , NULL },
+ { NULL, NULL, NULL}
};
-static HashItem hashArray_b [] = {
- { "b", &cmd_b, NULL },
- { "bullet", &cmd_bullet, NULL },
- { "bin", &cmd_bin, "picture is binary" },
+static CmdHashItem hashArray_b [] = {
+ { "b", &cmd_b, NULL },
+ { "bullet", &cmd_bullet, NULL },
+ { "bin", &cmd_bin, "picture is binary" },
#if 0
- { "bgbdiag", NULL, NULL },
- { "bgcross", NULL, NULL },
- { "bgdcross", NULL, NULL },
- { "bgfdiag", NULL, NULL },
- { "bghoriz", NULL, NULL },
- { "bgkbdiag", NULL, NULL },
- { "bgkcross", NULL, NULL },
- { "bgkdcross", NULL, NULL },
- { "bgkfdiag", NULL, NULL },
- { "bgkhoriz", NULL, NULL },
- { "bgkvert", NULL, NULL },
- { "bgvert", NULL, NULL },
- { "brdrcf", NULL, NULL },
- { "brdrdb", NULL, NULL },
- { "brdrdot", NULL, NULL },
- { "brdrhair", NULL, NULL },
- { "brdrs", NULL, NULL },
- { "brdrsh", NULL, NULL },
- { "brdrth", NULL, NULL },
- { "brdrw", NULL, NULL },
+ { "bgbdiag", NULL, NULL },
+ { "bgcross", NULL, NULL },
+ { "bgdcross", NULL, NULL },
+ { "bgfdiag", NULL, NULL },
+ { "bghoriz", NULL, NULL },
+ { "bgkbdiag", NULL, NULL },
+ { "bgkcross", NULL, NULL },
+ { "bgkdcross", NULL, NULL },
+ { "bgkfdiag", NULL, NULL },
+ { "bgkhoriz", NULL, NULL },
+ { "bgkvert", NULL, NULL },
+ { "bgvert", NULL, NULL },
+ { "brdrcf", NULL, NULL },
+ { "brdrdb", NULL, NULL },
+ { "brdrdot", NULL, NULL },
+ { "brdrhair", NULL, NULL },
+ { "brdrs", NULL, NULL },
+ { "brdrsh", NULL, NULL },
+ { "brdrth", NULL, NULL },
+ { "brdrw", NULL, NULL },
#endif
- { NULL, NULL, NULL}
+ { NULL, NULL, NULL}
};
-static HashItem hashArray_c [] = {
- { "caps", &cmd_caps, NULL },
- { "cb", cmd_cb, NULL },
- { "cf", cmd_cf, NULL },
- { "colortbl", &cmd_colortbl, "color table" },
- { "cols", NULL, "columns (not implemented)" },
- { "column", NULL, "column break (not implemented)" },
- { "cbpat", NULL, "Paragraph Shading" },
- { "cellx", NULL, "Table Definitions" },
- { "cfpat", NULL, NULL },
- { "cgrid", NULL, NULL },
- { "charrsid", NULL, "Revision Mark (ignore)" },
- { "clbgbcross", NULL, NULL },
- { "clbgbdiag", NULL, NULL },
- { "clbgbkbdiag", NULL, NULL },
- { "clbgbkcross", NULL, NULL },
- { "clbgbkdcross", NULL, NULL },
- { "clbgbkfdiag", NULL, NULL },
- { "clbgbkhor", NULL, NULL },
- { "clbgbkvert", NULL, NULL },
- { "clbgdcross", NULL, NULL },
- { "clbgfdiag", NULL, NULL },
- { "clbghoriz", NULL, NULL },
- { "clbgvert", NULL, NULL },
- { "clbrdrb", NULL, NULL },
- { "clbrdrl", NULL, NULL },
- { "clbrdrr", NULL, NULL },
- { "clbrdrt", NULL, NULL },
- { "clcbpat", NULL, NULL },
- { "clcfpat", NULL, NULL },
- { "clmgf", NULL, NULL },
- { "clmrg", NULL, NULL },
- { "clshdng", NULL, NULL },
- { NULL, NULL, NULL}
+static CmdHashItem hashArray_c [] = {
+ { "caps", &cmd_caps, NULL },
+ { "cb", cmd_cb, NULL },
+ { "cf", cmd_cf, NULL },
+ { "colortbl", &cmd_colortbl, "color table" },
+ { "cols", NULL, "columns (not implemented)" },
+ { "column", NULL, "column break (not implemented)" },
+ { "cbpat", NULL, "Paragraph Shading" },
+ { "cellx", NULL, "Table Definitions" },
+ { "cfpat", NULL, NULL },
+ { "cgrid", NULL, NULL },
+ { "charrsid", NULL, "Revision Mark (ignore)" },
+ { "clbgbcross", NULL, NULL },
+ { "clbgbdiag", NULL, NULL },
+ { "clbgbkbdiag", NULL, NULL },
+ { "clbgbkcross", NULL, NULL },
+ { "clbgbkdcross", NULL, NULL },
+ { "clbgbkfdiag", NULL, NULL },
+ { "clbgbkhor", NULL, NULL },
+ { "clbgbkvert", NULL, NULL },
+ { "clbgdcross", NULL, NULL },
+ { "clbgfdiag", NULL, NULL },
+ { "clbghoriz", NULL, NULL },
+ { "clbgvert", NULL, NULL },
+ { "clbrdrb", NULL, NULL },
+ { "clbrdrl", NULL, NULL },
+ { "clbrdrr", NULL, NULL },
+ { "clbrdrt", NULL, NULL },
+ { "clcbpat", NULL, NULL },
+ { "clcfpat", NULL, NULL },
+ { "clmgf", NULL, NULL },
+ { "clmrg", NULL, NULL },
+ { "clshdng", NULL, NULL },
+ { NULL, NULL, NULL}
};
-static HashItem hashArray_d [] = {
- { "deff", NULL, "Default Font" },
- { "dn", &cmd_dn, NULL },
+static CmdHashItem hashArray_d [] = {
+ { "deff", NULL, "Default Font" },
+ { "dn", &cmd_dn, NULL },
#if 0
- { "dibitmap", NULL, NULL },
+ { "dibitmap", NULL, NULL },
#endif
- { NULL, NULL, NULL}
+ { NULL, NULL, NULL}
};
-static HashItem hashArray_e [] = {
- { "emdash", cmd_emdash, NULL },
- { "endash", cmd_endash, NULL },
- { "embo", &cmd_emboss, NULL },
- { "expand", &cmd_expand, NULL },
- { "expnd", &cmd_expand, NULL },
- { NULL, NULL, NULL}
+static CmdHashItem hashArray_e [] = {
+ { "emdash", cmd_emdash, NULL },
+ { "endash", cmd_endash, NULL },
+ { "embo", &cmd_emboss, NULL },
+ { "expand", &cmd_expand, NULL },
+ { "expnd", &cmd_expand, NULL },
+ { NULL, NULL, NULL}
};
-static HashItem hashArray_f [] = {
- { "f", cmd_f, NULL },
- { "fdecor", cmd_fdecor, NULL },
- { "fmodern", cmd_fmodern, NULL },
- { "fnil", cmd_fnil, NULL },
- { "fonttbl", cmd_fonttbl, "font table" },
- { "froman", cmd_froman, NULL },
- { "fs", cmd_fs, NULL },
- { "fscript", cmd_fscript, NULL },
- { "fswiss", cmd_fswiss, NULL },
- { "ftech", cmd_ftech, NULL },
- { "field", cmd_field, NULL },
- { "footer", cmd_footer, NULL },
- { "footerf", cmd_footerf, NULL },
- { "footerl", cmd_footerl, NULL },
- { "footerr", cmd_footerr, NULL },
- { NULL, NULL, NULL}
+static CmdHashItem hashArray_f [] = {
+ { "f", cmd_f, NULL },
+ { "fdecor", cmd_fdecor, NULL },
+ { "fmodern", cmd_fmodern, NULL },
+ { "fnil", cmd_fnil, NULL },
+ { "fonttbl", cmd_fonttbl, "font table" },
+ { "froman", cmd_froman, NULL },
+ { "fs", cmd_fs, NULL },
+ { "fscript", cmd_fscript, NULL },
+ { "fswiss", cmd_fswiss, NULL },
+ { "ftech", cmd_ftech, NULL },
+ { "field", cmd_field, NULL },
+ { "footer", cmd_footer, NULL },
+ { "footerf", cmd_footerf, NULL },
+ { "footerl", cmd_footerl, NULL },
+ { "footerr", cmd_footerr, NULL },
+ { NULL, NULL, NULL}
};
-static HashItem hashArray_h [] = {
- { "highlight", &cmd_highlight, NULL },
- { "header", cmd_header, NULL },
- { "headerf", cmd_headerf, NULL },
- { "headerl", cmd_headerl, NULL },
- { "headerr", cmd_headerr, NULL },
- { "hl", cmd_ignore, "hyperlink within object" },
- { NULL, NULL, NULL}
+static CmdHashItem hashArray_h [] = {
+ { "highlight", &cmd_highlight, NULL },
+ { "header", cmd_header, NULL },
+ { "headerf", cmd_headerf, NULL },
+ { "headerl", cmd_headerl, NULL },
+ { "headerr", cmd_headerr, NULL },
+ { "hl", cmd_ignore, "hyperlink within object" },
+ { NULL, NULL, NULL}
};
-static HashItem hashArray_i [] = {
- { "i", &cmd_i, NULL },
- { "info", &cmd_info, NULL },
- { "insrsid", NULL, "Revision Mark (ignore)" },
- { "intbl", &cmd_intbl, NULL },
- { "impr", &cmd_engrave, NULL },
- { NULL, NULL, NULL}
+static CmdHashItem hashArray_i [] = {
+ { "i", &cmd_i, NULL },
+ { "info", &cmd_info, NULL },
+ { "insrsid", NULL, "Revision Mark (ignore)" },
+ { "intbl", &cmd_intbl, NULL },
+ { "impr", &cmd_engrave, NULL },
+ { NULL, NULL, NULL}
};
-static HashItem hashArray_j [] = {
- { "jpegblip", &cmd_jpegblip, NULL },
- { NULL, NULL, NULL}
+static CmdHashItem hashArray_j [] = {
+ { "jpegblip", &cmd_jpegblip, NULL },
+ { NULL, NULL, NULL}
};
-static HashItem hashArray_l [] = {
- { "ldblquote", &cmd_ldblquote, NULL },
- { "line", &cmd_line, NULL },
- { "lquote", &cmd_lquote, NULL },
- { NULL, NULL, NULL}
+static CmdHashItem hashArray_l [] = {
+ { "ldblquote", &cmd_ldblquote, NULL },
+ { "line", &cmd_line, NULL },
+ { "lquote", &cmd_lquote, NULL },
+ { NULL, NULL, NULL}
};
-static HashItem hashArray_m [] = {
- { "mac", &cmd_mac , NULL },
- { "macpict", &cmd_macpict, NULL },
- { NULL, NULL, NULL}
+static CmdHashItem hashArray_m [] = {
+ { "mac", &cmd_mac , NULL },
+ { "macpict", &cmd_macpict, NULL },
+ { NULL, NULL, NULL}
};
-static HashItem hashArray_n [] = {
- { "nosupersub", &cmd_nosupersub, NULL },
- { NULL, NULL, NULL}
+static CmdHashItem hashArray_n [] = {
+ { "nosupersub", &cmd_nosupersub, NULL },
+ { NULL, NULL, NULL}
};
-static HashItem hashArray_o [] = {
- { "outl", &cmd_outl, NULL },
- { NULL, NULL, NULL}
+static CmdHashItem hashArray_o [] = {
+ { "outl", &cmd_outl, NULL },
+ { NULL, NULL, NULL}
};
-static HashItem hashArray_p [] = {
- { "page", &cmd_page, NULL },
- { "par", &cmd_par, NULL },
- { "pc", &cmd_pc , NULL },
- { "pca", &cmd_pca , NULL },
- { "pich", &cmd_pich, NULL },
- { "pict", &cmd_pict, "picture" },
- { "picw", &cmd_picw, NULL },
- { "plain", &cmd_plain, NULL },
- { "pngblip", &cmd_pngblip, NULL },
- { "pnmetafile", &cmd_pnmetafile, NULL },
+static CmdHashItem hashArray_p [] = {
+ { "page", &cmd_page, NULL },
+ { "par", &cmd_par, NULL },
+ { "pc", &cmd_pc , NULL },
+ { "pca", &cmd_pca , NULL },
+ { "pich", &cmd_pich, NULL },
+ { "pict", &cmd_pict, "picture" },
+ { "picw", &cmd_picw, NULL },
+ { "plain", &cmd_plain, NULL },
+ { "pngblip", &cmd_pngblip, NULL },
+ { "pnmetafile", &cmd_pnmetafile, NULL },
#if 0
- { "piccropb", NULL, NULL },
- { "piccropl", NULL, NULL },
- { "piccropr", NULL, NULL },
- { "piccropt", NULL, NULL },
- { "pichgoal", NULL, NULL },
- { "pichgoal", NULL, NULL },
- { "picscaled", NULL, NULL },
- { "picscalex", NULL, NULL },
- { "picwgoal", NULL, NULL },
+ { "piccropb", NULL, NULL },
+ { "piccropl", NULL, NULL },
+ { "piccropr", NULL, NULL },
+ { "piccropt", NULL, NULL },
+ { "pichgoal", NULL, NULL },
+ { "pichgoal", NULL, NULL },
+ { "picscaled", NULL, NULL },
+ { "picscalex", NULL, NULL },
+ { "picwgoal", NULL, NULL },
#endif
- { NULL, NULL, NULL}
+ { NULL, NULL, NULL}
};
-static HashItem hashArray_r [] = {
- { "rdblquote", &cmd_rdblquote, NULL },
- { "rquote", &cmd_rquote, NULL },
- { "rtf", &cmd_rtf, NULL },
- { NULL, NULL, NULL}
+static CmdHashItem hashArray_r [] = {
+ { "rdblquote", &cmd_rdblquote, NULL },
+ { "rquote", &cmd_rquote, NULL },
+ { "rtf", &cmd_rtf, NULL },
+ { NULL, NULL, NULL}
};
-static HashItem hashArray_s [] = {
- { "s", cmd_s, "style" },
- { "sect", &cmd_sect, "section break"},
- { "scaps", &cmd_scaps, NULL },
- { "super", &cmd_super, NULL },
- { "sub", &cmd_sub, NULL },
- { "shad", &cmd_shad, NULL },
- { "strike", &cmd_strike, NULL },
- { "striked", &cmd_striked, NULL },
- { "strikedl", &cmd_strikedl, NULL },
- { "stylesheet", &cmd_ignore, "style sheet" },
- { "shp", cmd_shp, "drawn shape" },
+static CmdHashItem hashArray_s [] = {
+ { "s", cmd_s, "style" },
+ { "sect", &cmd_sect, "section break"},
+ { "scaps", &cmd_scaps, NULL },
+ { "super", &cmd_super, NULL },
+ { "sub", &cmd_sub, NULL },
+ { "shad", &cmd_shad, NULL },
+ { "strike", &cmd_strike, NULL },
+ { "striked", &cmd_striked, NULL },
+ { "strikedl", &cmd_strikedl, NULL },
+ { "stylesheet", &cmd_ignore, "style sheet" },
+ { "shp", cmd_shp, "drawn shape" },
#if 0
- { "shading", NULL, NULL },
+ { "shading", NULL, NULL },
#endif
- { NULL, NULL, NULL}
+ { NULL, NULL, NULL}
};
-static HashItem hashArray_t [] = {
- { "tab", &cmd_tab, NULL },
- { "tc", cmd_tc, "TOC entry" },
- { "tcn", cmd_tcn, "TOC entry" },
- { NULL, NULL, NULL}
+static CmdHashItem hashArray_t [] = {
+ { "tab", &cmd_tab, NULL },
+ { "tc", cmd_tc, "TOC entry" },
+ { "tcn", cmd_tcn, "TOC entry" },
+ { NULL, NULL, NULL}
};
-static HashItem hashArray_u [] = {
- { "u", &cmd_u, NULL },
- { "ul", &cmd_ul, NULL },
- { "up", &cmd_up, NULL },
- { "uld", &cmd_uld, NULL },
- { "uldash", &cmd_uldash, NULL },
- { "uldashd", &cmd_uldashd, NULL },
- { "uldashdd", &cmd_uldashdd, NULL },
- { "uldb", &cmd_uldb, NULL },
- { "ulnone", &cmd_ulnone, NULL },
- { "ulth", &cmd_ulth, NULL },
- { "ulthd", &cmd_ulthd, NULL },
- { "ulthdash", &cmd_ulthdash, NULL },
- { "ulw", &cmd_ulw, NULL },
- { "ulwave", &cmd_ulwave, NULL },
- { NULL, NULL, NULL}
+static CmdHashItem hashArray_u [] = {
+ { "u", &cmd_u, NULL },
+ { "ul", &cmd_ul, NULL },
+ { "up", &cmd_up, NULL },
+ { "uld", &cmd_uld, NULL },
+ { "uldash", &cmd_uldash, NULL },
+ { "uldashd", &cmd_uldashd, NULL },
+ { "uldashdd", &cmd_uldashdd, NULL },
+ { "uldb", &cmd_uldb, NULL },
+ { "ulnone", &cmd_ulnone, NULL },
+ { "ulth", &cmd_ulth, NULL },
+ { "ulthd", &cmd_ulthd, NULL },
+ { "ulthdash", &cmd_ulthdash, NULL },
+ { "ulw", &cmd_ulw, NULL },
+ { "ulwave", &cmd_ulwave, NULL },
+ { NULL, NULL, NULL}
};
-static HashItem hashArray_v [] = {
- { "v", NULL, "Hidden Text" },
- { NULL, NULL, NULL }
+static CmdHashItem hashArray_v [] = {
+ { "v", NULL, "Hidden Text" },
+ { NULL, NULL, NULL }
};
-static HashItem hashArray_w [] = {
- { "wbmbitspixel", &cmd_wbmbitspixel, NULL },
- { "wmetafile", &cmd_wmetafile, NULL },
- { NULL, NULL, NULL}
+static CmdHashItem hashArray_w [] = {
+ { "wbmbitspixel", &cmd_wbmbitspixel, NULL },
+ { "wmetafile", &cmd_wmetafile, NULL },
+ { NULL, NULL, NULL}
};
-static HashItem hashArray_x [] = {
- { "xe", cmd_xe, "index entry" },
- { NULL, NULL, NULL}
+static CmdHashItem hashArray_x [] = {
+ { "xe", cmd_xe, "index entry" },
+ { NULL, NULL, NULL}
};
-static HashItem *hash [26] = {
- hashArray_a,
- hashArray_b,
- hashArray_c,
- hashArray_d,
- hashArray_e,
- hashArray_f,
- NULL,
- hashArray_h,
- hashArray_i,
- hashArray_j,
- NULL,
- hashArray_l,
- hashArray_m,
- hashArray_n,
- hashArray_o,
- hashArray_p,
- NULL,
- hashArray_r,
- hashArray_s,
- hashArray_t,
- hashArray_u,
- hashArray_v,
- hashArray_w,
- hashArray_x,
- NULL, NULL
+static CmdHashItem *hash [26] = {
+ hashArray_a,
+ hashArray_b,
+ hashArray_c,
+ hashArray_d,
+ hashArray_e,
+ hashArray_f,
+ NULL,
+ hashArray_h,
+ hashArray_i,
+ hashArray_j,
+ NULL,
+ hashArray_l,
+ hashArray_m,
+ hashArray_n,
+ hashArray_o,
+ hashArray_p,
+ NULL,
+ hashArray_r,
+ hashArray_s,
+ hashArray_t,
+ hashArray_u,
+ hashArray_v,
+ hashArray_w,
+ hashArray_x,
+ NULL, NULL
};
@@ -3038,53 +3037,56 @@ static HashItem *hash [26] = {
*=======================================================================*/
void
-print_with_special_exprs (char *s) {
- int ch;
- int state;
+print_with_special_exprs (const struct OutputContext *oc, char *s) {
+ int ch;
+ int state;
+ const struct unRTFOutputDevice *device = &oc->conversion->options->device;
-enum { SMALL=0, BIG=1 };
+ enum { SMALL=0, BIG=1 };
- CHECK_PARAM_NOT_NULL(s);
+ CHECK_PARAM_NOT_NULL(s);
- state=SMALL; /* Pacify gcc, st001906 - 0.19.6 */
- if (simulate_smallcaps) {
- if (*s >= 'a' && *s <= 'z') {
- state=SMALL;
- if (safe_printf(0, op->smaller_begin)) fprintf(stderr, TOO_MANY_ARGS, "smaller_begin");
- }
- else
- state=BIG;
- }
+ state=SMALL; /* Pacify gcc, st001906 - 0.19.6 */
+ if (oc->conversion->simulate_smallcaps) {
+ if (*s >= 'a' && *s <= 'z') {
+ state=SMALL;
+ if (safe_printf(device, 0, oc->personality->smaller_begin)) fprintf(stderr, TOO_MANY_ARGS, "smaller_begin");
+ }
+ else
+ state=BIG;
+ }
- while ((ch=*s)) {
- char *post_trans = NULL;
+ while ((ch=*s)) {
+ char *post_trans = NULL;
- if (simulate_allcaps || simulate_smallcaps)
- ch = toupper (ch);
+ if (oc->conversion->simulate_allcaps || oc->conversion->simulate_smallcaps)
+ ch = toupper (ch);
- if (ch >= 0x20 && ch < 0x80) {
- post_trans = op_translate_char (op, desc, ch);
- if(post_trans)
- printf("%s",post_trans);
- }
+ if (ch >= 0x20 && ch < 0x80) {
+ post_trans = op_translate_char (oc->conversion, oc->personality, ch);
+ if(post_trans) {
+ safe_printf(device, 0, post_trans);
+ free(post_trans);
+ }
+ }
- s++;
+ s++;
- if (simulate_smallcaps) {
- ch = *s;
- if (ch >= 'a' && ch <= 'z') {
- if (state==BIG)
- if (safe_printf(0, op->smaller_begin)) fprintf(stderr, TOO_MANY_ARGS, "smaller_begin");
- state=SMALL;
- }
- else
- {
- if (state==SMALL)
- if (safe_printf(0, op->smaller_end)) fprintf(stderr, TOO_MANY_ARGS, "smaller_end");
- state=BIG;
- }
- }
- }
+ if (oc->conversion->simulate_smallcaps) {
+ ch = *s;
+ if (ch >= 'a' && ch <= 'z') {
+ if (state==BIG)
+ if (safe_printf(device, 0, oc->personality->smaller_begin)) fprintf(stderr, TOO_MANY_ARGS, "smaller_begin");
+ state=SMALL;
+ }
+ else
+ {
+ if (state==SMALL)
+ if (safe_printf(device, 0, oc->personality->smaller_end)) fprintf(stderr, TOO_MANY_ARGS, "smaller_end");
+ state=BIG;
+ }
+ }
+ }
}
@@ -3097,16 +3099,18 @@ enum { SMALL=0, BIG=1 };
*=======================================================================*/
static void
-begin_table()
+begin_table(const struct OutputContext *oc)
{
- within_table=TRUE;
- have_printed_row_begin = FALSE;
- have_printed_cell_begin = FALSE;
- have_printed_row_end = FALSE;
- have_printed_cell_end = FALSE;
- attrstack_push();
- starting_body();
- if (safe_printf(0, op->table_begin)) fprintf(stderr, TOO_MANY_ARGS, "table_begin");
+ const struct unRTFOutputDevice *device = &oc->conversion->options->device;
+
+ oc->conversion->within_table=TRUE;
+ oc->conversion->have_printed_row_begin = FALSE;
+ oc->conversion->have_printed_cell_begin = FALSE;
+ oc->conversion->have_printed_row_end = FALSE;
+ oc->conversion->have_printed_cell_end = FALSE;
+ attrstack_push(oc->conversion);
+ starting_body(oc);
+ if (safe_printf(device, 0, oc->personality->table_begin)) fprintf(stderr, TOO_MANY_ARGS, "table_begin");
}
@@ -3119,23 +3123,25 @@ begin_table()
*=======================================================================*/
void
-end_table ()
+end_table (const struct OutputContext *oc)
{
- if (within_table) {
- if (!have_printed_cell_end) {
- attr_pop_dump();
- if (safe_printf(0, op->table_cell_end)) fprintf(stderr, TOO_MANY_ARGS, "table_cell_end");
- }
- if (!have_printed_row_end) {
- if (safe_printf(0, op->table_row_end)) fprintf(stderr, TOO_MANY_ARGS, "table_row_end");
- }
- if (safe_printf(0, op->table_end)) fprintf(stderr, TOO_MANY_ARGS, "table_end");
- within_table=FALSE;
- have_printed_row_begin = FALSE;
- have_printed_cell_begin = FALSE;
- have_printed_row_end = FALSE;
- have_printed_cell_end = FALSE;
- }
+ const struct unRTFOutputDevice *device = &oc->conversion->options->device;
+
+ if (oc->conversion->within_table) {
+ if (!oc->conversion->have_printed_cell_end) {
+ attr_pop_dump();
+ if (safe_printf(device, 0, oc->personality->table_cell_end)) fprintf(stderr, TOO_MANY_ARGS, "table_cell_end");
+ }
+ if (!oc->conversion->have_printed_row_end) {
+ if (safe_printf(device, 0, oc->personality->table_row_end)) fprintf(stderr, TOO_MANY_ARGS, "table_row_end");
+ }
+ if (safe_printf(device, 0, oc->personality->table_end)) fprintf(stderr, TOO_MANY_ARGS, "table_end");
+ oc->conversion->within_table=FALSE;
+ oc->conversion->have_printed_row_begin = FALSE;
+ oc->conversion->have_printed_cell_begin = FALSE;
+ oc->conversion->have_printed_row_end = FALSE;
+ oc->conversion->have_printed_cell_end = FALSE;
+ }
}
@@ -3148,21 +3154,23 @@ end_table ()
*=======================================================================*/
void
-starting_text() {
- if (within_table) {
- if (!have_printed_row_begin) {
- if (safe_printf(0, op->table_row_begin)) fprintf(stderr, TOO_MANY_ARGS, "table_row_begin");
- have_printed_row_begin=TRUE;
- have_printed_row_end=FALSE;
- have_printed_cell_begin=FALSE;
- }
- if (!have_printed_cell_begin) {
- if (safe_printf(0, op->table_cell_begin)) fprintf(stderr, TOO_MANY_ARGS, "table_cell_begin");
- attrstack_express_all();
- have_printed_cell_begin=TRUE;
- have_printed_cell_end=FALSE;
- }
- }
+starting_text(const struct OutputContext *oc) {
+ const struct unRTFOutputDevice *device = &oc->conversion->options->device;
+
+ if (oc->conversion->within_table) {
+ if (!oc->conversion->have_printed_row_begin) {
+ if (safe_printf(device, 0, oc->personality->table_row_begin)) fprintf(stderr, TOO_MANY_ARGS, "table_row_begin");
+ oc->conversion->have_printed_row_begin=TRUE;
+ oc->conversion->have_printed_row_end=FALSE;
+ oc->conversion->have_printed_cell_begin=FALSE;
+ }
+ if (!oc->conversion->have_printed_cell_begin) {
+ if (safe_printf(device, 0, oc->personality->table_cell_begin)) fprintf(stderr, TOO_MANY_ARGS, "table_cell_begin");
+ attrstack_express_all();
+ oc->conversion->have_printed_cell_begin=TRUE;
+ oc->conversion->have_printed_cell_end=FALSE;
+ }
+ }
}
@@ -3176,25 +3184,27 @@ starting_text() {
*=======================================================================*/
static void
-starting_paragraph_align (int align)
+starting_paragraph_align (const struct OutputContext *oc, int align)
{
- if (within_header && align != ALIGN_LEFT)
- starting_body();
+ const struct unRTFOutputDevice *device = &oc->conversion->options->device;
- switch (align)
- {
- case ALIGN_CENTER:
- if (safe_printf(0, op->center_begin)) fprintf(stderr, TOO_MANY_ARGS, "center_begin");
- break;
- case ALIGN_LEFT:
- break;
- case ALIGN_RIGHT:
- if (safe_printf(0, op->align_right_begin)) fprintf(stderr, TOO_MANY_ARGS, "align_right_begin");
- break;
- case ALIGN_JUSTIFY:
- if (safe_printf(0, op->justify_begin)) fprintf(stderr, TOO_MANY_ARGS, "justify_begin"); /* But this is correct */
- break;
- }
+ if (oc->conversion->within_header && align != ALIGN_LEFT)
+ starting_body(oc);
+
+ switch (align)
+ {
+ case ALIGN_CENTER:
+ if (safe_printf(device, 0, oc->personality->center_begin)) fprintf(stderr, TOO_MANY_ARGS, "center_begin");
+ break;
+ case ALIGN_LEFT:
+ break;
+ case ALIGN_RIGHT:
+ if (safe_printf(device, 0, oc->personality->align_right_begin)) fprintf(stderr, TOO_MANY_ARGS, "align_right_begin");
+ break;
+ case ALIGN_JUSTIFY:
+ if (safe_printf(device, 0, oc->personality->justify_begin)) fprintf(stderr, TOO_MANY_ARGS, "justify_begin"); /* But this is correct */
+ break;
+ }
}
@@ -3207,21 +3217,23 @@ starting_paragraph_align (int align)
*=======================================================================*/
static void
-ending_paragraph_align (int align)
+ending_paragraph_align (const struct OutputContext *oc, int align)
{
- switch (align) {
- case ALIGN_CENTER:
- if (safe_printf(0, op->center_end)) fprintf(stderr, TOO_MANY_ARGS, "center_end");
- break;
- case ALIGN_LEFT:
- break;
- case ALIGN_RIGHT:
- if (safe_printf(0, op->align_right_end)) fprintf(stderr, TOO_MANY_ARGS, "align_right_end");
- break;
- case ALIGN_JUSTIFY:
- if (safe_printf(0, op->justify_end)) fprintf(stderr, TOO_MANY_ARGS, "justify_end");
- break;
- }
+ const struct unRTFOutputDevice *device = &oc->conversion->options->device;
+
+ switch (align) {
+ case ALIGN_CENTER:
+ if (safe_printf(device, 0, oc->personality->center_end)) fprintf(stderr, TOO_MANY_ARGS, "center_end");
+ break;
+ case ALIGN_LEFT:
+ break;
+ case ALIGN_RIGHT:
+ if (safe_printf(device, 0, oc->personality->align_right_end)) fprintf(stderr, TOO_MANY_ARGS, "align_right_end");
+ break;
+ case ALIGN_JUSTIFY:
+ if (safe_printf(device, 0, oc->personality->justify_end)) fprintf(stderr, TOO_MANY_ARGS, "justify_end");
+ break;
+ }
}
@@ -3234,411 +3246,411 @@ ending_paragraph_align (int align)
*=======================================================================*/
static void
-word_print_core (Word *w)
+word_print_core (const struct OutputContext *oc, Word *w)
{
- char *s;
- FILE *pictfile=NULL;
- int is_cell_group=FALSE;
- int paragraph_begined=FALSE;
- int paragraph_align=ALIGN_LEFT;
+ char *s;
+ FILE *pictfile=NULL;
+ int is_cell_group=FALSE;
+ int paragraph_begined=FALSE;
+ int paragraph_align=ALIGN_LEFT;
+ const struct unRTFOutputDevice *device = &oc->conversion->options->device;
- CHECK_PARAM_NOT_NULL(w);
+ CHECK_PARAM_NOT_NULL(w);
- if (!coming_pars_that_are_tabular && within_table) {
- end_table();
- }
- else if (coming_pars_that_are_tabular && !within_table) {
- begin_table();
- }
+ if (!oc->conversion->coming_pars_that_are_tabular && oc->conversion->within_table) {
+ end_table(oc);
+ }
+ else if (oc->conversion->coming_pars_that_are_tabular && !oc->conversion->within_table) {
+ begin_table(oc);
+ }
- /* Mark our place in the stack */
- attrstack_push();
+ /* Mark our place in the stack */
+ attrstack_push(oc->conversion);
- while (w) {
+ while (w) {
- s = word_string (w);
+ s = word_string (oc->conversion, w);
- if (s) {
+ if (s) {
- /*--Ignore whitespace in header--------------------*/
- if (*s==' ' && within_header) {
- /* no op */
- }
- else
- /*--Handle word -----------------------------------*/
- if (s[0] != '\\')
- {
- starting_body();
- starting_text();
+ /*--Ignore whitespace in header--------------------*/
+ if (*s==' ' && oc->conversion->within_header) {
+ /* no op */
+ }
+ else
+ /*--Handle word -----------------------------------*/
+ if (s[0] != '\\')
+ {
+ starting_body(oc);
+ starting_text(oc);
- if (!paragraph_begined) {
- starting_paragraph_align (paragraph_align);
- paragraph_begined=TRUE;
- }
+ if (!paragraph_begined) {
+ starting_paragraph_align (oc, paragraph_align);
+ paragraph_begined=TRUE;
+ }
- /*----------------------------------------*/
- if (within_picture) {
- starting_body();
- if (!pictfile && !nopict_mode) {
- char *ext=NULL;
- switch (picture_type) {
- case PICT_WB: ext="bmp"; break;
- case PICT_WM: ext="wmf"; break;
- case PICT_MAC: ext="pict"; break;
- case PICT_JPEG: ext="jpg"; break;
- case PICT_PNG: ext="png"; break;
- case PICT_DI: ext="dib"; break; /* Device independent bitmap=??? */
- case PICT_PM: ext="pmm"; break; /* OS/2 metafile=??? */
- }
- sprintf(picture_path, "pict%03d.%s",
- picture_file_number++,ext);
- pictfile=fopen(picture_path,"w");
- }
+ /*----------------------------------------*/
+ if (oc->conversion->within_picture) {
+ starting_body(oc);
+ if (!pictfile && !oc->conversion->options->nopict_mode) {
+ char *ext=NULL;
+ switch (oc->conversion->picture_type) {
+ case PICT_WB: ext="bmp"; break;
+ case PICT_WM: ext="wmf"; break;
+ case PICT_MAC: ext="pict"; break;
+ case PICT_JPEG: ext="jpg"; break;
+ case PICT_PNG: ext="png"; break;
+ case PICT_DI: ext="dib"; break; /* Device independent bitmap=??? */
+ case PICT_PM: ext="pmm"; break; /* OS/2 metafile=??? */
+ }
+ sprintf(oc->conversion->picture_path, "pict%03d.%s",
+ oc->conversion->picture_file_number++,ext);
+ pictfile=fopen(oc->conversion->picture_path,"w");
+ }
- if (s[0]!=' ') {
- char *s2;
- if (safe_printf(0, op->comment_begin)) fprintf(stderr, TOO_MANY_ARGS, "comment_begin");
- printf("picture data found, ");
- if (picture_wmetafile_type_str) {
- printf("WMF type is %s, ",
- picture_wmetafile_type_str);
- }
- printf("picture dimensions are %d by %d, depth %d",
- picture_width, picture_height, picture_bits_per_pixel);
- if (safe_printf(0, op->comment_end)) fprintf(stderr, TOO_MANY_ARGS, "comment_end");
- if (picture_width && picture_height && picture_bits_per_pixel) {
- s2=s;
- while (*s2) {
- unsigned int tmp,value;
- tmp=tolower(*s2++);
- if (tmp>'9') tmp-=('a'-10);
- else tmp-='0';
- value=16*tmp;
- tmp=tolower(*s2++);
- if (tmp>'9') tmp-=('a'-10);
- else tmp-='0';
- value+=tmp;
- if (pictfile) {
- fprintf(pictfile,"%c", value);
- }
- }
- }
- }
- }
- /*----------------------------------------*/
- else {
- total_chars_this_line += strlen(s);
+ if (s[0]!=' ') {
+ char *s2;
+ if (safe_printf(device, 0, oc->personality->comment_begin)) fprintf(stderr, TOO_MANY_ARGS, "comment_begin");
+ printf("picture data found, ");
+ if (oc->conversion->picture_wmetafile_type_str) {
+ printf("WMF type is %s, ",
+ oc->conversion->picture_wmetafile_type_str);
+ }
+ printf("picture dimensions are %d by %d, depth %d",
+ oc->conversion->picture_width, oc->conversion->picture_height, oc->conversion->picture_bits_per_pixel);
+ if (safe_printf(device, 0, oc->personality->comment_end)) fprintf(stderr, TOO_MANY_ARGS, "comment_end");
+ if (oc->conversion->picture_width && oc->conversion->picture_height && oc->conversion->picture_bits_per_pixel) {
+ s2=s;
+ while (*s2) {
+ unsigned int tmp,value;
+ tmp=tolower(*s2++);
+ if (tmp>'9') tmp-=('a'-10);
+ else tmp-='0';
+ value=16*tmp;
+ tmp=tolower(*s2++);
+ if (tmp>'9') tmp-=('a'-10);
+ else tmp-='0';
+ value+=tmp;
+ if (pictfile) {
+ fprintf(pictfile,"%c", value);
+ }
+ }
+ }
+ }
+ }
+ /*----------------------------------------*/
+ else {
+ oc->conversion->total_chars_this_line += strlen(s);
- if (op->word_begin)
- if (safe_printf(0, op->word_begin)) fprintf(stderr, TOO_MANY_ARGS, "word_begin");
+ if (oc->personality->word_begin)
+ if (safe_printf(device, 0, oc->personality->word_begin)) fprintf(stderr, TOO_MANY_ARGS, "word_begin");
- print_with_special_exprs (s);
+ print_with_special_exprs (oc, s);
- if (op->word_end)
- if (safe_printf(0, op->word_end)) fprintf(stderr, TOO_MANY_ARGS, "word_end");
- }
+ if (oc->personality->word_end)
+ if (safe_printf(device, 0, oc->personality->word_end)) fprintf(stderr, TOO_MANY_ARGS, "word_end");
+ }
- }
- /* output an escaped backslash */
- /* do we need special handling for latex? */
- else if (*(s+1) == '\\')
- {
- s++;
- putchar('\\');
- }
- else if (*(s+1) == '{')
- {
- s++;
- putchar('{');
- }
- else if (*(s+1) == '}')
- {
- s++;
- putchar('}');
- }
- /*---Handle RTF keywords---------------------------*/
- else {
+ }
+ /* output an escaped backslash */
+ /* do we need special handling for latex? */
+ else if (*(s+1) == '\\')
+ {
+ s++;
+ putchar('\\');
+ }
+ else if (*(s+1) == '{')
+ {
+ s++;
+ putchar('{');
+ }
+ else if (*(s+1) == '}')
+ {
+ s++;
+ putchar('}');
+ }
+ /*---Handle RTF keywords---------------------------*/
+ else {
- int done=FALSE;
- s++;
-/*----Paragraph alignment----------------------------------------------------*/
- if (!strcmp ("ql", s))
- paragraph_align = ALIGN_LEFT;
- else if (!strcmp ("qr", s))
- paragraph_align = ALIGN_RIGHT;
- else if (!strcmp ("qj", s))
- paragraph_align = ALIGN_JUSTIFY;
- else if (!strcmp ("qc", s))
- paragraph_align = ALIGN_CENTER;
- else if (!strcmp ("pard", s))
- {
- /* Clear out all font attributes.
- */
- attr_pop_all();
+ int done=FALSE;
+ s++;
+ /*----Paragraph alignment----------------------------------------------------*/
+ if (!strcmp ("ql", s))
+ paragraph_align = ALIGN_LEFT;
+ else if (!strcmp ("qr", s))
+ paragraph_align = ALIGN_RIGHT;
+ else if (!strcmp ("qj", s))
+ paragraph_align = ALIGN_JUSTIFY;
+ else if (!strcmp ("qc", s))
+ paragraph_align = ALIGN_CENTER;
+ else if (!strcmp ("pard", s))
+ {
+ /* Clear out all font attributes.
+ */
+ attr_pop_all(oc);
- if (coming_pars_that_are_tabular) {
- --coming_pars_that_are_tabular;
- }
+ if (oc->conversion->coming_pars_that_are_tabular) {
+ --oc->conversion->coming_pars_that_are_tabular;
+ }
- /* Clear out all paragraph attributes.
- */
- ending_paragraph_align(paragraph_align);
- paragraph_align = ALIGN_LEFT;
- paragraph_begined = FALSE;
- }
-/*----Table keywords---------------------------------------------------------*/
- else
- if (!strcmp (s, "cell")) {
+ /* Clear out all paragraph attributes.
+ */
+ ending_paragraph_align (oc, paragraph_align);
+ paragraph_align = ALIGN_LEFT;
+ paragraph_begined = FALSE;
+ }
+ /*----Table keywords---------------------------------------------------------*/
+ else
+ if (!strcmp (s, "cell")) {
- is_cell_group=TRUE;
- if (!have_printed_cell_begin) {
- /* Need this with empty cells */
- if (safe_printf(0, op->table_cell_begin)) fprintf(stderr, TOO_MANY_ARGS, "table_cell_begin");
- attrstack_express_all();
- }
- attr_pop_dump();
- if (safe_printf(0, op->table_cell_end)) fprintf(stderr, TOO_MANY_ARGS, "table_cell_end");
- have_printed_cell_begin = FALSE;
- have_printed_cell_end=TRUE;
- }
- else if (!strcmp (s, "row")) {
+ is_cell_group=TRUE;
+ if (!oc->conversion->have_printed_cell_begin) {
+ /* Need this with empty cells */
+ if (safe_printf(device, 0, oc->personality->table_cell_begin)) fprintf(stderr, TOO_MANY_ARGS, "table_cell_begin");
+ attrstack_express_all();
+ }
+ attr_pop_dump();
+ if (safe_printf(device, 0, oc->personality->table_cell_end)) fprintf(stderr, TOO_MANY_ARGS, "table_cell_end");
+ oc->conversion->have_printed_cell_begin = FALSE;
+ oc->conversion->have_printed_cell_end=TRUE;
+ }
+ else if (!strcmp (s, "row")) {
- if (within_table) {
- if (safe_printf(0, op->table_row_end)) fprintf(stderr, TOO_MANY_ARGS, "table_row_end");
- have_printed_row_begin = FALSE;
- have_printed_row_end=TRUE;
- } else {
- if (debug_mode) {
- if (safe_printf(0, op->comment_begin)) fprintf(stderr, TOO_MANY_ARGS, "comment_begin");
- printf("end of table row");
- if (safe_printf(0, op->comment_end)) fprintf(stderr, TOO_MANY_ARGS, "comment_end");
- }
- }
- }
+ if (oc->conversion->within_table) {
+ if (safe_printf(device, 0, oc->personality->table_row_end)) fprintf(stderr, TOO_MANY_ARGS, "table_row_end");
+ oc->conversion->have_printed_row_begin = FALSE;
+ oc->conversion->have_printed_row_end=TRUE;
+ } else {
+ if (oc->conversion->options->debug_mode) {
+ if (safe_printf(device, 0, oc->personality->comment_begin)) fprintf(stderr, TOO_MANY_ARGS, "comment_begin");
+ printf("end of table row");
+ if (safe_printf(device, 0, oc->personality->comment_end)) fprintf(stderr, TOO_MANY_ARGS, "comment_end");
+ }
+ }
+ }
-/*----Special chars---------------------------------------------------------*/
- else if (*s == '\'') {
- /* \'XX is a hex char code expression */
+ /*----Special chars---------------------------------------------------------*/
+ else if (*s == '\'') {
+ /* \'XX is a hex char code expression */
- int ch = h2toi (&s[1]);
- char *s2;
+ int ch = h2toi (&s[1]);
+ char *s2;
#if 1 /* daved - 0.21.2 */
- if(ch > h2toi("7f") && ch < h2toi("a1"))
- {
- /* 2 byte char - read 2nd */
- int ch2;
- char *snext;
- int *doublet;
- w = w->next;
- snext = word_string (w);
- if(*snext == '\\' && *(snext+1) == '\'')
- {
- /* all looks good */
- ch2 = h2toi(&snext[2]);
+ if(ch > h2toi("7f") && ch < h2toi("a1"))
+ {
+ /* 2 byte char - read 2nd */
+ int ch2;
+ char *snext;
+ int *doublet;
+ w = w->next;
+ snext = word_string (oc->conversion, w);
+ if(*snext == '\\' && *(snext+1) == '\'')
+ {
+ /* all looks good */
+ ch2 = h2toi(&snext[2]);
#if 0
- fprintf(stderr,"ch, ch2 = %o %o\n", ch, ch2);
+ fprintf(stderr,"ch, ch2 = %o %o\n", ch, ch2);
#endif
- doublet = (int *)my_malloc(12);
- *doublet = (int)ch;
- *(doublet+1) = (int)ch2;
- *(doublet+2) = 0;
+ doublet = (int *)unrtf_malloc(12);
+ *doublet = (int)ch;
+ *(doublet+1) = (int)ch2;
+ *(doublet+2) = 0;
#if 0
- fprintf(stderr, "doublet = %o %o\n", *doublet, *(doublet+1));
+ fprintf(stderr, "doublet = %o %o\n", *doublet, *(doublet+1));
#endif
- desc2 = desc;
- desc = my_iconv_open("UTF-8", "SHIFT_JIS");
+ oc->conversion->desc2 = oc->conversion->desc;
+ oc->conversion->desc = my_iconv_open(oc->conversion, "UTF-8", "SHIFT_JIS");
#if 1
- s2 = op_translate_doublet (op, desc, ch, ch2);
+ s2 = op_translate_doublet (oc->conversion, oc->personality, ch, ch2);
#else
- s2 = op_translate_str (op, desc, doublet);
+ s2 = op_translate_str (oc->conversion, oc->personality, doublet);
#endif
- free(doublet);
- desc = my_iconv_close(desc);
- desc = desc2;
- my_iconv_t_make_invalid(&desc2);
- }
- }
- else
+ free(doublet);
+ oc->conversion->desc = my_iconv_close(oc->conversion->desc);
+ oc->conversion->desc = oc->conversion->desc2;
+ my_iconv_t_make_invalid(&oc->conversion->desc2);
+ }
+ }
+ else
#endif
-//standard
- s2 = op_translate_char (op, desc, ch);
- if (!s2 || !*s2) {
- if (safe_printf(0, op->comment_begin)) fprintf(stderr, TOO_MANY_ARGS, "comment_begin");
- printf("char 0x%02x",ch);
- if (safe_printf(0, op->comment_end)) fprintf(stderr, TOO_MANY_ARGS, "comment_end");
- } else {
- if (op->word_begin)
- if (safe_printf(0, op->word_begin)) fprintf(stderr, TOO_MANY_ARGS, "word_begin");
-
- printf("%s", s2);
+ //standard
+ s2 = op_translate_char (oc->conversion, oc->personality, ch);
+ if (!s2 || !*s2) {
+ if (safe_printf(device, 0, oc->personality->comment_begin)) fprintf(stderr, TOO_MANY_ARGS, "comment_begin");
+ printf("char 0x%02x",ch);
+ if (safe_printf(device, 0, oc->personality->comment_end)) fprintf(stderr, TOO_MANY_ARGS, "comment_end");
+ } else {
+ if (oc->personality->word_begin)
+ if (safe_printf(device, 0, oc->personality->word_begin)) fprintf(stderr, TOO_MANY_ARGS, "word_begin");
- if (op->word_end)
- if (safe_printf(0, op->word_end)) fprintf(stderr, TOO_MANY_ARGS, "word_end");
- }
- }
- else
-/*----Search the RTF command hash-------------------------------------------*/
- {
- int ch;
- int index=0;
- int have_param = FALSE, param = 0;
- HashItem *hip;
- char *p;
- int match = FALSE; /* Pacify gcc, st001906 - 0.19.6 */
+ printf("%s", s2);
- /* Look for a parameter */
- p = s;
- while (*p && (!isdigit(*p) && *p != '-')) p++;
- if (*p && (isdigit(*p) || *p == '-')) {
- have_param = TRUE;
- param = atoi(p);
- }
+ if (oc->personality->word_end)
+ if (safe_printf(device, 0, oc->personality->word_end)) fprintf(stderr, TOO_MANY_ARGS, "word_end");
+ }
+ }
+ else
+ /*----Search the RTF command hash-------------------------------------------*/
+ {
+ int ch;
+ int index=0;
+ int have_param = FALSE, param = 0;
+ CmdHashItem *hip;
+ char *p;
+ int match = FALSE; /* Pacify gcc, st001906 - 0.19.6 */
- /* Generate a hash index */
- ch = tolower(*s);
- if (ch >= 'a' && ch <= 'z')
- hip = hash[ch - 'a'];
- else
- hip = hashArray_other;
+ /* Look for a parameter */
+ p = s;
+ while (*p && (!isdigit(*p) && *p != '-')) p++;
+ if (*p && (isdigit(*p) || *p == '-')) {
+ have_param = TRUE;
+ param = atoi(p);
+ }
- if (!hip) {
- if (debug_mode) {
- if (safe_printf(0, op->comment_begin)) fprintf(stderr, TOO_MANY_ARGS, "comment_begin");
- printf("Unfamiliar RTF command: %s (HashIndex not found)", s);
- if (safe_printf(0, op->comment_end)) fprintf(stderr, TOO_MANY_ARGS, "comment_end");
- }
- }
- else {
- while (!done) {
- match = FALSE;
+ /* Generate a hash index */
+ ch = tolower(*s);
+ if (ch >= 'a' && ch <= 'z')
+ hip = hash[ch - 'a'];
+ else
+ hip = hashArray_other;
- if (have_param) {
- int len=p-s;
- if (!hip[index].name[len] && !strncmp(s, hip[index].name, len))
- match = TRUE;
- }
- else
- match = !strcmp(s, hip[index].name);
+ if (!hip) {
+ if (oc->conversion->options->debug_mode) {
+ if (safe_printf(device, 0, oc->personality->comment_begin)) fprintf(stderr, TOO_MANY_ARGS, "comment_begin");
+ printf("Unfamiliar RTF command: %s (HashIndex not found)", s);
+ if (safe_printf(device, 0, oc->personality->comment_end)) fprintf(stderr, TOO_MANY_ARGS, "comment_end");
+ }
+ }
+ else {
+ while (!done) {
+ match = FALSE;
- if (match) {
+ if (have_param) {
+ int len=p-s;
+ if (!hip[index].name[len] && !strncmp(s, hip[index].name, len))
+ match = TRUE;
+ }
+ else
+ match = !strcmp(s, hip[index].name);
- char *debug;
- int terminate_group;
+ if (match) {
- if (hip[index].func) {
-//unicode
- terminate_group = hip[index].func (w,paragraph_align, have_param, param);
- /* daved - 0.19.4 - unicode support may need to skip only one word */
- if (terminate_group == SKIP_ONE_WORD)
- w=w->next;
- else
- if (terminate_group)
- while(w) w=w->next;
- }
+ char *debug;
+ int terminate_group;
- debug=hip[index].debug_print;
+ if (hip[index].func) {
+ //unicode
+ terminate_group = hip[index].func (oc, w, paragraph_align, have_param, param);
+ /* daved - 0.19.4 - unicode support may need to skip only one word */
+ if (terminate_group == SKIP_ONE_WORD)
+ w=w->next;
+ else
+ if (terminate_group)
+ while(w) w=w->next;
+ }
- if (debug && debug_mode) {
- if (safe_printf(0, op->comment_begin))
- fprintf(stderr, TOO_MANY_ARGS, "comment_begin");
- printf("%s", debug);
- if (safe_printf(0, op->comment_end)) fprintf(stderr, TOO_MANY_ARGS, "comment_end");
- }
+ debug=hip[index].debug_print;
- done=TRUE;
- }
- else {
- index++;
- if (!hip[index].name)
- done = TRUE;
- }
- }
- }
- if (!match) {
- if (debug_mode) {
- if (safe_printf(0, op->comment_begin)) fprintf(stderr, TOO_MANY_ARGS, "comment_begin");
- printf("Unfamiliar RTF command: %s", s);
- if (safe_printf(0, op->comment_end)) fprintf(stderr, TOO_MANY_ARGS, "comment_end");
- }
- }
- }
- }
-/*-------------------------------------------------------------------------*/
- } else {
+ if (debug && oc->conversion->options->debug_mode) {
+ if (safe_printf(device, 0, oc->personality->comment_begin))
+ fprintf(stderr, TOO_MANY_ARGS, "comment_begin");
+ printf("%s", debug);
+ if (safe_printf(device, 0, oc->personality->comment_end)) fprintf(stderr, TOO_MANY_ARGS, "comment_end");
+ }
- Word *child;
+ done=TRUE;
+ }
+ else {
+ index++;
+ if (!hip[index].name)
+ done = TRUE;
+ }
+ }
+ }
+ if (!match) {
+ if (oc->conversion->options->debug_mode) {
+ if (safe_printf(device, 0, oc->personality->comment_begin)) fprintf(stderr, TOO_MANY_ARGS, "comment_begin");
+ printf("Unfamiliar RTF command: %s", s);
+ if (safe_printf(device, 0, oc->personality->comment_end)) fprintf(stderr, TOO_MANY_ARGS, "comment_end");
+ }
+ }
+ }
+ }
+ /*-------------------------------------------------------------------------*/
+ } else {
- child = w->child;
+ Word *child;
- if (!paragraph_begined) {
- starting_paragraph_align (paragraph_align);
- paragraph_begined=TRUE;
- }
+ child = w->child;
- if (child)
- word_print_core (child);
- }
+ if (!paragraph_begined) {
+ starting_paragraph_align (oc, paragraph_align);
+ paragraph_begined=TRUE;
+ }
- if (w)
- w = w->next;
- }
+ if (child)
+ word_print_core (oc, child);
+ }
- if (within_picture) {
- if(pictfile) {
- fclose(pictfile);
- if (safe_printf(0, op->imagelink_begin)) fprintf(stderr, TOO_MANY_ARGS, "imagelink_begin");
- printf("%s", picture_path);
- if (safe_printf(0, op->imagelink_end)) fprintf(stderr, TOO_MANY_ARGS, "imagelink_end");
- }
- within_picture=FALSE;
- }
+ if (w)
+ w = w->next;
+ }
- /* Undo font attributes UNLESS we're doing table cells
- * since they would appear between </td> and </tr>.
- */
+ if (oc->conversion->within_picture) {
+ if(pictfile) {
+ fclose(pictfile);
+ if (safe_printf(device, 0, oc->personality->imagelink_begin)) fprintf(stderr, TOO_MANY_ARGS, "imagelink_begin");
+ printf("%s", oc->conversion->picture_path);
+ if (safe_printf(device, 0, oc->personality->imagelink_end)) fprintf(stderr, TOO_MANY_ARGS, "imagelink_end");
+ }
+ oc->conversion->within_picture=FALSE;
+ }
- if (!is_cell_group)
- attr_pop_all();
- else
- attr_drop_all();
+ /* Undo font attributes UNLESS we're doing table cells
+ * since they would appear between </td> and </tr>.
+ */
- /* Undo paragraph alignment
- */
- if (paragraph_begined)
- ending_paragraph_align (paragraph_align);
+ if (!is_cell_group)
+ attr_pop_all(oc);
+ else
+ attr_drop_all();
- attrstack_drop();
+ /* Undo paragraph alignment
+ */
+ if (paragraph_begined)
+ ending_paragraph_align (oc, paragraph_align);
- if((s = attr_get_param(ATTR_FONTFACE)) != NULL &&
- strstr(s,"Symbol") != NULL)
- {
- if (!my_iconv_is_valid(desc2))
- desc2 = desc;
- else
- desc = my_iconv_close(desc);
+ attrstack_drop(oc);
- desc = my_iconv_open("UTF-8", FONT_SYMBOL);
- }
- else if((s = attr_get_param(ATTR_FONTFACE)) != NULL &&
- strstr(s,"Greek") != NULL)
- {
- if (!my_iconv_is_valid(desc2))
- desc2 = desc;
- else
- desc = my_iconv_close(desc);
+ if((s = attr_get_param(oc->conversion, ATTR_FONTFACE)) != NULL &&
+ strstr(s,"Symbol") != NULL)
+ {
+ if (!my_iconv_is_valid(oc->conversion->desc2))
+ oc->conversion->desc2 = oc->conversion->desc;
+ else
+ oc->conversion->desc = my_iconv_close(oc->conversion->desc);
- desc = my_iconv_open("UTF-8", FONT_GREEK);
- }
- else
- if (my_iconv_is_valid(desc2)) /* AF - 0.21.0-rc2 */
- {
- my_iconv_close(desc);
- desc = desc2;
- my_iconv_t_make_invalid(&desc2);
- }
+ oc->conversion->desc = my_iconv_open(oc->conversion, "UTF-8", FONT_SYMBOL);
+ }
+ else if((s = attr_get_param(oc->conversion, ATTR_FONTFACE)) != NULL &&
+ strstr(s,"Greek") != NULL)
+ {
+ if (!my_iconv_is_valid(oc->conversion->desc2))
+ oc->conversion->desc2 = oc->conversion->desc;
+ else
+ oc->conversion->desc = my_iconv_close(oc->conversion->desc);
+ oc->conversion->desc = my_iconv_open(oc->conversion, "UTF-8", FONT_GREEK);
+ }
+ else
+ if (my_iconv_is_valid(oc->conversion->desc2)) /* AF - 0.21.0-rc2 */
+ {
+ my_iconv_close(oc->conversion->desc);
+ oc->conversion->desc = oc->conversion->desc2;
+ my_iconv_t_make_invalid(&oc->conversion->desc2);
+ }
}
@@ -3652,37 +3664,227 @@ word_print_core (Word *w)
*=======================================================================*/
void
-word_print (Word *w)
+word_print (const struct OutputContext *oc, Word *w)
{
- CHECK_PARAM_NOT_NULL (w);
+ const struct unRTFOutputDevice *device = &oc->conversion->options->device;
- if (!inline_mode) {
+ CHECK_PARAM_NOT_NULL (w);
+
+ if (!oc->conversion->options->inline_mode) {
#if 1 /* AK3 - AF */
- if (safe_printf(0, op->document_begin)) fprintf(stderr, TOO_MANY_ARGS, "document_begin");
- if (safe_printf(0, op->header_begin)) fprintf(stderr, TOO_MANY_ARGS, "header_begin");
- if (safe_printf(0, op->utf8_encoding)) fprintf(stderr, TOO_MANY_ARGS, "utf8_encoding");
+ if (safe_printf(device, 0, oc->personality->document_begin)) fprintf(stderr, TOO_MANY_ARGS, "document_begin");
+ if (safe_printf(device, 0, oc->personality->header_begin)) fprintf(stderr, TOO_MANY_ARGS, "header_begin");
+ if (safe_printf(device, 0, oc->personality->utf8_encoding)) fprintf(stderr, TOO_MANY_ARGS, "utf8_encoding");
#else
- printf(op->document_begin);
- printf(op->header_begin);
+ printf(oc->personality->document_begin);
+ printf(oc->personality->header_begin);
#endif
- }
+ }
- print_banner ();
+ print_banner (oc);
- within_header=TRUE;
- have_printed_body=FALSE;
- within_table=FALSE;
- simulate_allcaps=FALSE;
- word_print_core (w);
- end_table();
+ oc->conversion->within_header=TRUE;
+ oc->conversion->have_printed_body=FALSE;
+ oc->conversion->within_table=FALSE;
+ oc->conversion->simulate_allcaps=FALSE;
+ word_print_core (oc, w);
+ end_table (oc);
- if (!inline_mode) {
+ if (!oc->conversion->options->inline_mode) {
#if 1 /* AK3 - AF */
- if (safe_printf(0, op->body_end)) fprintf(stderr, TOO_MANY_ARGS, "body_end");
- if (safe_printf(0, op->document_end)) fprintf(stderr, TOO_MANY_ARGS, "document_end");
+ if (safe_printf(device, 0, oc->personality->body_end)) fprintf(stderr, TOO_MANY_ARGS, "body_end");
+ if (safe_printf(device, 0, oc->personality->document_end)) fprintf(stderr, TOO_MANY_ARGS, "document_end");
#else
- printf(op->body_end);
- printf(op->document_end);
+ printf(oc->personality->body_end);
+ printf(oc->personality->document_end);
#endif
- }
+ }
+}
+
+/* public functions */
+void unrtf_set_output_device (unRTFOptions *options, unrtf_output_device_func output_func, void *output_data)
+{
+ options->device.print = output_func;
+ options->device.data = output_data;
+}
+
+/*========================================================================
+ * Name: main
+ * Purpose: Main control function.
+ * Args: Args.
+ * Returns: Exit code.
+ *=======================================================================*/
+
+static int stdout_print(void *null, const char *data, size_t data_len)
+{
+ return printf ("%s", data);
+}
+
+static char *format_path(const unRTFOptions *options)
+{
+ size_t fullname_len;
+ char *fullname;
+
+ if (!options->output_format || !options->config_directory)
+ return 0;
+
+ fullname_len = strlen (options->output_format) + strlen (options->config_directory) + 6;
+ fullname = malloc(fullname_len + 1);
+ sprintf (fullname, "%s/%s.conf", options->config_directory, options->output_format);
+
+ return fullname;
+}
+
+/* TODO: make use of mmap */
+int unrtf_convert_from_string (unRTFOptions *options, const char *input_str, size_t input_len)
+{
+ Word *word;
+ char *path, *env_path_p;
+ ConversionContext cc;
+ OutputContext oc;
+
+ if (!options)
+ return 0;
+
+ if (!input_str || !input_len)
+ return 0;
+
+ if (!options->output_format)
+ options->output_format = DEFAULT_OUTPUT;
+ if (!options->config_directory)
+ {
+ if ((env_path_p = getenv("UNRTF_SEARCH_PATH")) != NULL)
+ {
+ if (options->verbose_mode)
+ fprintf (stderr, "got environment path: %s\n", env_path_p);
+ options->config_directory = env_path_p;
+ }
+ else
+ options->config_directory = DEFAULT_UNRTF_SEARCH_PATH;
+ }
+
+ path = format_path(options);
+ if (!path)
+ return 0;
+
+ if (access(path, R_OK) != 0)
+ {
+ free (path);
+ return 0;
+ }
+
+ if (!options->device.print)
+ unrtf_set_output_device (options, stdout_print, NULL);
+
+ memset (&cc, 0, sizeof (struct ConversionContext));
+
+ hash_init (&cc);
+
+ cc.read_buf = input_str;
+ cc.read_buf_end = input_len;
+
+ cc.current_max_length = 1;
+ cc.ungot_char = -1;
+ cc.ungot_char2 = -1;
+ cc.ungot_char3 = -1;
+
+ cc.picture_file_number=1;
+ cc.picture_bits_per_pixel=1;
+ cc.picture_type = PICT_UNKNOWN;
+
+ cc.desc.desc = (iconv_t) -1;
+ cc.desc2.desc = (iconv_t) -1;
+
+ cc.options = options;
+
+ oc.personality = user_init(&cc, path);
+ oc.conversion = &cc;
+
+ /* All the work starts here. word_read() should keep reading words until
+ * the end of the file. */
+ word = word_read(&cc);
+
+ if (options->dump_mode) {
+ word_dump(&cc, word);
+ printf("\n");
+ } else {
+ /* Should we also optimize word before dump? - AF */
+ /* word = optimize_word(oc.conversion, word); */
+ word_print(&oc, word);
+ }
+
+ /* marcossamaral - 0.19.9 */
+ if (options->verbose_mode || options->debug_mode) {
+ unsigned long total=0;
+ total = hash_stats(&cc);
+ fprintf(stderr, "Done.\n");
+ fprintf(stderr, "%lu words were hashed.\n", total);
+ }
+
+ if (options->debug_mode) {
+ fprintf(stderr, "Total memory allocated %ld bytes.\n",
+ total_malloced());
+ }
+
+ hash_free(&cc);
+ if (cc.input_str)
+ unrtf_free(cc.input_str);
+ word_free(word);
+ fonttable_free(oc.conversion);
+ if (my_iconv_is_valid(oc.conversion->desc))
+ my_iconv_close(oc.conversion->desc);
+ op_free (oc.personality);
+ free (path);
+
+ return 1; /* success */
+}
+
+int unrtf_convert_from_filename (unRTFOptions *options, const char *filename)
+{
+ FILE *f;
+ size_t read_len, total_len, max_len;
+ char *content;
+ char buffer[4096];
+ int is_stdin = 0, rc;
+
+ if (!filename || strcmp(filename, "-") == 0)
+ {
+ is_stdin = 1;
+ f = stdin;
+ filename = "<stdin>";
+ }
+ else
+ {
+ f = fopen (filename, "r");
+ if (!f)
+ return 0;
+ }
+
+ if (options->verbose_mode || options->debug_mode) fprintf(stderr, "Processing %s...\n", filename);
+
+ max_len = 4096;
+ total_len = 0;
+ content = malloc (max_len + 1);
+ do
+ {
+ read_len = fread (buffer, sizeof (char), 4096, f);
+ memcpy (content + total_len, buffer, read_len);
+ total_len += read_len;
+ if (total_len + 4096 > max_len)
+ {
+ max_len = total_len + 4096;
+ content = realloc (content, max_len + 1);
+ }
+ }
+ while (read_len == 4096);
+
+ if (!is_stdin)
+ fclose (f);
+
+ content[total_len] = 0;
+ rc = unrtf_convert_from_string (options, content, total_len);
+
+ free (content);
+
+ return rc;
}
diff -durpN unrtf-0.21.2.old/src/convert.h unrtf-0.21.2/src/convert.h
--- unrtf-0.21.2.old/src/convert.h 2010-07-04 04:30:58.000000000 +0200
+++ unrtf-0.21.2/src/convert.h 2013-01-17 02:41:09.685864239 +0100
@@ -36,18 +36,135 @@
#ifndef _CONVERT
+#include "my_iconv.h"
+
enum {
- CHARSET_ANSI=1,
- CHARSET_MAC,
- CHARSET_CP437,
- CHARSET_CP850,
+ CHARSET_ANSI=1,
+ CHARSET_MAC,
+ CHARSET_CP437,
+ CHARSET_CP850,
};
#ifndef _WORD
#include "word.h"
#endif
-extern void word_print (Word*);
+typedef struct {
+ int num;
+ char *name;
+} FontEntry;
+
+#define MAX_FONTS (8192)
+
+/* RTF color table colors are RGB */
+
+typedef struct {
+ unsigned char r,g,b;
+} Color;
+
+#define MAX_COLORS (1024)
+
+/* For each RTF text block (the text within braces) we must keep
+ * an AttrStack which is a stack of attributes and their optional
+ * parameter. Since RTF text blocks are nested, these make up a
+ * stack of stacks. And, since RTF text blocks inherit attributes
+ * from parent blocks, all new AttrStacks do the same from
+ * their parent AttrStack.
+ */
+#define MAX_ATTRS (10000)
+
+typedef struct _stack {
+ unsigned char attr_stack[MAX_ATTRS];
+ char *attr_stack_params[MAX_ATTRS];
+ int tos;
+ struct _stack *next;
+} AttrStack;
+
+typedef struct _hi {
+ struct _hi *next;
+ char *str;
+ unsigned long value;
+} HashItem;
+
+typedef struct ConversionContext {
+ const struct unRTFOptions *options;
+
+ HashItem *hash[256];
+ unsigned long hash_length[256];
+ unsigned long hash_value;
+
+ int lineno; /* Used for error reporting and final line count. */
+
+ int banner_printed;
+
+ int within_picture;
+ int picture_file_number;
+ char picture_path[256];
+ int picture_width;
+ int picture_height;
+ int picture_bits_per_pixel;
+ int picture_type;
+ int picture_wmetafile_type;
+ char *picture_wmetafile_type_str;
+
+ int have_printed_body;
+ int within_header;
+
+ char *hyperlink_base;
+
+ FontEntry font_table[MAX_FONTS];
+ int total_fonts;
+
+ Color color_table[MAX_COLORS];
+ int total_colors;
+
+ my_iconv_t desc;
+ my_iconv_t desc2;
+
+ /* Previously in word_print_core function
+ */
+ int total_chars_this_line; /* for simulating \tab */
+
+ /* This value is set by attr_push and attr_pop
+ */
+ int simulate_smallcaps;
+ int simulate_allcaps;
+
+ int coming_pars_that_are_tabular;
+ int within_table;
+ int have_printed_row_begin;
+ int have_printed_cell_begin;
+ int have_printed_row_end;
+ int have_printed_cell_end;
+
+ /* attr.c */
+ AttrStack *stack_of_stacks;
+ AttrStack *stack_of_stacks_top;
+
+ /* word.c */
+ int indent_level;
+
+ /* parse.c */
+ char *input_str;
+ unsigned long current_max_length;
+ int ungot_char;
+ int ungot_char2;
+ int ungot_char3;
+ int last_returned_ch;
+ int buffer_size;
+
+ const char *read_buf;
+ int read_buf_end;
+ int read_buf_index;
+
+} ConversionContext;
+
+struct OutputContext;
+
+extern void word_print (const struct OutputContext *, Word*);
+extern void starting_body(const struct OutputContext *);
+extern void starting_text(const struct OutputContext *);
+
#define FONT_GREEK "cp1253"
#define FONT_SYMBOL "SYMBOL"
diff -durpN unrtf-0.21.2.old/src/defs.h unrtf-0.21.2/src/defs.h
--- unrtf-0.21.2.old/src/defs.h 2010-07-04 04:30:58.000000000 +0200
+++ unrtf-0.21.2/src/defs.h 2013-01-17 02:41:09.685864239 +0100
@@ -64,9 +64,6 @@
#define SKIP_ONE_WORD 2
#endif
-#define USAGE "unrtf [--version] [--verbose] [--help] [--nopict|-n] [--noremap] [--html] [--text] [--vt] [--latex] [--rtf] [-P config_search_path] [-t <file_with_tags>)] <filename>"
-
-
/* Default names for RTF's default fonts */
#define FONTNIL_STR "Times,TimesRoman,TimesNewRoman"
#define FONTROMAN_STR "Times,Palatino"
@@ -76,3 +73,6 @@
#define FONTDECOR_STR "ZapfChancery"
#define FONTTECH_STR "Symbol"
+/* This one should be deduce from the configure script */
+#define DEFAULT_UNRTF_SEARCH_PATH "/usr/local/lib/unrtf/"
+#define DEFAULT_OUTPUT "html"
diff -durpN unrtf-0.21.2.old/src/.deps/attr.Po unrtf-0.21.2/src/.deps/attr.Po
--- unrtf-0.21.2.old/src/.deps/attr.Po 1970-01-01 01:00:00.000000000 +0100
+++ unrtf-0.21.2/src/.deps/attr.Po 2013-01-17 02:47:40.017847101 +0100
@@ -0,0 +1 @@
+# dummy
diff -durpN unrtf-0.21.2.old/src/.deps/convert.Po unrtf-0.21.2/src/.deps/convert.Po
--- unrtf-0.21.2.old/src/.deps/convert.Po 1970-01-01 01:00:00.000000000 +0100
+++ unrtf-0.21.2/src/.deps/convert.Po 2013-01-17 02:47:40.021847101 +0100
@@ -0,0 +1 @@
+# dummy
diff -durpN unrtf-0.21.2.old/src/.deps/error.Po unrtf-0.21.2/src/.deps/error.Po
--- unrtf-0.21.2.old/src/.deps/error.Po 1970-01-01 01:00:00.000000000 +0100
+++ unrtf-0.21.2/src/.deps/error.Po 2013-01-17 02:47:40.025847101 +0100
@@ -0,0 +1 @@
+# dummy
diff -durpN unrtf-0.21.2.old/src/.deps/hash.Po unrtf-0.21.2/src/.deps/hash.Po
--- unrtf-0.21.2.old/src/.deps/hash.Po 1970-01-01 01:00:00.000000000 +0100
+++ unrtf-0.21.2/src/.deps/hash.Po 2013-01-17 02:47:40.029847100 +0100
@@ -0,0 +1 @@
+# dummy
diff -durpN unrtf-0.21.2.old/src/.deps/main.Po unrtf-0.21.2/src/.deps/main.Po
--- unrtf-0.21.2.old/src/.deps/main.Po 1970-01-01 01:00:00.000000000 +0100
+++ unrtf-0.21.2/src/.deps/main.Po 2013-01-17 02:47:40.033847100 +0100
@@ -0,0 +1 @@
+# dummy
diff -durpN unrtf-0.21.2.old/src/.deps/malloc.Po unrtf-0.21.2/src/.deps/malloc.Po
--- unrtf-0.21.2.old/src/.deps/malloc.Po 1970-01-01 01:00:00.000000000 +0100
+++ unrtf-0.21.2/src/.deps/malloc.Po 2013-01-17 02:47:40.033847100 +0100
@@ -0,0 +1 @@
+# dummy
diff -durpN unrtf-0.21.2.old/src/.deps/my_iconv.Po unrtf-0.21.2/src/.deps/my_iconv.Po
--- unrtf-0.21.2.old/src/.deps/my_iconv.Po 1970-01-01 01:00:00.000000000 +0100
+++ unrtf-0.21.2/src/.deps/my_iconv.Po 2013-01-17 02:47:40.037847100 +0100
@@ -0,0 +1 @@
+# dummy
diff -durpN unrtf-0.21.2.old/src/.deps/output.Po unrtf-0.21.2/src/.deps/output.Po
--- unrtf-0.21.2.old/src/.deps/output.Po 1970-01-01 01:00:00.000000000 +0100
+++ unrtf-0.21.2/src/.deps/output.Po 2013-01-17 02:47:40.041847100 +0100
@@ -0,0 +1 @@
+# dummy
diff -durpN unrtf-0.21.2.old/src/.deps/parse.Po unrtf-0.21.2/src/.deps/parse.Po
--- unrtf-0.21.2.old/src/.deps/parse.Po 1970-01-01 01:00:00.000000000 +0100
+++ unrtf-0.21.2/src/.deps/parse.Po 2013-01-17 02:47:40.045847100 +0100
@@ -0,0 +1 @@
+# dummy
diff -durpN unrtf-0.21.2.old/src/.deps/path.Po unrtf-0.21.2/src/.deps/path.Po
--- unrtf-0.21.2.old/src/.deps/path.Po 1970-01-01 01:00:00.000000000 +0100
+++ unrtf-0.21.2/src/.deps/path.Po 2013-01-17 02:47:40.049847100 +0100
@@ -0,0 +1 @@
+# dummy
diff -durpN unrtf-0.21.2.old/src/.deps/unicode.Po unrtf-0.21.2/src/.deps/unicode.Po
--- unrtf-0.21.2.old/src/.deps/unicode.Po 1970-01-01 01:00:00.000000000 +0100
+++ unrtf-0.21.2/src/.deps/unicode.Po 2013-01-17 02:47:40.053847099 +0100
@@ -0,0 +1 @@
+# dummy
diff -durpN unrtf-0.21.2.old/src/.deps/user.Po unrtf-0.21.2/src/.deps/user.Po
--- unrtf-0.21.2.old/src/.deps/user.Po 1970-01-01 01:00:00.000000000 +0100
+++ unrtf-0.21.2/src/.deps/user.Po 2013-01-17 02:47:40.057847099 +0100
@@ -0,0 +1 @@
+# dummy
diff -durpN unrtf-0.21.2.old/src/.deps/util.Po unrtf-0.21.2/src/.deps/util.Po
--- unrtf-0.21.2.old/src/.deps/util.Po 1970-01-01 01:00:00.000000000 +0100
+++ unrtf-0.21.2/src/.deps/util.Po 2013-01-17 02:47:40.061847099 +0100
@@ -0,0 +1 @@
+# dummy
diff -durpN unrtf-0.21.2.old/src/.deps/word.Po unrtf-0.21.2/src/.deps/word.Po
--- unrtf-0.21.2.old/src/.deps/word.Po 1970-01-01 01:00:00.000000000 +0100
+++ unrtf-0.21.2/src/.deps/word.Po 2013-01-17 02:47:40.061847099 +0100
@@ -0,0 +1 @@
+# dummy
diff -durpN unrtf-0.21.2.old/src/error.c unrtf-0.21.2/src/error.c
--- unrtf-0.21.2.old/src/error.c 2010-07-04 04:30:58.000000000 +0200
+++ unrtf-0.21.2/src/error.c 2013-01-17 02:41:09.685864239 +0100
@@ -51,27 +51,11 @@
#include <stdlib.h>
#endif
+#include "convert.h"
#include "defs.h"
#include "main.h"
-
-/*========================================================================
- * Name: usage
- * Purpose: Prints usage information and exits with an error.
- * Args: None.
- * Returns: None.
- *=======================================================================*/
-
-void
-usage ()
-{
- fprintf(stderr, "Usage: %s\n", USAGE);
- exit(-3);
-}
-
-
-
/*========================================================================
* Name: error_handler
* Purpose: Prints error message and other useful info, then exits.
@@ -80,10 +64,10 @@ usage ()
*=======================================================================*/
void
-error_handler (char* message)
+error_handler (const struct ConversionContext *cc, char* message)
{
#if 1
- fprintf(stderr, "Error (line %d): %s\n", lineno, message);
+ fprintf(stderr, "Error (line %d): %s\n", cc->lineno, message);
#else
fprintf(stderr, "Error: %s\n", message);
#endif
diff -durpN unrtf-0.21.2.old/src/error.h unrtf-0.21.2/src/error.h
--- unrtf-0.21.2.old/src/error.h 2010-07-04 04:30:58.000000000 +0200
+++ unrtf-0.21.2/src/error.h 2013-01-17 02:41:09.685864239 +0100
@@ -37,9 +37,10 @@
#define CHECK_MALLOC_SUCCESS(XX) { if ((XX)==NULL) { fprintf (stderr, "internal error: cannot allocate memory in %s at %d\n", __FILE__, __LINE__); exit (1); }}
+struct ConversionContext;
extern void usage(void);
-extern void error_handler (char*);
+extern void error_handler (const struct ConversionContext *, char*);
extern void warning_handler (char*);
diff -durpN unrtf-0.21.2.old/src/GNUmakefile unrtf-0.21.2/src/GNUmakefile
--- unrtf-0.21.2.old/src/GNUmakefile 1970-01-01 01:00:00.000000000 +0100
+++ unrtf-0.21.2/src/GNUmakefile 2013-01-17 02:43:38.797857692 +0100
@@ -0,0 +1,34 @@
+# -*-makefile-*-
+
+# GNUstep makefile
+
+include $(GNUSTEP_MAKEFILES)/common.make
+
+UNRTF = unrtf
+
+SUBPROJECT_NAME = $(UNRTF)
+
+$(UNRTF)_C_FILES = \
+ attr.c \
+ convert.c \
+ error.c \
+ hash.c \
+ malloc.c \
+ my_iconv.c \
+ output.c \
+ parse.c \
+ unicode.c \
+ user.c \
+ util.c \
+ word.c
+
+$(UNRTF)_CFLAGS = -DHAVE_CONFIG_H=1 -I. -I../
+
+# Option include to set any additional variables
+-include GNUmakefile.preamble
+
+# Include in the rules for making libraries
+include $(GNUSTEP_MAKEFILES)/subproject.make
+
+# Option include to define any additional rules
+-include GNUmakefile.postamble
diff -durpN unrtf-0.21.2.old/src/hash.c unrtf-0.21.2/src/hash.c
--- unrtf-0.21.2.old/src/hash.c 2010-07-04 04:30:58.000000000 +0200
+++ unrtf-0.21.2/src/hash.c 2013-01-17 02:43:16.581858668 +0100
@@ -53,24 +53,20 @@
#include <string.h>
#endif
+#ifdef HAVE_STDLIB_H
+#include <stdlib.h>
+#endif
+
+#ifdef HAVE_STDINT_H
+#include <stdint.h>
+#endif
+
+#include "convert.h"
#include "error.h"
#include "main.h"
#include "malloc.h"
-
-typedef struct _hi {
- struct _hi *next;
- char *str;
- unsigned long value;
-} HashItem;
-
-
-/* Index by first char of string */
-static HashItem *hash[256];
-static unsigned long hash_length[256];
-static unsigned long hash_value=0;
-
-
+#include "hash.h"
/*========================================================================
* Name: hash_init
@@ -80,13 +76,13 @@ static unsigned long hash_value=0;
*=======================================================================*/
void
-hash_init ()
+hash_init (struct ConversionContext *cc)
{
- int i;
- for (i=0; i<256; i++) {
- hash[i]=NULL;
- hash_length[i]=0;
- }
+ int i;
+ for (i=0; i<256; i++) {
+ cc->hash[i]=NULL;
+ cc->hash_length[i]=0;
+ }
}
@@ -101,14 +97,14 @@ hash_init ()
*=======================================================================*/
unsigned long
-hash_stats ()
+hash_stats (struct ConversionContext *cc)
{
- int i;
- unsigned long total=0;
- for (i=0; i<256; i++) {
- total += hash_length[i];
- }
- return(total);
+ int i;
+ unsigned long total=0;
+ for (i=0; i<256; i++) {
+ total += cc->hash_length[i];
+ }
+ return(total);
}
@@ -121,32 +117,32 @@ hash_stats ()
*=======================================================================*/
static HashItem *
-hashitem_new (char *str)
+hashitem_new (struct ConversionContext *cc, char *str)
{
- HashItem *hi;
- unsigned long i;
-
- hi=(HashItem*) my_malloc(sizeof(HashItem));
- if (!hi)
- error_handler("Out of memory");
- memset ((void*)hi, 0, sizeof (HashItem));
-
- hi->str = my_strdup(str);
+ HashItem *hi;
+ unsigned long i;
- i = *str;
- if (i=='\\') i=str[1];
- i <<= 24;
- hi->value = i | (hash_value++ & 0xffffff);
- hi->next = NULL;
+ hi=(HashItem*) unrtf_malloc(sizeof(HashItem));
+ if (!hi)
+ error_handler(cc, "Out of memory");
+ memset ((void*)hi, 0, sizeof (HashItem));
+
+ hi->str = unrtf_strdup(cc, str);
+
+ i = *str;
+ if (i=='\\') i=str[1];
+ i <<= 24;
+ hi->value = i | (cc->hash_value++ & 0xffffff);
+ hi->next = NULL;
#if 0
- if (debug_mode) {
- printf ("<!-- storing val %08lx str %s -->\n",
- hi->value, hi->str);
- }
+ if (debug_mode) {
+ printf ("<!-- storing val %08lx str %s -->\n",
+ hi->value, hi->str);
+ }
#endif
- return hi;
+ return hi;
}
@@ -158,7 +154,7 @@ hashitem_new (char *str)
*=======================================================================*/
unsigned long
-hash_get_index (char *str)
+hash_get_index (struct ConversionContext *cc, char *str)
{
#if 1 /* daved - 0.19.1 */
unsigned short index;
@@ -177,17 +173,17 @@ hash_get_index (char *str)
if (ch=='\\' && *(str+1))
ch = *(str+1);
index = ch;
- hi = hash[index];
+ hi = cc->hash[index];
while (hi) {
if (!strcmp(hi->str,str))
return hi->value;
hi=hi->next;
}
/* not in hash */
- hi = hashitem_new (str);
- hi->next = hash[index];
- hash [index] = hi;
- ++hash_length [index];
+ hi = hashitem_new (cc, str);
+ hi->next = cc->hash[index];
+ cc->hash [index] = hi;
+ ++cc->hash_length [index];
return hi->value;
}
@@ -201,13 +197,13 @@ hash_get_index (char *str)
*=======================================================================*/
char*
-hash_get_string (unsigned long value)
+hash_get_string (const struct ConversionContext *cc, unsigned long value)
{
- int index;
+ uint8_t index;
HashItem *hi;
- index = value >> 24;
- hi = hash[index];
+ index = (uint8_t)(value >> 24);
+ hi = cc->hash[index];
while (hi) {
if (hi->value == value)
return hi->str;
@@ -216,3 +212,27 @@ hash_get_string (unsigned long value)
warning_handler("Word not in hash");
return NULL;
}
+
+static void
+hashitem_free (HashItem *item)
+{
+ HashItem *next = item->next;
+
+ unrtf_free (item->str);
+ free (item);
+ if (next)
+ hashitem_free(next);
+}
+
+void
+hash_free (struct ConversionContext *cc)
+{
+ int i;
+ for (i=0; i<256; i++) {
+ if (cc->hash[i]) {
+ hashitem_free(cc->hash[i]);
+ }
+ cc->hash[i]=NULL;
+ cc->hash_length[i]=0;
+ }
+}
diff -durpN unrtf-0.21.2.old/src/hash.h unrtf-0.21.2/src/hash.h
--- unrtf-0.21.2.old/src/hash.h 2010-07-04 04:30:58.000000000 +0200
+++ unrtf-0.21.2/src/hash.h 2013-01-17 02:41:09.685864239 +0100
@@ -32,11 +32,15 @@
* 16 Dec 07, daved@physiol.usyd.edu.au: updated to GPL v3
*--------------------------------------------------------------------*/
+#ifndef HASH_H
+#define HASH_H 1
+struct ConversionContext;
-extern void hash_init (void);
-extern unsigned long hash_stats (void);
-extern unsigned long hash_get_index (char *);
-extern char* hash_get_string (unsigned long );
-
+extern void hash_init (struct ConversionContext *);
+extern unsigned long hash_stats (struct ConversionContext *);
+extern unsigned long hash_get_index (struct ConversionContext *, char *);
+extern char* hash_get_string (const struct ConversionContext *, unsigned long);
+extern void hash_free (struct ConversionContext *);
+#endif /* HASH_H */
diff -durpN unrtf-0.21.2.old/src/main.c unrtf-0.21.2/src/main.c
--- unrtf-0.21.2.old/src/main.c 2010-07-04 04:30:58.000000000 +0200
+++ unrtf-0.21.2/src/main.c 2013-01-17 02:41:09.685864239 +0100
@@ -1,23 +1,23 @@
/*=============================================================================
- GNU UnRTF, a command-line program to convert RTF documents to other formats.
- Copyright (C) 2000, 2001, 2004 by Zachary Smith
+ GNU UnRTF, a command-line program to convert RTF documents to other formats.
+ Copyright (C) 2000, 2001, 2004 by Zachary Smith
- 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 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.
+ 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, write to the Free Software
- Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- The maintainer is reachable by electronic mail at daved@physiol.usyd.edu.au
-=============================================================================*/
+ The maintainer is reachable by electronic mail at daved@physiol.usyd.edu.au
+ =============================================================================*/
/*----------------------------------------------------------------------
@@ -45,7 +45,7 @@
* 17 Dec 07, daved@physiol.usyd.edu.au: support for --noremap from
* David Santinoli
* 09 Nov 08, arkadiusz.firus@gmail.com: support for -t <tag_file>
- and read stdin if no input file provided
+ and read stdin if no input file provided
* 13 Dec 08, daved@physiol.usyd.edu.au: search path code
* 17 Jan 10, daved@physiol.usyd.edu.au: change search path to directory
* containing output conf and font charmap files
@@ -70,263 +70,136 @@
#include <unistd.h>
#include "defs.h"
-#include "error.h"
-#include "word.h"
-#include "convert.h"
-#include "parse.h"
-#include "hash.h"
-#include "malloc.h"
-#include "path.h"
+#include "unrtf.h"
-#include "output.h"
-#include "user.h"
#include "main.h"
-#include "util.h"
-
-int nopict_mode; /* TRUE => Do not write \pict's to files */
-int dump_mode; /* TRUE => Output a dump of the RTF word tree */
-int debug_mode; /* TRUE => Output debug comments within HTML */
-int lineno; /* Used for error reporting and final line count. */
-int simple_mode; /* TRUE => Output HTML without SPAN/DIV tags -- This would
- probably be more useful if we could pull out <font> tags
- as well. */
-int inline_mode; /* TRUE => Output HTML without HTML/BODY/HEAD -- This is
- buggy. I've seen it output pages of </font> tags. */
-/* marcossamaral - 0.19.9 */
-int verbose_mode; /* TRUE => Output additional informations about unrtf */
-int no_remap_mode; /* don't remap codepoints */
-
-
-OutputPersonality *op = NULL;
/*========================================================================
- * Name: get_config
- * Purpose: Updates output acording to information found in file path.
- * Args: Path to configuration file, OutputPersonality, mode.
- If mode == 0 configuration file is defined by user.
- If mode == 1 configuration file is in CONFIG_DIR.
- * Returns: Updated OutputPersonality.
+ * Name: usage
+ * Purpose: Prints usage information and exits with an error.
+ * Args: None.
+ * Returns: None.
*=======================================================================*/
-OutputPersonality *
-get_config(char *path, OutputPersonality *op, int mode)
+void
+usage ()
{
- char *absolute_path;
- char *user_path;
- char u_success=0;
- struct path_dir *path_dir_p;
-
- switch(mode)
- {
- case 0:
- if(n_path_dirs == 0)
- {
- fprintf(stderr,"no directories to search for %s\n", path);
- exit(1);
- }
- for(path_dir_p = &topdir; path_dir_p->dir_name; path_dir_p = path_dir_p->next)
- {
- char *p;
- p = path_dir_p->dir_name;
- if(*(p+strlen(p)-1) != '/')
- p = concatenate(p, "/");
- p=concatenate(p, path);
- user_path=concatenate(p, ".conf");
- if(access(user_path, F_OK|R_OK))
- continue;
- op = user_init(op, user_path);
- u_success++;
- break;
- }
- if(!u_success)
- {
- fprintf(stderr, "failed to find %s.conf in search path dirs\n", path);
- exit(1);
- }
- break;
- case 1:
- path = concatenate(CONFIG_DIR, path);
- absolute_path = concatenate(path, ".conf");
- op = user_init(op, absolute_path);
- my_free(absolute_path);
- break;
- default:
- error_handler("Error in function get_config (file main.c).");
- }
-
- return op;
+ fprintf(stderr, "Usage: %s\n", USAGE);
+ exit(-3);
}
-/*========================================================================
- * Name: main
- * Purpose: Main control function.
- * Args: Args.
- * Returns: Exit code.
- *=======================================================================*/
-
int
main (int argc, char **argv)
{
- FILE *f;
- Word * word;
- char *path = NULL;
- char *env_path_p = '\0';
-
- int i;
- nopict_mode = debug_mode = dump_mode = inline_mode = no_remap_mode = FALSE;
- /* initialize search path to compiled-in value */
- search_path = DEFAULT_UNRTF_SEARCH_PATH;
+ unRTFOptions unrtf_options;
+ int show_version = 0, i, free_path = 0;
+ char *path = NULL, *old_path;
+ size_t path_len;
- if((env_path_p = getenv("UNRTF_SEARCH_PATH")) != NULL)
- {
- if(verbose_mode)
- fprintf(stderr, "got environment path: %s\n", env_path_p);
- search_path=env_path_p;
- }
+ memset (&unrtf_options, 0, sizeof (unRTFOptions));
- /* Handle arguments */
+ /* Handle arguments */
- for (i = 1; i < argc; i++) {
- if (!strcmp("--dump", argv[i])) dump_mode = TRUE;
- else if (!strcmp("-d", argv[i])) dump_mode = TRUE;
- else if (!strcmp("--debug", argv[i])) debug_mode = TRUE;
- else if (!strcmp("--verbose", argv[i])) verbose_mode = TRUE;
- else if (!strcmp("--simple", argv[i])) simple_mode = TRUE;
- else if (!strcmp("--noremap", argv[i])) no_remap_mode = TRUE;
- else if (!strcmp("-t", argv[i]))
- {
- if ((i + 1) < argc && *argv[i + 1] != '-')
- {
- i++;
- if(!path_checked && check_dirs() == 0)
- {
- fprintf(stderr,"no config dirs for %s\n", argv[i]);
- exit(1);
- }
- op = get_config(argv[i], op, 0);
- }
- }
- else if (!strcmp("-P", argv[i]))
- {
- if(i+1 > argc)
- {
- fprintf(stderr,"-P needs a path argument\n");
- exit(1);
- }
- search_path=argv[++i];
- }
- else if (!strcmp("--inline", argv[i])) inline_mode = TRUE;
- else if (!strcmp("--help", argv[i])) {
- usage();
- }
- else if (!strcmp("--version", argv[i])) {
- fprintf(stderr, "%s\n", PACKAGE_VERSION);
- fprintf(stderr, "search path is: %s\n", search_path);
- exit(0);
- }
- else if (!strcmp("--nopict", argv[i])) nopict_mode = TRUE;
- else if (!strcmp("-n", argv[i])) nopict_mode = TRUE;
- else if (!strncmp("--", argv[i], 2))
+ for (i = 1; i < argc; i++) {
+ if (!strcmp("--dump", argv[i])) unrtf_options.dump_mode = TRUE;
+ else if (!strcmp("-d", argv[i])) unrtf_options.dump_mode = TRUE;
+ else if (!strcmp("--debug", argv[i])) unrtf_options.debug_mode = TRUE;
+ else if (!strcmp("--verbose", argv[i])) unrtf_options.verbose_mode = TRUE;
+ else if (!strcmp("--simple", argv[i])) unrtf_options.simple_mode = TRUE;
+ else if (!strcmp("--noremap", argv[i])) unrtf_options.no_remap_mode = TRUE;
+ else if (!strcmp("-t", argv[i]))
+ {
+ if ((i + 1) < argc && *argv[i + 1] != '-')
+ {
+ i++;
+ unrtf_options.output_format = argv[i];
+ }
+ else
+ {
+ fprintf(stderr, "-t needs a path argument\n");
+ exit(1);
+ }
+ }
+ else if (!strcmp("-P", argv[i]))
+ {
+ if ((i + 1) < argc && *argv[i + 1] != '-')
+ {
+ i++;
+ unrtf_options.config_directory = argv[i];
+ }
+ else
+ {
+ fprintf(stderr,"-P needs a path argument\n");
+ exit(1);
+ }
+ }
+ else if (!strcmp("--inline", argv[i])) unrtf_options.inline_mode = TRUE;
+ else if (!strcmp("--help", argv[i])) {
+ usage();
+ }
+ else if (!strcmp("--version", argv[i])) {
+ show_version = 1;
+ }
+ else if (!strcmp("--nopict", argv[i])) unrtf_options.nopict_mode = TRUE;
+ else if (!strcmp("-n", argv[i])) unrtf_options.nopict_mode = TRUE;
+ else if (!strncmp("--", argv[i], 2))
#if 0 /* daved 0.21.1 */
- op = get_config(&argv[i][2], op, 1)
+ op = get_config(&cc, &argv[i][2], op, 1)
#else
- {
- if(!path_checked && check_dirs() == 0)
- {
- fprintf(stderr,"no config dirs for %s\n", argv[i]);
- exit(1);
- }
- op = get_config(&argv[i][2], op, 0);
- }
+ {
+ unrtf_options.output_format = argv[i] + 2;
+ }
#endif
- else {
- if (*argv[i] == '-') usage();
-
- if (path)
- usage();
- else
- path = argv[i];
- }
- }
-
-
-
- if (op == NULL)
- op = get_config(DEFAULT_OUTPUT, op, 1);
- if(!path_checked && check_dirs() == 0)
- {
- fprintf(stderr,"no config directories\n");
- exit(1);
- }
-
-
- hash_init();
-
- /* Program information */
- if (verbose_mode || debug_mode) {
- fprintf(stderr, "This is UnRTF ");
- fprintf(stderr, "version %s\n", PACKAGE_VERSION);
- fprintf(stderr, "By Dave Davey, Marcos Serrou do Amaral and Arkadiusz Firus\n");
- fprintf(stderr, "Original Author: Zachary Smith\n");
- show_dirs();
- }
-
- if (debug_mode) fprintf(stderr, "Debug mode.\n");
- if (dump_mode) fprintf(stderr, "Dump mode.\n");
-
- /* Open file for reading. Append ".rtf" to file name if not supplied. */
- if (path == NULL)
- f = stdin;
- else
- {
- f = fopen(path, "r");
- if (!f) {
- char path2[200];
- strcpy(path2, path);
- strcat(path2, ".rtf");
- f = fopen(path2, "r");
- if (!f)
- error_handler("Cannot open input file");
- }
- }
-
- if (verbose_mode || debug_mode) fprintf(stderr, "Processing %s...\n", path);
-
- /* Keep track of lines processed. This is arbitrary to the user as
- * RTF ignores newlines. May be helpful in error tracking. */
- lineno = 0;
+ else {
+ if (*argv[i] == '-') usage();
- /* All the work starts here. word_read() should keep reading words until
- * the end of the file. */
- word = word_read(f);
+ if (path)
+ usage();
+ else
+ path = argv[i];
+ }
+ }
- if (dump_mode) {
- word_dump(word);
- printf("\n");
- } else {
-/* Should we also optimize word before dump? - AF */
- word = optimize_word(word);
- word_print(word);
- }
+ if (show_version) {
+ fprintf(stderr, "%s\n", PACKAGE_VERSION);
+ fprintf(stderr, "search path is: %s\n",
+ (unrtf_options.config_directory
+ ? unrtf_options.config_directory : DEFAULT_UNRTF_SEARCH_PATH));
+ exit(0);
+ }
- fclose(f);
+ /* Program information */
+ if (unrtf_options.verbose_mode || unrtf_options.debug_mode) {
+ fprintf(stderr, "This is UnRTF ");
+ fprintf(stderr, "version %s\n", PACKAGE_VERSION);
+ fprintf(stderr, "By Dave Davey, Marcos Serrou do Amaral and Arkadiusz Firus\n");
+ fprintf(stderr, "Original Author: Zachary Smith\n");
+ fprintf(stderr, "Configuration directory: %s\n",
+ (unrtf_options.config_directory
+ ? unrtf_options.config_directory
+ : DEFAULT_UNRTF_SEARCH_PATH));
+ }
- /* marcossamaral - 0.19.9 */
- if(verbose_mode || debug_mode) {
- unsigned long total=0;
- total = hash_stats();
- fprintf(stderr, "Done.\n");
- fprintf(stderr, "%lu words were hashed.\n", total);
- }
+ if (unrtf_options.debug_mode) fprintf(stderr, "Debug mode.\n");
+ if (unrtf_options.dump_mode) fprintf(stderr, "Dump mode.\n");
- if (debug_mode) {
- fprintf(stderr, "Total memory allocated %ld bytes.\n",
- total_malloced());
- }
+ /* Check file access for reading. Append ".rtf" to file name if not supplied. */
+ if (path && access(path, R_OK) != 0) {
+ path_len = strlen(path);
+ old_path = path;
+ path = malloc (path_len + 5);
+ sprintf (path, "%s.rtf", old_path);
+ if (access(path, R_OK) != 0) {
+ free (path);
+ fprintf (stderr, "Cannot access input file.\n");
+ exit (10);
+ }
+ free_path = 1;
+ }
- /* May as well */
- word_free(word);
+ unrtf_convert_from_filename (&unrtf_options, path);
+ if (free_path)
+ free (path);
- return 0;
+ return 0;
}
-
diff -durpN unrtf-0.21.2.old/src/main.h unrtf-0.21.2/src/main.h
--- unrtf-0.21.2.old/src/main.h 2010-07-04 04:30:58.000000000 +0200
+++ unrtf-0.21.2/src/main.h 2013-01-17 02:41:09.685864239 +0100
@@ -35,21 +35,8 @@
* 17 Jan 10, daved@physiol.usyd.edu.au: change CONFIG_DIR to drop outputs/
*--------------------------------------------------------------------*/
-
-extern int lineno;
-extern int debug_mode;
-extern int simple_mode;
-extern int inline_mode;
-extern int no_remap_mode;
-
-
#ifndef _OUTPUT
#include "output.h"
#endif
-#define CONFIG_DIR "/usr/local/lib/unrtf/"
-#define DEFAULT_OUTPUT "html"
-
-extern OutputPersonality *op;
-
-
+#define USAGE "unrtf [--version] [--verbose] [--help] [--nopict|-n] [--noremap] [--html] [--text] [--vt] [--latex] [--rtf] [-P config_search_path] [-t <file_with_tags>)] <filename>"
diff -durpN unrtf-0.21.2.old/src/Makefile unrtf-0.21.2/src/Makefile
--- unrtf-0.21.2.old/src/Makefile 1970-01-01 01:00:00.000000000 +0100
+++ unrtf-0.21.2/src/Makefile 2013-01-17 02:52:06.525835400 +0100
@@ -0,0 +1,494 @@
+# Makefile.in generated by automake 1.11.1 from Makefile.am.
+# src/Makefile. Generated from Makefile.in by configure.
+
+# Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
+# 2003, 2004, 2005, 2006, 2007, 2008, 2009 Free Software Foundation,
+# Inc.
+# This Makefile.in is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
+# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+# PARTICULAR PURPOSE.
+
+
+
+# This is the Makefile.am that deals with the program proper.
+# It all works automagically.
+
+
+pkgdatadir = $(datadir)/unrtf
+pkgincludedir = $(includedir)/unrtf
+pkglibdir = $(libdir)/unrtf
+pkglibexecdir = $(libexecdir)/unrtf
+am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd
+install_sh_DATA = $(install_sh) -c -m 644
+install_sh_PROGRAM = $(install_sh) -c
+install_sh_SCRIPT = $(install_sh) -c
+INSTALL_HEADER = $(INSTALL_DATA)
+transform = $(program_transform_name)
+NORMAL_INSTALL = :
+PRE_INSTALL = :
+POST_INSTALL = :
+NORMAL_UNINSTALL = :
+PRE_UNINSTALL = :
+POST_UNINSTALL = :
+build_triplet = x86_64-unknown-linux-gnu
+host_triplet = x86_64-unknown-linux-gnu
+bin_PROGRAMS = unrtf$(EXEEXT)
+subdir = src
+DIST_COMMON = $(srcdir)/Makefile.am $(srcdir)/Makefile.in
+ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
+am__aclocal_m4_deps = $(top_srcdir)/configure.ac
+am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
+ $(ACLOCAL_M4)
+mkinstalldirs = $(install_sh) -d
+CONFIG_HEADER = $(top_builddir)/config.h
+CONFIG_CLEAN_FILES =
+CONFIG_CLEAN_VPATH_FILES =
+am__installdirs = "$(DESTDIR)$(bindir)"
+PROGRAMS = $(bin_PROGRAMS)
+am_unrtf_OBJECTS = attr.$(OBJEXT) convert.$(OBJEXT) error.$(OBJEXT) \
+ hash.$(OBJEXT) my_iconv.$(OBJEXT) main.$(OBJEXT) \
+ malloc.$(OBJEXT) output.$(OBJEXT) parse.$(OBJEXT) \
+ path.$(OBJEXT) unicode.$(OBJEXT) user.$(OBJEXT) util.$(OBJEXT) \
+ word.$(OBJEXT)
+unrtf_OBJECTS = $(am_unrtf_OBJECTS)
+unrtf_LDADD = $(LDADD)
+DEFAULT_INCLUDES = -I. -I$(top_builddir)
+depcomp = $(SHELL) $(top_srcdir)/config/depcomp
+am__depfiles_maybe = depfiles
+am__mv = mv -f
+COMPILE = $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) \
+ $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)
+CCLD = $(CC)
+LINK = $(CCLD) $(AM_CFLAGS) $(CFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@
+SOURCES = $(unrtf_SOURCES)
+DIST_SOURCES = $(unrtf_SOURCES)
+ETAGS = etags
+CTAGS = ctags
+DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
+ACLOCAL = ${SHELL} /home/jkerihuel/Projects/sogo/OpenChange/unrtf-0.21.2/config/missing --run aclocal-1.11
+AMTAR = ${SHELL} /home/jkerihuel/Projects/sogo/OpenChange/unrtf-0.21.2/config/missing --run tar
+AUTOCONF = ${SHELL} /home/jkerihuel/Projects/sogo/OpenChange/unrtf-0.21.2/config/missing --run autoconf
+AUTOHEADER = ${SHELL} /home/jkerihuel/Projects/sogo/OpenChange/unrtf-0.21.2/config/missing --run autoheader
+AUTOMAKE = ${SHELL} /home/jkerihuel/Projects/sogo/OpenChange/unrtf-0.21.2/config/missing --run automake-1.11
+AWK = mawk
+CC = gcc
+CCDEPMODE = depmode=gcc3
+CFLAGS = -g -O2
+CPP = gcc -E
+CPPFLAGS =
+CYGPATH_W = echo
+DEFS = -DHAVE_CONFIG_H
+DEPDIR = .deps
+ECHO_C =
+ECHO_N = -n
+ECHO_T =
+EGREP = /bin/grep -E
+EXEEXT =
+GREP = /bin/grep
+INSTALL = /usr/bin/install -c
+INSTALL_DATA = ${INSTALL} -m 644
+INSTALL_PROGRAM = ${INSTALL}
+INSTALL_SCRIPT = ${INSTALL}
+INSTALL_STRIP_PROGRAM = $(install_sh) -c -s
+LDFLAGS =
+LIBOBJS =
+LIBS =
+LTLIBOBJS =
+MAINT = #
+MAKEINFO = ${SHELL} /home/jkerihuel/Projects/sogo/OpenChange/unrtf-0.21.2/config/missing --run makeinfo
+MKDIR_P = /bin/mkdir -p
+OBJEXT = o
+PACKAGE = unrtf
+PACKAGE_BUGREPORT = bug-unrtf@gnu.org
+PACKAGE_NAME = unrtf
+PACKAGE_STRING = unrtf 0.21.2
+PACKAGE_TARNAME = unrtf
+PACKAGE_VERSION = 0.21.2
+PATH_SEPARATOR = :
+SET_MAKE =
+SHELL = /bin/bash
+STRIP =
+VERSION = 0.21.2
+abs_builddir = /home/jkerihuel/Projects/sogo/OpenChange/unrtf-0.21.2/src
+abs_srcdir = /home/jkerihuel/Projects/sogo/OpenChange/unrtf-0.21.2/src
+abs_top_builddir = /home/jkerihuel/Projects/sogo/OpenChange/unrtf-0.21.2
+abs_top_srcdir = /home/jkerihuel/Projects/sogo/OpenChange/unrtf-0.21.2
+ac_ct_CC = gcc
+am__include = include
+am__leading_dot = .
+am__quote =
+am__tar = ${AMTAR} chof - "$$tardir"
+am__untar = ${AMTAR} xf -
+bindir = ${exec_prefix}/bin
+build = x86_64-unknown-linux-gnu
+build_alias =
+build_cpu = x86_64
+build_os = linux-gnu
+build_vendor = unknown
+builddir = .
+datadir = ${datarootdir}
+datarootdir = ${prefix}/share
+docdir = ${datarootdir}/doc/${PACKAGE_TARNAME}
+dvidir = ${docdir}
+exec_prefix = ${prefix}
+host = x86_64-unknown-linux-gnu
+host_alias =
+host_cpu = x86_64
+host_os = linux-gnu
+host_vendor = unknown
+htmldir = ${docdir}
+includedir = ${prefix}/include
+infodir = ${datarootdir}/info
+install_sh = ${SHELL} /home/jkerihuel/Projects/sogo/OpenChange/unrtf-0.21.2/config/install-sh
+libdir = ${exec_prefix}/lib
+libexecdir = ${exec_prefix}/libexec
+localedir = ${datarootdir}/locale
+localstatedir = ${prefix}/var
+mandir = ${datarootdir}/man
+mkdir_p = /bin/mkdir -p
+oldincludedir = /usr/include
+pdfdir = ${docdir}
+prefix = /usr/local
+program_transform_name = s,x,x,
+psdir = ${docdir}
+sbindir = ${exec_prefix}/sbin
+sharedstatedir = ${prefix}/com
+srcdir = .
+sysconfdir = ${prefix}/etc
+target_alias =
+top_build_prefix = ../
+top_builddir = ..
+top_srcdir = ..
+unrtf_SOURCES = attr.c attr.h \
+ convert.c convert.h \
+ defs.h \
+ error.c error.h \
+ hash.c hash.h \
+ my_iconv.c my_iconv.h \
+ main.c main.h \
+ malloc.c malloc.h \
+ output.c output.h \
+ parse.c parse.h \
+ path.c path.h \
+ unicode.c unicode.h \
+ user.c user.h \
+ util.c util.h \
+ word.c word.h
+
+all: all-am
+
+.SUFFIXES:
+.SUFFIXES: .c .o .obj
+$(srcdir)/Makefile.in: # $(srcdir)/Makefile.am $(am__configure_deps)
+ @for dep in $?; do \
+ case '$(am__configure_deps)' in \
+ *$$dep*) \
+ ( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \
+ && { if test -f $@; then exit 0; else break; fi; }; \
+ exit 1;; \
+ esac; \
+ done; \
+ echo ' cd $(top_srcdir) && $(AUTOMAKE) --gnu src/Makefile'; \
+ $(am__cd) $(top_srcdir) && \
+ $(AUTOMAKE) --gnu src/Makefile
+.PRECIOUS: Makefile
+Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
+ @case '$?' in \
+ *config.status*) \
+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \
+ *) \
+ echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \
+ cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \
+ esac;
+
+$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)
+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+
+$(top_srcdir)/configure: # $(am__configure_deps)
+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+$(ACLOCAL_M4): # $(am__aclocal_m4_deps)
+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+$(am__aclocal_m4_deps):
+install-binPROGRAMS: $(bin_PROGRAMS)
+ @$(NORMAL_INSTALL)
+ test -z "$(bindir)" || $(MKDIR_P) "$(DESTDIR)$(bindir)"
+ @list='$(bin_PROGRAMS)'; test -n "$(bindir)" || list=; \
+ for p in $$list; do echo "$$p $$p"; done | \
+ sed 's/$(EXEEXT)$$//' | \
+ while read p p1; do if test -f $$p; \
+ then echo "$$p"; echo "$$p"; else :; fi; \
+ done | \
+ sed -e 'p;s,.*/,,;n;h' -e 's|.*|.|' \
+ -e 'p;x;s,.*/,,;s/$(EXEEXT)$$//;$(transform);s/$$/$(EXEEXT)/' | \
+ sed 'N;N;N;s,\n, ,g' | \
+ $(AWK) 'BEGIN { files["."] = ""; dirs["."] = 1 } \
+ { d=$$3; if (dirs[d] != 1) { print "d", d; dirs[d] = 1 } \
+ if ($$2 == $$4) files[d] = files[d] " " $$1; \
+ else { print "f", $$3 "/" $$4, $$1; } } \
+ END { for (d in files) print "f", d, files[d] }' | \
+ while read type dir files; do \
+ if test "$$dir" = .; then dir=; else dir=/$$dir; fi; \
+ test -z "$$files" || { \
+ echo " $(INSTALL_PROGRAM_ENV) $(INSTALL_PROGRAM) $$files '$(DESTDIR)$(bindir)$$dir'"; \
+ $(INSTALL_PROGRAM_ENV) $(INSTALL_PROGRAM) $$files "$(DESTDIR)$(bindir)$$dir" || exit $$?; \
+ } \
+ ; done
+
+uninstall-binPROGRAMS:
+ @$(NORMAL_UNINSTALL)
+ @list='$(bin_PROGRAMS)'; test -n "$(bindir)" || list=; \
+ files=`for p in $$list; do echo "$$p"; done | \
+ sed -e 'h;s,^.*/,,;s/$(EXEEXT)$$//;$(transform)' \
+ -e 's/$$/$(EXEEXT)/' `; \
+ test -n "$$list" || exit 0; \
+ echo " ( cd '$(DESTDIR)$(bindir)' && rm -f" $$files ")"; \
+ cd "$(DESTDIR)$(bindir)" && rm -f $$files
+
+clean-binPROGRAMS:
+ -test -z "$(bin_PROGRAMS)" || rm -f $(bin_PROGRAMS)
+unrtf$(EXEEXT): $(unrtf_OBJECTS) $(unrtf_DEPENDENCIES)
+ @rm -f unrtf$(EXEEXT)
+ $(LINK) $(unrtf_OBJECTS) $(unrtf_LDADD) $(LIBS)
+
+mostlyclean-compile:
+ -rm -f *.$(OBJEXT)
+
+distclean-compile:
+ -rm -f *.tab.c
+
+include ./$(DEPDIR)/attr.Po
+include ./$(DEPDIR)/convert.Po
+include ./$(DEPDIR)/error.Po
+include ./$(DEPDIR)/hash.Po
+include ./$(DEPDIR)/main.Po
+include ./$(DEPDIR)/malloc.Po
+include ./$(DEPDIR)/my_iconv.Po
+include ./$(DEPDIR)/output.Po
+include ./$(DEPDIR)/parse.Po
+include ./$(DEPDIR)/path.Po
+include ./$(DEPDIR)/unicode.Po
+include ./$(DEPDIR)/user.Po
+include ./$(DEPDIR)/util.Po
+include ./$(DEPDIR)/word.Po
+
+.c.o:
+ $(COMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $<
+ $(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po
+# source='$<' object='$@' libtool=no \
+# DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) \
+# $(COMPILE) -c $<
+
+.c.obj:
+ $(COMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ `$(CYGPATH_W) '$<'`
+ $(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po
+# source='$<' object='$@' libtool=no \
+# DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) \
+# $(COMPILE) -c `$(CYGPATH_W) '$<'`
+
+ID: $(HEADERS) $(SOURCES) $(LISP) $(TAGS_FILES)
+ list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
+ unique=`for i in $$list; do \
+ if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+ done | \
+ $(AWK) '{ files[$$0] = 1; nonempty = 1; } \
+ END { if (nonempty) { for (i in files) print i; }; }'`; \
+ mkid -fID $$unique
+tags: TAGS
+
+TAGS: $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \
+ $(TAGS_FILES) $(LISP)
+ set x; \
+ here=`pwd`; \
+ list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
+ unique=`for i in $$list; do \
+ if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+ done | \
+ $(AWK) '{ files[$$0] = 1; nonempty = 1; } \
+ END { if (nonempty) { for (i in files) print i; }; }'`; \
+ shift; \
+ if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \
+ test -n "$$unique" || unique=$$empty_fix; \
+ if test $$# -gt 0; then \
+ $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
+ "$$@" $$unique; \
+ else \
+ $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
+ $$unique; \
+ fi; \
+ fi
+ctags: CTAGS
+CTAGS: $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \
+ $(TAGS_FILES) $(LISP)
+ list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
+ unique=`for i in $$list; do \
+ if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+ done | \
+ $(AWK) '{ files[$$0] = 1; nonempty = 1; } \
+ END { if (nonempty) { for (i in files) print i; }; }'`; \
+ test -z "$(CTAGS_ARGS)$$unique" \
+ || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
+ $$unique
+
+GTAGS:
+ here=`$(am__cd) $(top_builddir) && pwd` \
+ && $(am__cd) $(top_srcdir) \
+ && gtags -i $(GTAGS_ARGS) "$$here"
+
+distclean-tags:
+ -rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags
+
+distdir: $(DISTFILES)
+ @srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
+ topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
+ list='$(DISTFILES)'; \
+ dist_files=`for file in $$list; do echo $$file; done | \
+ sed -e "s|^$$srcdirstrip/||;t" \
+ -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \
+ case $$dist_files in \
+ */*) $(MKDIR_P) `echo "$$dist_files" | \
+ sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \
+ sort -u` ;; \
+ esac; \
+ for file in $$dist_files; do \
+ if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \
+ if test -d $$d/$$file; then \
+ dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \
+ if test -d "$(distdir)/$$file"; then \
+ find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
+ fi; \
+ if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \
+ cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \
+ find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
+ fi; \
+ cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \
+ else \
+ test -f "$(distdir)/$$file" \
+ || cp -p $$d/$$file "$(distdir)/$$file" \
+ || exit 1; \
+ fi; \
+ done
+check-am: all-am
+check: check-am
+all-am: Makefile $(PROGRAMS)
+installdirs:
+ for dir in "$(DESTDIR)$(bindir)"; do \
+ test -z "$$dir" || $(MKDIR_P) "$$dir"; \
+ done
+install: install-am
+install-exec: install-exec-am
+install-data: install-data-am
+uninstall: uninstall-am
+
+install-am: all-am
+ @$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
+
+installcheck: installcheck-am
+install-strip:
+ $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
+ install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
+ `test -z '$(STRIP)' || \
+ echo "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'"` install
+mostlyclean-generic:
+
+clean-generic:
+
+distclean-generic:
+ -test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES)
+ -test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES)
+
+maintainer-clean-generic:
+ @echo "This command is intended for maintainers to use"
+ @echo "it deletes files that may require special tools to rebuild."
+clean: clean-am
+
+clean-am: clean-binPROGRAMS clean-generic mostlyclean-am
+
+distclean: distclean-am
+ -rm -rf ./$(DEPDIR)
+ -rm -f Makefile
+distclean-am: clean-am distclean-compile distclean-generic \
+ distclean-tags
+
+dvi: dvi-am
+
+dvi-am:
+
+html: html-am
+
+html-am:
+
+info: info-am
+
+info-am:
+
+install-data-am:
+
+install-dvi: install-dvi-am
+
+install-dvi-am:
+
+install-exec-am: install-binPROGRAMS
+
+install-html: install-html-am
+
+install-html-am:
+
+install-info: install-info-am
+
+install-info-am:
+
+install-man:
+
+install-pdf: install-pdf-am
+
+install-pdf-am:
+
+install-ps: install-ps-am
+
+install-ps-am:
+
+installcheck-am:
+
+maintainer-clean: maintainer-clean-am
+ -rm -rf ./$(DEPDIR)
+ -rm -f Makefile
+maintainer-clean-am: distclean-am maintainer-clean-generic
+
+mostlyclean: mostlyclean-am
+
+mostlyclean-am: mostlyclean-compile mostlyclean-generic
+
+pdf: pdf-am
+
+pdf-am:
+
+ps: ps-am
+
+ps-am:
+
+uninstall-am: uninstall-binPROGRAMS
+
+.MAKE: install-am install-strip
+
+.PHONY: CTAGS GTAGS all all-am check check-am clean clean-binPROGRAMS \
+ clean-generic ctags distclean distclean-compile \
+ distclean-generic distclean-tags distdir dvi dvi-am html \
+ html-am info info-am install install-am install-binPROGRAMS \
+ install-data install-data-am install-dvi install-dvi-am \
+ install-exec install-exec-am install-html install-html-am \
+ install-info install-info-am install-man install-pdf \
+ install-pdf-am install-ps install-ps-am install-strip \
+ installcheck installcheck-am installdirs maintainer-clean \
+ maintainer-clean-generic mostlyclean mostlyclean-compile \
+ mostlyclean-generic pdf pdf-am ps ps-am tags uninstall \
+ uninstall-am uninstall-binPROGRAMS
+
+
+# Tell versions [3.59,3.63) of GNU make to not export all variables.
+# Otherwise a system limit (for SysV at least) may be exceeded.
+.NOEXPORT:
diff -durpN unrtf-0.21.2.old/src/Makefile.am unrtf-0.21.2/src/Makefile.am
--- unrtf-0.21.2.old/src/Makefile.am 2010-07-04 04:30:58.000000000 +0200
+++ unrtf-0.21.2/src/Makefile.am 2013-01-17 02:41:09.685864239 +0100
@@ -13,7 +13,6 @@ unrtf_SOURCES = attr.c attr.h \
malloc.c malloc.h \
output.c output.h \
parse.c parse.h \
- path.c path.h \
unicode.c unicode.h \
user.c user.h \
util.c util.h \
diff -durpN unrtf-0.21.2.old/src/malloc.c unrtf-0.21.2/src/malloc.c
--- unrtf-0.21.2.old/src/malloc.c 2010-07-09 07:13:05.000000000 +0200
+++ unrtf-0.21.2/src/malloc.c 2013-01-17 02:41:09.685864239 +0100
@@ -28,6 +28,8 @@
* much memory is being used.
*----------------------------------------------------------------------
* Changes:
+ * 21 Aug 12, wsourdeau@inverse.ca: renamed "my_*" to "unrtf_*", to
+ * avoid symbol classes with other libraries
* 14 Aug 01, tuorfa@yahoo.com: added Turbo C support.
* 16 Aug 01, Lars Unger <l.unger@tu-bs.de>: added Amiga/GCC support.
* 22 Sep 01, tuorfa@yahoo.com: added function-level comment blocks
@@ -35,7 +37,7 @@
* 08 Oct 03, daved@physiol.usyd.edu.au: added stdlib.h for linux
* 29 Mar 05, daved@physiol.usyd.edu.au: changes requested by ZT Smith
* 16 Dec 07, daved@physiol.usyd.edu.au: updated to GPL v3
- * 09 Nov 08, arkadiusz.firus@gmail.com: added my_realloc
+ * 09 Nov 08, arkadiusz.firus@gmail.com: added unrtf_realloc
*--------------------------------------------------------------------*/
#ifdef HAVE_CONFIG_H
@@ -60,14 +62,14 @@
static unsigned long count=0;
/*========================================================================
- * Name: my_malloc
+ * Name: unrtf_malloc
* Purpose: Internal version of malloc necessary for record keeping.
* Args: Amount.
* Returns: Pointer.
*=======================================================================*/
char *
-my_malloc (unsigned long size) {
+unrtf_malloc (unsigned long size) {
char *ptr;
ptr = malloc (size);
@@ -78,14 +80,14 @@ my_malloc (unsigned long size) {
}
/*========================================================================
- * Name: my_free
+ * Name: unrtf_free
* Purpose: Internal version of free necessary for record keeping.
* Args: Pointer.
* Returns: None.
*=======================================================================*/
void
-my_free (char* ptr) {
+unrtf_free (char* ptr) {
CHECK_PARAM_NOT_NULL(ptr);
free (ptr);
@@ -93,20 +95,20 @@ my_free (char* ptr) {
#if 1 /* AK3 - AF */
/*========================================================================
- * Name: my_realloc
+ * Name: unrtf_realloc
* Purpose: Internal version of realloc necessary for record keeping.
* Args: Pointer.
* Returns: None.
*=======================================================================*/
char *
-my_realloc(char *ptr, unsigned long old_size, unsigned long new_size)
+unrtf_realloc(char *ptr, unsigned long old_size, unsigned long new_size)
{
- char *new_ptr = my_malloc(new_size);
+ char *new_ptr = unrtf_malloc(new_size);
if (new_ptr != NULL)
memcpy(new_ptr, ptr, old_size);
- my_free(ptr);
+ unrtf_free(ptr);
return new_ptr;
}
@@ -128,26 +130,26 @@ total_malloced (void) {
/*========================================================================
- * Name: my_strdup
+ * Name: unrtf_strdup
* Purpose: Internal version of strdup necessary for record keeping.
* Args: String.
* Returns: String.
*=======================================================================*/
char *
-my_strdup (char *src) {
- unsigned long len;
- char *ptr;
+unrtf_strdup (struct ConversionContext *cc, char *src) {
+ unsigned long len;
+ char *ptr;
- CHECK_PARAM_NOT_NULL(src);
+ CHECK_PARAM_NOT_NULL(src);
- len = strlen(src);
- ptr = my_malloc (len+1);
- if (!ptr)
- error_handler ("out of memory in strdup()");
+ len = strlen(src);
+ ptr = unrtf_malloc (len+1);
+ if (!ptr)
+ error_handler (cc, "out of memory in strdup()");
- strcpy (ptr, src);
- return ptr;
+ sprintf (ptr, "%s", src);
+ return ptr;
}
/* added by daved */
#include <sys/types.h>
@@ -163,5 +165,5 @@ rpl_malloc (size_t n)
{
if (n == 0)
n = 1;
-return malloc (n);
+ return malloc (n);
}
diff -durpN unrtf-0.21.2.old/src/malloc.c.orig unrtf-0.21.2/src/malloc.c.orig
--- unrtf-0.21.2.old/src/malloc.c.orig 2010-07-04 04:30:58.000000000 +0200
+++ unrtf-0.21.2/src/malloc.c.orig 1970-01-01 01:00:00.000000000 +0100
@@ -1,152 +0,0 @@
-/*=============================================================================
- GNU UnRTF, a command-line program to convert RTF documents to other formats.
- Copyright (C) 2000,2001,2004 by Zachary Smith
-
- 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, write to the Free Software
- Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
-
- The maintainer is reachable by electronic mail at daved@physiol.usyd.edu.au
-=============================================================================*/
-
-
-/*----------------------------------------------------------------------
- * Module name: malloc
- * Author name: Zachary Smith
- * Create date: 01 Aug 01
- * Purpose: Memory management. Allows us to keep track of how
- * much memory is being used.
- *----------------------------------------------------------------------
- * Changes:
- * 14 Aug 01, tuorfa@yahoo.com: added Turbo C support.
- * 16 Aug 01, Lars Unger <l.unger@tu-bs.de>: added Amiga/GCC support.
- * 22 Sep 01, tuorfa@yahoo.com: added function-level comment blocks
- * 28 Sep 01, tuorfa@yahoo.com: removed Turbo C support.
- * 08 Oct 03, daved@physiol.usyd.edu.au: added stdlib.h for linux
- * 29 Mar 05, daved@physiol.usyd.edu.au: changes requested by ZT Smith
- * 16 Dec 07, daved@physiol.usyd.edu.au: updated to GPL v3
- * 09 Nov 08, arkadiusz.firus@gmail.com: added my_realloc
- *--------------------------------------------------------------------*/
-
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
-#ifdef HAVE_STDIO_H
-#include <stdio.h>
-#endif
-
-#ifdef HAVE_STDLIB_H
-#include <stdlib.h>
-#endif
-
-#ifdef HAVE_STRING_H
-#include <string.h>
-#endif
-
-#include "error.h"
-#include "malloc.h"
-
-static unsigned long count=0;
-
-/*========================================================================
- * Name: my_malloc
- * Purpose: Internal version of malloc necessary for record keeping.
- * Args: Amount.
- * Returns: Pointer.
- *=======================================================================*/
-
-char *
-my_malloc (unsigned long size) {
- char *ptr;
-
- ptr = malloc (size);
- if (ptr)
- count += size;
-
- return ptr;
-}
-
-/*========================================================================
- * Name: my_free
- * Purpose: Internal version of free necessary for record keeping.
- * Args: Pointer.
- * Returns: None.
- *=======================================================================*/
-
-void
-my_free (char* ptr) {
- CHECK_PARAM_NOT_NULL(ptr);
-
- free (ptr);
-}
-
-#if 1 /* AK3 - AF */
-/*========================================================================
- * Name: my_realloc
- * Purpose: Internal version of realloc necessary for record keeping.
- * Args: Pointer.
- * Returns: None.
- *=======================================================================*/
-char *
-my_realloc(char *ptr, unsigned long old_size, unsigned long new_size)
-{
- char *new_ptr = my_malloc(new_size);
-
- if (new_ptr != NULL)
- memcpy(new_ptr, ptr, old_size);
-
- my_free(ptr);
-
- return new_ptr;
-}
-#endif
-
-/*========================================================================
- * Name: total_malloced
- * Purpose: Returns total amount of memory thus far allocated. Called at
- * the end of main() when in debug mode.
- * Args: None.
- * Returns: Amount.
- *=======================================================================*/
-
-unsigned long
-total_malloced (void) {
- return count;
-}
-
-
-
-/*========================================================================
- * Name: my_strdup
- * Purpose: Internal version of strdup necessary for record keeping.
- * Args: String.
- * Returns: String.
- *=======================================================================*/
-
-char *
-my_strdup (char *src) {
- unsigned long len;
- char *ptr;
-
- CHECK_PARAM_NOT_NULL(src);
-
- len = strlen(src);
- ptr = my_malloc (len+1);
- if (!ptr)
- error_handler ("out of memory in strdup()");
-
- strcpy (ptr, src);
- return ptr;
-}
-
diff -durpN unrtf-0.21.2.old/src/malloc.h unrtf-0.21.2/src/malloc.h
--- unrtf-0.21.2.old/src/malloc.h 2010-07-04 04:30:58.000000000 +0200
+++ unrtf-0.21.2/src/malloc.h 2013-01-17 02:41:09.685864239 +0100
@@ -32,9 +32,10 @@
* 09 Nov 08, arkadiusz.firus@gmail.com: added my_realloc
*--------------------------------------------------------------------*/
-extern char * my_malloc (unsigned long);
-extern void my_free (char*);
-extern char * my_realloc(char*, unsigned long, unsigned long);
-extern unsigned long total_malloced (void);
-extern char * my_strdup (char*);
+struct ConversionContext;
+extern char * unrtf_malloc (unsigned long);
+extern void unrtf_free (char*);
+extern char * unrtf_realloc(char*, unsigned long, unsigned long);
+extern unsigned long total_malloced (void);
+extern char * unrtf_strdup (struct ConversionContext *, char*);
diff -durpN unrtf-0.21.2.old/src/my_iconv.c unrtf-0.21.2/src/my_iconv.c
--- unrtf-0.21.2.old/src/my_iconv.c 2010-08-16 06:12:43.000000000 +0200
+++ unrtf-0.21.2/src/my_iconv.c 2013-01-17 02:41:09.685864239 +0100
@@ -12,154 +12,133 @@
#include <stdio.h>
#include <string.h>
-#include "malloc.h"
-#include "my_iconv.h"
-#include "util.h"
#if 1 /* daved 0.21.1 */
#include "unicode.h"
-#include "path.h"
#include <unistd.h>
#include <stdlib.h>
#endif
-extern int verbose_mode;
+#include "convert.h"
+#include "malloc.h"
+#include "my_iconv.h"
+#include "util.h"
+#include "unrtf.h"
+
+#define MY_ICONV_T_CLEAR {(iconv_t) -1, NULL}
my_iconv_t
-my_iconv_open(const char *tocode, const char *fromcode)
+my_iconv_open(const struct ConversionContext *cc, const char *tocode, const char *fromcode)
{
- char *path;
- FILE *f;
- my_iconv_t cd = MY_ICONV_T_CLEAR;
- int c, i;
+ char *path;
+ FILE *f;
+ my_iconv_t cd = MY_ICONV_T_CLEAR;
+ int c, i;
- if ((cd.desc = iconv_open(tocode, fromcode)) == (iconv_t) -1)
- {
-#if 1 /* daved 0.21.1 */
- struct path_dir *path_dir_p;
- char u_success=0;
- for(path_dir_p = &topdir; path_dir_p->dir_name; path_dir_p = path_dir_p->next)
- {
- char *p;
- p = path_dir_p->dir_name;
- if(*(p+strlen(p)-1) != '/')
- p = concatenate(p, "/");
- p = concatenate(p, fromcode);
- path=concatenate(p, ".charmap");
- if(access(path, F_OK|R_OK))
- continue;
- u_success++;
- break;
- }
- if(!u_success)
- {
-#else
- path = concatenate(CHARMAP_DIR, fromcode);
-#endif
-#if 1 /* daved 0.21.1 */
- }
- if((f = fopen(path, "r")) == NULL && verbose_mode)
- fprintf(stderr, "failed to open charmap file %s\n", path);
-#else
- f = fopen(path, "r");
-#endif
+ if ((cd.desc = iconv_open(tocode, fromcode)) == (iconv_t) -1)
+ {
+ path = unrtf_malloc((strlen(cc->options->config_directory) + strlen(fromcode) + 10) * sizeof(char));
+ sprintf (path, "%s/%s.charmap", cc->options->config_directory, fromcode);
- if (f != NULL)
- {
- cd.char_table = (char **)my_malloc(char_table_size * sizeof(char *));
- c = fgetc(f);
+ if((f = fopen(path, "r")) == NULL && cc->options->verbose_mode)
+ fprintf(stderr, "failed to open charmap file %s\n", path);
- for (i = 0; i < char_table_size && c != EOF; i++)
- {
- if (c == '<')
- cd.char_table[i] = get_unicode_char(f);
- leave_line(f);
- c = fgetc(f);
- }
+ if (f != NULL)
+ {
+ cd.char_table = (char **)unrtf_malloc(char_table_size * sizeof(char *));
+ c = fgetc(f);
- fclose(f);
- }
+ for (i = 0; i < char_table_size && c != EOF; i++)
+ {
+ if (c == '<')
+ cd.char_table[i] = get_unicode_char(f);
+ leave_line(f);
+ c = fgetc(f);
+ }
- my_free(path);
- }
+ fclose(f);
+ }
- return cd;
+ unrtf_free(path);
+ }
+
+ return cd;
}
size_t
my_iconv(my_iconv_t cd, char **inbuf, size_t *inbytesleft, char **outbuf, size_t *outbytesleft)
{
- int c, i;
- size_t result = 0;
+ int c, i;
+ size_t result = 0;
- if (cd.desc == (iconv_t) -1) {
- if (cd.char_table != NULL)
- {
- while (*inbytesleft > 0 && *outbytesleft > 0)
- {
- c = (int) **inbuf;
- if (c < 0)
- c = 256 + c;
+ if (cd.desc == (iconv_t) -1) {
+ if (cd.char_table != NULL)
+ {
+ while (*inbytesleft > 0 && *outbytesleft > 0)
+ {
+ c = (int) **inbuf;
+ if (c < 0)
+ c = 256 + c;
- if (cd.char_table[c] != NULL)
- {
- for (i = 0; cd.char_table[c][i] != '\0' && *outbytesleft > 0; i++)
- {
- **outbuf = cd.char_table[c][i];
- (*outbytesleft)--;
- (*outbuf)++;
- }
- }
+ if (cd.char_table[c] != NULL)
+ {
+ for (i = 0; cd.char_table[c][i] != '\0' && *outbytesleft > 0; i++)
+ {
+ **outbuf = cd.char_table[c][i];
+ (*outbytesleft)--;
+ (*outbuf)++;
+ }
+ }
- (*inbuf)++;
- (*inbytesleft)--;
- result++;
- }
- }
- }
- else
- result = iconv(cd.desc, inbuf, inbytesleft, outbuf, outbytesleft);
+ (*inbuf)++;
+ (*inbytesleft)--;
+ result++;
+ }
+ }
+ }
+ else
+ result = iconv(cd.desc, inbuf, inbytesleft, outbuf, outbytesleft);
- return result;
+ return result;
}
my_iconv_t
my_iconv_close(my_iconv_t cd)
{
- int i;
+ int i;
- if (cd.char_table != NULL)
- {
- for (i = 0; i < char_table_size; i++)
- {
- my_free(cd.char_table[i]);
- }
+ if (cd.char_table != NULL)
+ {
+ for (i = 0; i < char_table_size; i++)
+ {
+ unrtf_free(cd.char_table[i]);
+ }
- my_free((void *)cd.char_table);
- cd.char_table = NULL;
- }
+ unrtf_free((void *)cd.char_table);
+ cd.char_table = NULL;
+ }
- if (cd.desc != (iconv_t) -1)
- {
- iconv_close(cd.desc);
- cd.desc = (iconv_t) -1;
- }
+ if (cd.desc != (iconv_t) -1)
+ {
+ iconv_close(cd.desc);
+ cd.desc = (iconv_t) -1;
+ }
- return cd;
+ return cd;
}
int
my_iconv_is_valid (my_iconv_t cd)
{
- if (cd.desc != (iconv_t) -1 || cd.char_table != NULL)
- return 1;
+ if (cd.desc != (iconv_t) -1 || cd.char_table != NULL)
+ return 1;
- return 0;
+ return 0;
}
void
my_iconv_t_make_invalid(my_iconv_t *cd)
{
- cd->desc = (iconv_t) -1;
- cd->char_table = NULL;
+ cd->desc = (iconv_t) -1;
+ cd->char_table = NULL;
}
diff -durpN unrtf-0.21.2.old/src/my_iconv.h unrtf-0.21.2/src/my_iconv.h
--- unrtf-0.21.2.old/src/my_iconv.h 2010-07-04 04:30:58.000000000 +0200
+++ unrtf-0.21.2/src/my_iconv.h 2013-01-17 02:41:09.685864239 +0100
@@ -5,6 +5,9 @@
* Purpose: my_conv definitions
*--------------------------------------------------------------------*/
+#ifndef _MY_ICONV
+#define _MY_ICONV 1
+
#ifndef HAVE_ICONV_H
#include <iconv.h>
#define HAVE_ICONV_H
@@ -19,9 +22,9 @@ typedef struct
char **char_table;
} my_iconv_t;
-#define MY_ICONV_T_CLEAR {(iconv_t) -1, NULL}
+struct ConversionContext;
-my_iconv_t my_iconv_open(const char *tocode, const char *fromcode);
+my_iconv_t my_iconv_open(const struct ConversionContext *cc, const char *tocode, const char *fromcode);
size_t my_iconv(my_iconv_t cd, char **inbuf, size_t *inbytesleft, char **outbuf, size_t *outbytesleft);
@@ -31,3 +34,4 @@ int my_iconv_is_valid(my_iconv_t cd);
void my_iconv_t_make_invalid(my_iconv_t *cd);
+#endif /* _MY_ICONV */
diff -durpN unrtf-0.21.2.old/src/output.c unrtf-0.21.2/src/output.c
--- unrtf-0.21.2.old/src/output.c 2011-06-07 14:04:38.000000000 +0200
+++ unrtf-0.21.2/src/output.c 2013-01-17 02:41:09.685864239 +0100
@@ -1,23 +1,23 @@
/*=============================================================================
- GNU UnRTF, a command-line program to convert RTF documents to other formats.
- Copyright (C) 2000,2001,2004 by Zachary Smith
+ GNU UnRTF, a command-line program to convert RTF documents to other formats.
+ Copyright (C) 2000,2001,2004 by Zachary Smith
- 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 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.
+ 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, write to the Free Software
- Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- The maintainer is reachable by electronic mail at daved@physiol.usyd.edu.au
-=============================================================================*/
+ The maintainer is reachable by electronic mail at daved@physiol.usyd.edu.au
+ =============================================================================*/
/*----------------------------------------------------------------------
@@ -38,7 +38,7 @@
* David Santinoli
* 09 Nov 08, arkadiusz.firus@gmail.com: use iconv
* 21 Aug 10, daved@physiol.usyd.edu.au: add code to deal with character
- doublets (see convert.c)
+ doublets (see convert.c)
*--------------------------------------------------------------------*/
@@ -64,7 +64,8 @@
#include "output.h"
#include "main.h"
#include "convert.h"
-
+#include "unrtf.h"
+#include "user.h"
#ifndef HAVE_ATTR_H
#include "attr.h"
@@ -79,16 +80,16 @@
*=======================================================================*/
OutputPersonality*
-op_create ()
+op_create (const struct ConversionContext *cc)
{
- OutputPersonality* new_op;
+ OutputPersonality* new_op;
- new_op = (OutputPersonality*) my_malloc (sizeof(OutputPersonality));
- if (!new_op)
- error_handler ("cannot allocate output personality");
+ new_op = (OutputPersonality*) unrtf_malloc (sizeof(OutputPersonality));
+ if (!new_op)
+ error_handler (cc, "cannot allocate output personality");
- memset ((void*) new_op, 0, sizeof (OutputPersonality));
- return new_op;
+ memset ((void*) new_op, 0, sizeof (OutputPersonality));
+ return new_op;
}
/*========================================================================
@@ -102,13 +103,15 @@ op_create ()
void
op_free (OutputPersonality *op)
{
- CHECK_PARAM_NOT_NULL(op);
-
- my_free ((void*) op);
-}
+ CHECK_PARAM_NOT_NULL(op);
+ free_user_definitions(op);
+ if (op->aliases)
+ free_collection(op->aliases);
+ unrtf_free ((void*) op);
+}
/*========================================================================
* Name: op_translate_char
@@ -119,102 +122,113 @@ op_free (OutputPersonality *op)
*=======================================================================*/
char *
-op_translate_char (OutputPersonality *op, my_iconv_t cd, int ch)
+op_translate_char (const struct ConversionContext *cc, const OutputPersonality *op, int ch)
{
- short start;
- char *result=NULL;
- static char output_buffer[2]={ 0, 0 };
- char *inbuf, *outbuf;
- size_t inbytes = (ch / 256) + 1, outbytes = inbytes * 4, i;
+ char *result=NULL;
+ static char output_buffer[2]={ 0, 0 };
+ char *inbuf, *outbuf, *originbuf, *origoutbuf, *alias;
+ size_t inbytes = (ch / 256) + 1, outbytes = inbytes * 4, i;
+ my_iconv_t cd;
- CHECK_PARAM_NOT_NULL(op);
+ CHECK_PARAM_NOT_NULL(op);
- if (no_remap_mode == TRUE && ch < 256)
- {
- output_buffer[0]=ch;
- result=output_buffer;
- }
- else
- if (result == NULL)
- {
- inbuf = my_malloc(inbytes + 1);
- outbuf = my_malloc(outbytes + 1);
+ if (cc->options->no_remap_mode == TRUE && ch < 256)
+ {
+ output_buffer[0]=ch;
+ result=strdup(output_buffer);
+ }
+ else
+ if (result == NULL)
+ {
+ originbuf = inbuf = unrtf_malloc(inbytes + 1);
+ origoutbuf = outbuf = unrtf_malloc(outbytes + 1);
- for (i = inbytes - 1; ch > 255; i--)
- {
- inbuf[i] = ch % 256;
- ch /= 256;
- }
+ for (i = inbytes - 1; ch > 255; i--)
+ {
+ inbuf[i] = ch % 256;
+ ch /= 256;
+ }
- inbuf[0] = ch;
- inbuf[inbytes] = '\0';
- i = outbytes;
- if (!my_iconv_is_valid(cd))
- {
- cd = my_iconv_open("UTF-8", "cp1252");
+ inbuf[0] = ch;
+ inbuf[inbytes] = '\0';
+ i = outbytes;
+ if (!my_iconv_is_valid(cc->desc))
+ {
+ cd = my_iconv_open(cc, "UTF-8", "cp1252");
- if (my_iconv(cd, &inbuf, &inbytes, &outbuf, &outbytes) == -1)
- {
+ if (my_iconv(cd, &inbuf, &inbytes, &outbuf, &outbytes) == -1)
+ {
#if 1 /* daved */
- fprintf(stderr, "unrtf: Error in executing iconv1\n");
+ fprintf(stderr, "unrtf: Error in executing iconv1\n");
#else
- fprintf(stderr, "unrtf: Error in executing iconv1\n");
+ fprintf(stderr, "unrtf: Error in executing iconv1\n");
#endif
- return NULL;
- }
+ free (originbuf);
+ free (origoutbuf);
+ return NULL;
+ }
- my_iconv_close(cd);
- }
- else
+ my_iconv_close(cd);
+ }
+ else
- if (my_iconv(cd, &inbuf, &inbytes, &outbuf, &outbytes) == -1)
- {
- fprintf(stderr, "unrtf: Error in executing iconv\n");
- return NULL;
- }
- *outbuf = '\0';
- outbuf -= i - outbytes;
-/* Conversion from string to utf8 code number */
- inbytes = 0;
+ if (my_iconv(cc->desc, &inbuf, &inbytes, &outbuf, &outbytes) == -1)
+ {
+ fprintf(stderr, "unrtf: Error in executing iconv\n");
+ free (originbuf);
+ free (origoutbuf);
+ return NULL;
+ }
+ *outbuf = '\0';
+ outbuf -= i - outbytes;
+ /* Conversion from string to utf8 code number */
+ inbytes = 0;
- for (i = 0; outbuf[i] != '\0'; i++)
- inbytes++;
+ for (i = 0; outbuf[i] != '\0'; i++)
+ inbytes++;
- ch = 0;
+ ch = 0;
- for (i = 0; i < inbytes; i++)
- {
- if (i == 0)
- switch (inbytes)
- {
- case 1:
- ch = outbuf[0];
- break;
- case 2:
- ch = (unsigned char) outbuf[0] - 192;
- break;
- case 3:
- ch = (unsigned char) outbuf[0] - 224;
- break;
- case 4:
- ch = (unsigned char) outbuf[0] - 240;
- break;
- }
- else
- ch = (ch * 64) + ((unsigned char) outbuf[i] - 128);
- }
-/* End of conversion*/
+ for (i = 0; i < inbytes; i++)
+ {
+ if (i == 0)
+ switch (inbytes)
+ {
+ case 1:
+ ch = outbuf[0];
+ break;
+ case 2:
+ ch = (unsigned char) outbuf[0] - 192;
+ break;
+ case 3:
+ ch = (unsigned char) outbuf[0] - 224;
+ break;
+ case 4:
+ ch = (unsigned char) outbuf[0] - 240;
+ break;
+ }
+ else
+ ch = (ch * 64) + ((unsigned char) outbuf[i] - 128);
+ }
+ /* End of conversion*/
- result = get_alias(op, ch);
+ alias = get_alias(op, ch);
- if (result == NULL)
- if (ch > 127 && op->unisymbol_print)
- result = assemble_string(op->unisymbol_print, ch);
- else
- result = outbuf;
- }
+ if (alias == NULL)
+ {
+ if (ch > 127 && op->unisymbol_print)
+ result = assemble_string(op->unisymbol_print, ch);
+ else
+ result = strdup(outbuf);
+ }
+ else
+ result = strdup(alias);
- return result;
+ free (originbuf);
+ free (origoutbuf);
+ }
+
+ return result;
}
#if 0 /* daved - 0.21.2 */
@@ -227,123 +241,122 @@ op_translate_char (OutputPersonality *op
*=======================================================================*/
char *
-op_translate_str (OutputPersonality *op, my_iconv_t cd, int * doublet)
+op_translate_str (const struct ConversionContext *cc, OutputPersonality *op, my_iconv_t cd, int * doublet)
{
- short start;
- char *result=NULL;
- static char output_buffer[3]={ 0, 0, 0 };
- unsigned char *inbuf;
- char *outbuf;
- int ch;
+ char *result=NULL;
+ static char output_buffer[3]={ 0, 0, 0 };
+ unsigned char *inbuf;
+ char *outbuf;
+ int ch;
- fprintf(stderr, "doublet = %o %o\n", *doublet, *(doublet+1));
+ fprintf(stderr, "doublet = %o %o\n", *doublet, *(doublet+1));
#if 0
- size_t inbytes = (ch / 256) + 1, outbytes = inbytes * 4, i;
+ size_t inbytes = (ch / 256) + 1, outbytes = inbytes * 4, i;
#else
- size_t inbytes = 3, outbytes = inbytes * 4, i;
+ size_t inbytes = 3, outbytes = inbytes * 4, i;
#endif
- CHECK_PARAM_NOT_NULL(op);
+ CHECK_PARAM_NOT_NULL(op);
#if 0
- if (no_remap_mode == TRUE && ch < 256)
- {
- output_buffer[0]=ch;
- result=output_buffer;
- }
- else
- if (result == NULL)
- {
+ if (cc->options->no_remap_mode == TRUE && ch < 256)
+ {
+ output_buffer[0]=ch;
+ result=output_buffer;
+ }
+ else
+ if (result == NULL)
+ {
#endif
- inbuf = (char *) my_malloc(inbytes + 1);
- *inbuf = *doublet;
- *(inbuf+1) = (unsigned char *) *(doublet+1);
- *(inbuf+2) = 0;
- fprintf(stderr, "inbuf = %o %o\n", *inbuf, *(inbuf+1));
- outbuf = my_malloc(outbytes + 1);
+ inbuf = (char *) unrtf_malloc(inbytes + 1);
+ *inbuf = *doublet;
+ *(inbuf+1) = (unsigned char *) *(doublet+1);
+ *(inbuf+2) = 0;
+ fprintf(stderr, "inbuf = %o %o\n", *inbuf, *(inbuf+1));
+ outbuf = unrtf_malloc(outbytes + 1);
#if 0
- for (i = inbytes - 1; ch > 255; i--)
- {
- inbuf[i] = ch % 256;
- ch /= 256;
- }
+ for (i = inbytes - 1; ch > 255; i--)
+ {
+ inbuf[i] = ch % 256;
+ ch /= 256;
+ }
- inbuf[0] = ch;
- inbuf[inbytes] = '\0';
+ inbuf[0] = ch;
+ inbuf[inbytes] = '\0';
#endif
- i = outbytes;
- if (!my_iconv_is_valid(cd))
- {
- cd = my_iconv_open("UTF-8", "cp1252");
+ i = outbytes;
+ if (!my_iconv_is_valid(cd))
+ {
+ cd = my_iconv_open("UTF-8", "cp1252");
- if (my_iconv(cd, &inbuf, &inbytes, &outbuf, &outbytes) == -1)
- {
- fprintf(stderr, "unrtf: Error in executing iconv1\n");
- return NULL;
- }
+ if (my_iconv(cd, &inbuf, &inbytes, &outbuf, &outbytes) == -1)
+ {
+ fprintf(stderr, "unrtf: Error in executing iconv1\n");
+ return NULL;
+ }
- my_iconv_close(cd);
- }
- else
- {
+ my_iconv_close(cd);
+ }
+ else
+ {
- if (my_iconv(cd, &inbuf, &inbytes, &outbuf, &outbytes) == -1)
- {
+ if (my_iconv(cd, &inbuf, &inbytes, &outbuf, &outbytes) == -1)
+ {
#if 1 /* daved */
- fprintf(stderr, "unrtf: Error in executing iconv - inbytes=%d inbuf[0]=%o inbuf[1]=%o\n", inbytes, inbuf[0], inbuf[1]);
+ fprintf(stderr, "unrtf: Error in executing iconv - inbytes=%d inbuf[0]=%o inbuf[1]=%o\n", inbytes, inbuf[0], inbuf[1]);
#else
- fprintf(stderr, "unrtf: Error in executing iconv\n");
+ fprintf(stderr, "unrtf: Error in executing iconv\n");
#endif
- return NULL;
- }
- }
- *outbuf = '\0';
- outbuf -= i - outbytes;
-/* Conversion from string to utf8 code number */
- inbytes = 0;
+ return NULL;
+ }
+ }
+ *outbuf = '\0';
+ outbuf -= i - outbytes;
+ /* Conversion from string to utf8 code number */
+ inbytes = 0;
- for (i = 0; outbuf[i] != '\0'; i++)
- inbytes++;
+ for (i = 0; outbuf[i] != '\0'; i++)
+ inbytes++;
- ch = 0;
+ ch = 0;
- for (i = 0; i < inbytes; i++)
- {
- if (i == 0)
- switch (inbytes)
- {
- case 1:
- ch = outbuf[0];
- break;
- case 2:
- ch = (unsigned char) outbuf[0] - 192;
- break;
- case 3:
- ch = (unsigned char) outbuf[0] - 224;
- break;
- case 4:
- ch = (unsigned char) outbuf[0] - 240;
- break;
- }
- else
- ch = (ch * 64) + ((unsigned char) outbuf[i] - 128);
- }
-/* End of conversion*/
+ for (i = 0; i < inbytes; i++)
+ {
+ if (i == 0)
+ switch (inbytes)
+ {
+ case 1:
+ ch = outbuf[0];
+ break;
+ case 2:
+ ch = (unsigned char) outbuf[0] - 192;
+ break;
+ case 3:
+ ch = (unsigned char) outbuf[0] - 224;
+ break;
+ case 4:
+ ch = (unsigned char) outbuf[0] - 240;
+ break;
+ }
+ else
+ ch = (ch * 64) + ((unsigned char) outbuf[i] - 128);
+ }
+ /* End of conversion*/
- result = get_alias(op, ch);
+ result = get_alias(op, ch);
- if (result == NULL)
- if (ch > 127 && op->unisymbol_print)
- result = assemble_string(op->unisymbol_print, ch);
- else
- result = outbuf;
+ if (result == NULL)
+ if (ch > 127 && op->unisymbol_print)
+ result = assemble_string(op->unisymbol_print, ch);
+ else
+ result = outbuf;
#if 0 /* daved 0.21.2 */
- }
+ }
#endif
- return result;
+ return result;
}
#endif
@@ -357,113 +370,115 @@ op_translate_str (OutputPersonality *op,
*=======================================================================*/
char *
-op_translate_doublet (OutputPersonality *op, my_iconv_t cd, int ch1, int ch2)
+op_translate_doublet (const struct ConversionContext *cc, const OutputPersonality *op, int ch1, int ch2)
{
- short start;
- char *result=NULL;
- static char output_buffer[3]={ 0, 0, 0 };
- unsigned char *inbuf;
- char *outbuf;
- int ch;
+ char *result=NULL;
+ static char output_buffer[3]={ 0, 0, 0 };
+ char *inbuf;
+ char *outbuf;
+ int ch;
+ my_iconv_t cd;
#if 0
- size_t inbytes = (ch / 256) + 1, outbytes = inbytes * 4, i;
+ size_t inbytes = (ch / 256) + 1, outbytes = inbytes * 4, i;
#else
- size_t inbytes = 3, outbytes = inbytes * 4, i;
+ size_t inbytes = 3, outbytes = inbytes * 4, i;
#if 0
- fprintf(stderr, "doublet = %o %o\n", ch1, ch2);
+ fprintf(stderr, "doublet = %o %o\n", ch1, ch2);
#endif
#endif
- CHECK_PARAM_NOT_NULL(op);
+ CHECK_PARAM_NOT_NULL(op);
- if (no_remap_mode == TRUE && ch < 256)
- {
- output_buffer[0]=ch1;
- output_buffer[1]=ch2;
- result=output_buffer;
- }
- else
- if (result == NULL)
- {
- inbuf = (char *) my_malloc(inbytes + 1);
- *inbuf = ch1;
- *(inbuf+1) = ch2;
- *(inbuf+2) = 0;
+ if (cc->options->no_remap_mode == TRUE && ch < 256)
+ {
+ output_buffer[0]=ch1;
+ output_buffer[1]=ch2;
+ result=output_buffer;
+ }
+ else
+ if (result == NULL)
+ {
+ inbuf = (char *) unrtf_malloc(inbytes + 1);
+ *inbuf = ch1;
+ *(inbuf+1) = ch2;
+ *(inbuf+2) = 0;
#if 0
- fprintf(stderr, "inbuf = %o %o\n", *inbuf, *(inbuf+1));
+ fprintf(stderr, "inbuf = %o %o\n", *inbuf, *(inbuf+1));
#endif
- outbuf = my_malloc(outbytes + 1);
+ outbuf = unrtf_malloc(outbytes + 1);
- i = outbytes;
- if (!my_iconv_is_valid(cd))
- {
- cd = my_iconv_open("UTF-8", "cp1252");
+ i = outbytes;
+ if (!my_iconv_is_valid(cc->desc))
+ {
+ cd = my_iconv_open(cc, "UTF-8", "cp1252");
- if (my_iconv(cd, (char **)&inbuf, (size_t *)&inbytes, (char **)&outbuf, &outbytes) == -1)
- {
- fprintf(stderr, "unrtf: Error in executing iconv1\n");
- return NULL;
- }
+ if (my_iconv(cd, (char **)&inbuf, (size_t *)&inbytes, (char **)&outbuf, &outbytes) == -1)
+ {
+ fprintf(stderr, "unrtf: Error in executing iconv1\n");
+ return NULL;
+ }
- my_iconv_close(cd);
- }
- else
- {
+ my_iconv_close(cd);
+ }
+ else
+ {
- if (my_iconv(cd, (char **)&inbuf, (size_t *)&inbytes, (char **)&outbuf, &outbytes) == -1)
- {
+ if (my_iconv(cc->desc, (char **)&inbuf, (size_t *)&inbytes, (char **)&outbuf, &outbytes) == -1)
+ {
#if 1 /* daved */
- fprintf(stderr, "unrtf: Error in executing iconv - inbytes=%d inbuf[0]=%o inbuf[1]=%o\n", inbytes, inbuf[0], inbuf[1]);
+ fprintf(stderr, "unrtf: Error in executing iconv - inbytes=%d inbuf[0]=%o inbuf[1]=%o\n", inbytes, inbuf[0], inbuf[1]);
#else
- fprintf(stderr, "unrtf: Error in executing iconv\n");
+ fprintf(stderr, "unrtf: Error in executing iconv\n");
#endif
- return NULL;
- }
- }
- *outbuf = '\0';
- outbuf -= i - outbytes;
-/* Conversion from string to utf8 code number */
- inbytes = 0;
+ return NULL;
+ }
+ }
+ *outbuf = '\0';
+ outbuf -= i - outbytes;
+ /* Conversion from string to utf8 code number */
+ inbytes = 0;
- for (i = 0; outbuf[i] != '\0'; i++)
- inbytes++;
+ for (i = 0; outbuf[i] != '\0'; i++)
+ inbytes++;
- ch = 0;
+ ch = 0;
- for (i = 0; i < inbytes; i++)
- {
- if (i == 0)
- switch (inbytes)
- {
- case 1:
- ch = outbuf[0];
- break;
- case 2:
- ch = (unsigned char) outbuf[0] - 192;
- break;
- case 3:
- ch = (unsigned char) outbuf[0] - 224;
- break;
- case 4:
- ch = (unsigned char) outbuf[0] - 240;
- break;
- }
- else
- ch = (ch * 64) + ((unsigned char) outbuf[i] - 128);
- }
-/* End of conversion*/
+ for (i = 0; i < inbytes; i++)
+ {
+ if (i == 0)
+ switch (inbytes)
+ {
+ case 1:
+ ch = outbuf[0];
+ break;
+ case 2:
+ ch = (unsigned char) outbuf[0] - 192;
+ break;
+ case 3:
+ ch = (unsigned char) outbuf[0] - 224;
+ break;
+ case 4:
+ ch = (unsigned char) outbuf[0] - 240;
+ break;
+ }
+ else
+ ch = (ch * 64) + ((unsigned char) outbuf[i] - 128);
+ }
+ /* End of conversion*/
- result = get_alias(op, ch);
+ result = get_alias(op, ch);
- if (result == NULL)
- if (ch > 127 && op->unisymbol_print)
- result = assemble_string(op->unisymbol_print, ch);
- else
- result = outbuf;
- }
+ if (result == NULL)
+ {
+ if (ch > 127 && op->unisymbol_print)
+ result = assemble_string(op->unisymbol_print, ch);
+ else
+ result = outbuf;
+ }
+ }
- return result;
+ return result;
}
#endif
/*========================================================================
@@ -475,123 +490,113 @@ op_translate_doublet (OutputPersonality
*=======================================================================*/
void
-op_begin_std_fontsize (OutputPersonality *op, int size)
+op_begin_std_fontsize (const OutputContext *oc, int size)
{
- int found_std_expr = FALSE;
+ int found_std_expr = FALSE;
+ const struct unRTFOutputDevice *device = &oc->conversion->options->device;
- CHECK_PARAM_NOT_NULL(op);
+ CHECK_PARAM_NOT_NULL(oc);
- /* Look for an exact match with a standard point size.
- */
- switch (size) {
- case 8:
- if (op->fontsize8_begin) {
- if (safe_printf(0, op->fontsize8_begin)) fprintf(stderr, TOO_MANY_ARGS, "fontsize8_begin");
- found_std_expr = TRUE;
- }
- break;
- case 10:
- if (op->fontsize10_begin) {
- if (safe_printf(0, op->fontsize10_begin)) fprintf(stderr, TOO_MANY_ARGS, "fontsize10_begin");
- found_std_expr = TRUE;
- }
- break;
- case 12:
- if (op->fontsize12_begin) {
- if (safe_printf(0, op->fontsize12_begin)) fprintf(stderr, TOO_MANY_ARGS, "fontsize12_begin");
- found_std_expr = TRUE;
- }
- break;
- case 14:
- if (op->fontsize14_begin) {
- if (safe_printf(0, op->fontsize14_begin)) fprintf(stderr, TOO_MANY_ARGS, "fontsize14_begin");
- found_std_expr = TRUE;
- }
- break;
- case 18:
- if (op->fontsize18_begin) {
- if (safe_printf(0, op->fontsize18_begin)) fprintf(stderr, TOO_MANY_ARGS, "fontsize18_begin");
- found_std_expr = TRUE;
- }
- break;
- case 24:
- if (op->fontsize24_begin) {
- if (safe_printf(0, op->fontsize24_begin)) fprintf(stderr, TOO_MANY_ARGS, "fontsize24_begin");
- found_std_expr = TRUE;
- }
- break;
- case 36:
- if (op->fontsize36_begin) {
- if (safe_printf(0, op->fontsize36_begin)) fprintf(stderr, TOO_MANY_ARGS, "fontsize36_begin");
- found_std_expr = TRUE;
- }
- break;
- case 48:
- if (op->fontsize48_begin) {
- if (safe_printf(0, op->fontsize48_begin)) fprintf(stderr, TOO_MANY_ARGS, "fontsize48_begin");
- found_std_expr = TRUE;
- }
- break;
- }
+ /* Look for an exact match with a standard point size.
+ */
+ switch (size) {
+ case 8:
+ if (oc->personality->fontsize8_begin) {
+ if (safe_printf(device, 0, oc->personality->fontsize8_begin)) fprintf(stderr, TOO_MANY_ARGS, "fontsize8_begin");
+ found_std_expr = TRUE;
+ }
+ break;
+ case 10:
+ if (oc->personality->fontsize10_begin) {
+ if (safe_printf(device, 0, oc->personality->fontsize10_begin)) fprintf(stderr, TOO_MANY_ARGS, "fontsize10_begin");
+ found_std_expr = TRUE;
+ }
+ break;
+ case 12:
+ if (oc->personality->fontsize12_begin) {
+ if (safe_printf(device, 0, oc->personality->fontsize12_begin)) fprintf(stderr, TOO_MANY_ARGS, "fontsize12_begin");
+ found_std_expr = TRUE;
+ }
+ break;
+ case 14:
+ if (oc->personality->fontsize14_begin) {
+ if (safe_printf(device, 0, oc->personality->fontsize14_begin)) fprintf(stderr, TOO_MANY_ARGS, "fontsize14_begin");
+ found_std_expr = TRUE;
+ }
+ break;
+ case 18:
+ if (oc->personality->fontsize18_begin) {
+ if (safe_printf(device, 0, oc->personality->fontsize18_begin)) fprintf(stderr, TOO_MANY_ARGS, "fontsize18_begin");
+ found_std_expr = TRUE;
+ }
+ break;
+ case 24:
+ if (oc->personality->fontsize24_begin) {
+ if (safe_printf(device, 0, oc->personality->fontsize24_begin)) fprintf(stderr, TOO_MANY_ARGS, "fontsize24_begin");
+ found_std_expr = TRUE;
+ }
+ break;
+ case 36:
+ if (oc->personality->fontsize36_begin) {
+ if (safe_printf(device, 0, oc->personality->fontsize36_begin)) fprintf(stderr, TOO_MANY_ARGS, "fontsize36_begin");
+ found_std_expr = TRUE;
+ }
+ break;
+ case 48:
+ if (oc->personality->fontsize48_begin) {
+ if (safe_printf(device, 0, oc->personality->fontsize48_begin)) fprintf(stderr, TOO_MANY_ARGS, "fontsize48_begin");
+ found_std_expr = TRUE;
+ }
+ break;
+ }
- /* If no exact match, try to write out a change to the
- * exact point size.
- */
- if (!found_std_expr) {
- if (op->fontsize_begin) {
- char expr[16];
- sprintf (expr, "%d", size);
- if (safe_printf (1, op->fontsize_begin, expr)) fprintf(stderr, TOO_MANY_ARGS, "fontsize_begin");
- } else {
- /* If we cannot write out a change for the exact
- * point size, we must approximate to a standard
- * size.
- */
- if (size<9 && op->fontsize8_begin) {
- if (safe_printf(0, op->fontsize8_begin)) fprintf(stderr, TOO_MANY_ARGS, "fontsize8_begin");
- } else
- if (size<11 && op->fontsize10_begin) {
- if (safe_printf(0, op->fontsize10_begin)) fprintf(stderr, TOO_MANY_ARGS, "fontsize10_begin");
- } else
- if (size<13 && op->fontsize12_begin) {
- if (safe_printf(0, op->fontsize12_begin)) fprintf(stderr, TOO_MANY_ARGS, "fontsize12_begin");
- } else
- if (size<16 && op->fontsize14_begin) {
- if (safe_printf(0, op->fontsize14_begin)) fprintf(stderr, TOO_MANY_ARGS, "fontsize14_begin");
- } else
- if (size<21 && op->fontsize18_begin) {
- if (safe_printf(0, op->fontsize18_begin)) fprintf(stderr, TOO_MANY_ARGS, "fontsize18_begin");
- } else
- if (size<30 && op->fontsize24_begin) {
- if (safe_printf(0, op->fontsize24_begin)) fprintf(stderr, TOO_MANY_ARGS, "fontsize24_begin");
- } else
- if (size<42 && op->fontsize36_begin) {
- if (safe_printf(0, op->fontsize36_begin)) fprintf(stderr, TOO_MANY_ARGS, "fontsize36_begin");
- } else
- if (size>40 && op->fontsize48_begin) {
- if (safe_printf(0, op->fontsize48_begin)) fprintf(stderr, TOO_MANY_ARGS, "fontsize48_begin");
- } else
- /* If we can't even produce a good approximation,
- * just try to get a font size near 12 point.
- */
- if (op->fontsize12_begin)
- if (safe_printf(0, op->fontsize12_begin)) fprintf(stderr, TOO_MANY_ARGS, "fontsize12_begin");
- else
- if (op->fontsize14_begin)
- if (safe_printf(0, op->fontsize14_begin)) fprintf(stderr, TOO_MANY_ARGS, "fontsize14_begin");
- else
- if (op->fontsize10_begin)
- if (safe_printf(0, op->fontsize10_begin)) fprintf(stderr, TOO_MANY_ARGS, "fontsize10_begin");
- else
- if (op->fontsize18_begin)
- if (safe_printf(0, op->fontsize18_begin)) fprintf(stderr, TOO_MANY_ARGS, "fontsize18_begin");
- else
- if (op->fontsize8_begin)
- if (safe_printf(0, op->fontsize8_begin)) fprintf(stderr, TOO_MANY_ARGS, "fontsize8_begin");
- else
- error_handler ("output personality lacks sufficient font size change capability");
- }
- }
+ /* If no exact match, try to write out a change to the
+ * exact point size.
+ */
+ if (!found_std_expr) {
+ if (oc->personality->fontsize_begin) {
+ char expr[16];
+ sprintf (expr, "%d", size);
+ if (safe_printf(device, 1, oc->personality->fontsize_begin, expr)) fprintf(stderr, TOO_MANY_ARGS, "fontsize_begin");
+ } else {
+ /* If we cannot write out a change for the exact
+ * point size, we must approximate to a standard
+ * size.
+ */
+ if (size<9 && oc->personality->fontsize8_begin) {
+ if (safe_printf(device, 0, oc->personality->fontsize8_begin)) fprintf(stderr, TOO_MANY_ARGS, "fontsize8_begin");
+ } else if (size<11 && oc->personality->fontsize10_begin) {
+ if (safe_printf(device, 0, oc->personality->fontsize10_begin)) fprintf(stderr, TOO_MANY_ARGS, "fontsize10_begin");
+ } else if (size<13 && oc->personality->fontsize12_begin) {
+ if (safe_printf(device, 0, oc->personality->fontsize12_begin)) fprintf(stderr, TOO_MANY_ARGS, "fontsize12_begin");
+ } else if (size<16 && oc->personality->fontsize14_begin) {
+ if (safe_printf(device, 0, oc->personality->fontsize14_begin)) fprintf(stderr, TOO_MANY_ARGS, "fontsize14_begin");
+ } else if (size<21 && oc->personality->fontsize18_begin) {
+ if (safe_printf(device, 0, oc->personality->fontsize18_begin)) fprintf(stderr, TOO_MANY_ARGS, "fontsize18_begin");
+ } else if (size<30 && oc->personality->fontsize24_begin) {
+ if (safe_printf(device, 0, oc->personality->fontsize24_begin)) fprintf(stderr, TOO_MANY_ARGS, "fontsize24_begin");
+ } else if (size<42 && oc->personality->fontsize36_begin) {
+ if (safe_printf(device, 0, oc->personality->fontsize36_begin)) fprintf(stderr, TOO_MANY_ARGS, "fontsize36_begin");
+ } else if (size>40 && oc->personality->fontsize48_begin) {
+ if (safe_printf(device, 0, oc->personality->fontsize48_begin)) fprintf(stderr, TOO_MANY_ARGS, "fontsize48_begin");
+ } else if (oc->personality->fontsize12_begin) {
+ /* If we can't even produce a good approximation,
+ * just try to get a font size near 12 point.
+ */
+ if (safe_printf(device, 0, oc->personality->fontsize12_begin)) fprintf(stderr, TOO_MANY_ARGS, "fontsize12_begin");
+ } else if (oc->personality->fontsize14_begin) {
+ if (safe_printf(device, 0, oc->personality->fontsize14_begin)) fprintf(stderr, TOO_MANY_ARGS, "fontsize14_begin");
+ } else if (oc->personality->fontsize10_begin) {
+ if (safe_printf(device, 0, oc->personality->fontsize10_begin)) fprintf(stderr, TOO_MANY_ARGS, "fontsize10_begin");
+ } else if (oc->personality->fontsize18_begin) {
+ if (safe_printf(device, 0, oc->personality->fontsize18_begin)) fprintf(stderr, TOO_MANY_ARGS, "fontsize18_begin");
+ } else if (oc->personality->fontsize8_begin) {
+ if (safe_printf(device, 0, oc->personality->fontsize8_begin)) fprintf(stderr, TOO_MANY_ARGS, "fontsize8_begin");
+ } else {
+ error_handler (oc->conversion, "output personality lacks sufficient font size change capability");
+ }
+ }
+ }
}
@@ -604,123 +609,113 @@ op_begin_std_fontsize (OutputPersonality
*=======================================================================*/
void
-op_end_std_fontsize (OutputPersonality *op, int size)
+op_end_std_fontsize (const OutputContext *oc, int size)
{
- int found_std_expr = FALSE;
+ int found_std_expr = FALSE;
+ const struct unRTFOutputDevice *device = &oc->conversion->options->device;
- CHECK_PARAM_NOT_NULL(op);
+ CHECK_PARAM_NOT_NULL(oc);
- /* Look for an exact match with a standard point size.
- */
- switch (size) {
- case 8:
- if (op->fontsize8_end) {
- if (safe_printf(0, op->fontsize8_end)) fprintf(stderr, TOO_MANY_ARGS, "fontsize8_end");
- found_std_expr = TRUE;
- }
- break;
- case 10:
- if (op->fontsize10_end) {
- if (safe_printf(0, op->fontsize10_end)) fprintf(stderr, TOO_MANY_ARGS, "fontsize10_end");
- found_std_expr = TRUE;
- }
- break;
- case 12:
- if (op->fontsize12_end) {
- if (safe_printf(0, op->fontsize12_end)) fprintf(stderr, TOO_MANY_ARGS, "fontsize12_end");
- found_std_expr = TRUE;
- }
- break;
- case 14:
- if (op->fontsize14_end) {
- if (safe_printf(0, op->fontsize14_end)) fprintf(stderr, TOO_MANY_ARGS, "fontsize14_end");
- found_std_expr = TRUE;
- }
- break;
- case 18:
- if (op->fontsize18_end) {
- if (safe_printf(0, op->fontsize18_end)) fprintf(stderr, TOO_MANY_ARGS, "fontsize18_end");
- found_std_expr = TRUE;
- }
- break;
- case 24:
- if (op->fontsize24_end) {
- if (safe_printf(0, op->fontsize24_end)) fprintf(stderr, TOO_MANY_ARGS, "fontsize24_end");
- found_std_expr = TRUE;
- }
- break;
- case 36:
- if (op->fontsize36_end) {
- if (safe_printf(0, op->fontsize36_end)) fprintf(stderr, TOO_MANY_ARGS, "fontsize36_end");
- found_std_expr = TRUE;
- }
- break;
- case 48:
- if (op->fontsize48_end) {
- if (safe_printf(0, op->fontsize48_end)) fprintf(stderr, TOO_MANY_ARGS, "fontsize48_end");
- found_std_expr = TRUE;
- }
- break;
- }
+ /* Look for an exact match with a standard point size.
+ */
+ switch (size) {
+ case 8:
+ if (oc->personality->fontsize8_end) {
+ if (safe_printf(device, 0, oc->personality->fontsize8_end)) fprintf(stderr, TOO_MANY_ARGS, "fontsize8_end");
+ found_std_expr = TRUE;
+ }
+ break;
+ case 10:
+ if (oc->personality->fontsize10_end) {
+ if (safe_printf(device, 0, oc->personality->fontsize10_end)) fprintf(stderr, TOO_MANY_ARGS, "fontsize10_end");
+ found_std_expr = TRUE;
+ }
+ break;
+ case 12:
+ if (oc->personality->fontsize12_end) {
+ if (safe_printf(device, 0, oc->personality->fontsize12_end)) fprintf(stderr, TOO_MANY_ARGS, "fontsize12_end");
+ found_std_expr = TRUE;
+ }
+ break;
+ case 14:
+ if (oc->personality->fontsize14_end) {
+ if (safe_printf(device, 0, oc->personality->fontsize14_end)) fprintf(stderr, TOO_MANY_ARGS, "fontsize14_end");
+ found_std_expr = TRUE;
+ }
+ break;
+ case 18:
+ if (oc->personality->fontsize18_end) {
+ if (safe_printf(device, 0, oc->personality->fontsize18_end)) fprintf(stderr, TOO_MANY_ARGS, "fontsize18_end");
+ found_std_expr = TRUE;
+ }
+ break;
+ case 24:
+ if (oc->personality->fontsize24_end) {
+ if (safe_printf(device, 0, oc->personality->fontsize24_end)) fprintf(stderr, TOO_MANY_ARGS, "fontsize24_end");
+ found_std_expr = TRUE;
+ }
+ break;
+ case 36:
+ if (oc->personality->fontsize36_end) {
+ if (safe_printf(device, 0, oc->personality->fontsize36_end)) fprintf(stderr, TOO_MANY_ARGS, "fontsize36_end");
+ found_std_expr = TRUE;
+ }
+ break;
+ case 48:
+ if (oc->personality->fontsize48_end) {
+ if (safe_printf(device, 0, oc->personality->fontsize48_end)) fprintf(stderr, TOO_MANY_ARGS, "fontsize48_end");
+ found_std_expr = TRUE;
+ }
+ break;
+ }
- /* If no exact match, try to write out a change to the
- * exact point size.
- */
- if (!found_std_expr) {
- if (op->fontsize_end) {
- char expr[16];
- sprintf (expr, "%d", size);
- if (safe_printf(1, op->fontsize_end, expr)) fprintf(stderr, TOO_MANY_ARGS, "fontsize_end");
- } else {
- /* If we cannot write out a change for the exact
- * point size, we must approximate to a standard
- * size.
- */
- if (size<9 && op->fontsize8_end) {
- if (safe_printf(0, op->fontsize8_end)) fprintf(stderr, TOO_MANY_ARGS, "fontsize8_end");
- } else
- if (size<11 && op->fontsize10_end) {
- if (safe_printf(0, op->fontsize10_end)) fprintf(stderr, TOO_MANY_ARGS, "fontsize10_end");
- } else
- if (size<13 && op->fontsize12_end) {
- if (safe_printf(0, op->fontsize12_end)) fprintf(stderr, TOO_MANY_ARGS, "fontsize12_end");
- } else
- if (size<16 && op->fontsize14_end) {
- if (safe_printf(0, op->fontsize14_end)) fprintf(stderr, TOO_MANY_ARGS, "fontsize14_end");
- } else
- if (size<21 && op->fontsize18_end) {
- if (safe_printf(0, op->fontsize18_end)) fprintf(stderr, TOO_MANY_ARGS, "fontsize18_end");
- } else
- if (size<30 && op->fontsize24_end) {
- if (safe_printf(0, op->fontsize24_end)) fprintf(stderr, TOO_MANY_ARGS, "fontsize24_end");
- } else
- if (size<42 && op->fontsize36_end) {
- if (safe_printf(0, op->fontsize36_end)) fprintf(stderr, TOO_MANY_ARGS, "fontsize36_end");
- } else
- if (size>40 && op->fontsize48_end) {
- if (safe_printf(0, op->fontsize48_end)) fprintf(stderr, TOO_MANY_ARGS, "fontsize48_end");
- } else
- /* If we can't even produce a good approximation,
- * just try to get a font size near 12 point.
- */
- if (op->fontsize12_end)
- if (safe_printf(0, op->fontsize12_end)) fprintf(stderr, TOO_MANY_ARGS, "fontsize12_end");
- else
- if (op->fontsize14_end)
- if (safe_printf(0, op->fontsize14_end)) fprintf(stderr, TOO_MANY_ARGS, "fontsize14_end");
- else
- if (op->fontsize10_end)
- if (safe_printf(0, op->fontsize10_end)) fprintf(stderr, TOO_MANY_ARGS, "fontsize10_end");
- else
- if (op->fontsize18_end)
- if (safe_printf(0, op->fontsize18_end)) fprintf(stderr, TOO_MANY_ARGS, "fontsize18_end");
- else
- if (op->fontsize8_end)
- if (safe_printf(0, op->fontsize8_end)) fprintf(stderr, TOO_MANY_ARGS, "fontsize8_end");
- else
- error_handler ("output personality lacks sufficient font size change capability");
- }
- }
+ /* If no exact match, try to write out a change to the
+ * exact point size.
+ */
+ if (!found_std_expr) {
+ if (oc->personality->fontsize_end) {
+ char expr[16];
+ sprintf (expr, "%d", size);
+ if (safe_printf(device, 1, oc->personality->fontsize_end, expr)) fprintf(stderr, TOO_MANY_ARGS, "fontsize_end");
+ } else {
+ /* If we cannot write out a change for the exact
+ * point size, we must approximate to a standard
+ * size.
+ */
+ if (size<9 && oc->personality->fontsize8_end) {
+ if (safe_printf(device, 0, oc->personality->fontsize8_end)) fprintf(stderr, TOO_MANY_ARGS, "fontsize8_end");
+ } else if (size<11 && oc->personality->fontsize10_end) {
+ if (safe_printf(device, 0, oc->personality->fontsize10_end)) fprintf(stderr, TOO_MANY_ARGS, "fontsize10_end");
+ } else if (size<13 && oc->personality->fontsize12_end) {
+ if (safe_printf(device, 0, oc->personality->fontsize12_end)) fprintf(stderr, TOO_MANY_ARGS, "fontsize12_end");
+ } else if (size<16 && oc->personality->fontsize14_end) {
+ if (safe_printf(device, 0, oc->personality->fontsize14_end)) fprintf(stderr, TOO_MANY_ARGS, "fontsize14_end");
+ } else if (size<21 && oc->personality->fontsize18_end) {
+ if (safe_printf(device, 0, oc->personality->fontsize18_end)) fprintf(stderr, TOO_MANY_ARGS, "fontsize18_end");
+ } else if (size<30 && oc->personality->fontsize24_end) {
+ if (safe_printf(device, 0, oc->personality->fontsize24_end)) fprintf(stderr, TOO_MANY_ARGS, "fontsize24_end");
+ } else if (size<42 && oc->personality->fontsize36_end) {
+ if (safe_printf(device, 0, oc->personality->fontsize36_end)) fprintf(stderr, TOO_MANY_ARGS, "fontsize36_end");
+ } else if (size>40 && oc->personality->fontsize48_end) {
+ if (safe_printf(device, 0, oc->personality->fontsize48_end)) fprintf(stderr, TOO_MANY_ARGS, "fontsize48_end");
+ } else if (oc->personality->fontsize12_end) {
+ /* If we can't even produce a good approximation,
+ * just try to get a font size near 12 point.
+ */
+ if (safe_printf(device, 0, oc->personality->fontsize12_end)) fprintf(stderr, TOO_MANY_ARGS, "fontsize12_end");
+ } else if (oc->personality->fontsize14_end) {
+ if (safe_printf(device, 0, oc->personality->fontsize14_end)) fprintf(stderr, TOO_MANY_ARGS, "fontsize14_end");
+ } else if (oc->personality->fontsize10_end) {
+ if (safe_printf(device, 0, oc->personality->fontsize10_end)) fprintf(stderr, TOO_MANY_ARGS, "fontsize10_end");
+ } else if (oc->personality->fontsize18_end) {
+ if (safe_printf(device, 0, oc->personality->fontsize18_end)) fprintf(stderr, TOO_MANY_ARGS, "fontsize18_end");
+ } else if (oc->personality->fontsize8_end) {
+ if (safe_printf(device, 0, oc->personality->fontsize8_end)) fprintf(stderr, TOO_MANY_ARGS, "fontsize8_end");
+ } else {
+ error_handler (oc->conversion, "output personality lacks sufficient font size change capability");
+ }
+ }
+ }
}
#if 1 /* AK3 - AF */
@@ -734,7 +729,7 @@ op_end_std_fontsize (OutputPersonality *
void
add_alias(OutputPersonality *op, int nr, char *text)
{
- op->aliases = (Aliases *)add_to_collection((Collection *)op->aliases, nr, text);
+ op->aliases = (Aliases *)add_to_collection((Collection *)op->aliases, nr, text);
}
/*========================================================================
@@ -745,9 +740,8 @@ add_alias(OutputPersonality *op, int nr,
*=======================================================================*/
char *
-get_alias(OutputPersonality *op, int nr)
+get_alias(const OutputPersonality *op, int nr)
{
- return get_from_collection((Collection *)op->aliases, nr);
+ return get_from_collection((Collection *)op->aliases, nr);
}
#endif
-
diff -durpN unrtf-0.21.2.old/src/output.h unrtf-0.21.2/src/output.h
--- unrtf-0.21.2.old/src/output.h 2010-08-12 03:09:02.000000000 +0200
+++ unrtf-0.21.2/src/output.h 2013-01-17 02:41:09.685864239 +0100
@@ -44,227 +44,228 @@
typedef Collection Aliases;
typedef struct {
- int cp;
- unsigned short chars[128];
+ int cp;
+ unsigned short chars[128];
} CodepageInfo;
+typedef struct OutputPersonality {
+ char *comment_begin;
+ char *comment_end;
-typedef struct {
- char *comment_begin;
- char *comment_end;
-
- char *document_begin;
- char *document_end;
+ char *document_begin;
+ char *document_end;
- char *header_begin;
- char *header_end;
+ char *header_begin;
+ char *header_end;
- char *document_title_begin;
- char *document_title_end;
+ char *document_title_begin;
+ char *document_title_end;
- char *document_keywords_begin;
- char *document_keywords_end;
+ char *document_keywords_begin;
+ char *document_keywords_end;
- char *document_author_begin;
- char *document_author_end;
+ char *document_author_begin;
+ char *document_author_end;
- char *document_changedate_begin;
- char *document_changedate_end;
+ char *document_changedate_begin;
+ char *document_changedate_end;
- char *body_begin;
- char *body_end;
+ char *body_begin;
+ char *body_end;
- char *word_begin;
- char *word_end;
+ char *word_begin;
+ char *word_end;
- char *paragraph_begin;
- char *paragraph_end;
+ char *paragraph_begin;
+ char *paragraph_end;
- char *center_begin;
- char *center_end;
+ char *center_begin;
+ char *center_end;
- char *align_left_begin;
- char *align_left_end;
+ char *align_left_begin;
+ char *align_left_end;
- char *align_right_begin;
- char *align_right_end;
+ char *align_right_begin;
+ char *align_right_end;
- char *justify_begin;
- char *justify_end;
+ char *justify_begin;
+ char *justify_end;
- char *forced_space;
- char *line_break;
- char *page_break;
+ char *forced_space;
+ char *line_break;
+ char *page_break;
- char *hyperlink_begin;
- char *hyperlink_end;
+ char *hyperlink_begin;
+ char *hyperlink_end;
- char *imagelink_begin;
- char *imagelink_end;
+ char *imagelink_begin;
+ char *imagelink_end;
- char *table_begin;
- char *table_end;
+ char *table_begin;
+ char *table_end;
- char *table_row_begin;
- char *table_row_end;
+ char *table_row_begin;
+ char *table_row_end;
- char *table_cell_begin;
- char *table_cell_end;
+ char *table_cell_begin;
+ char *table_cell_end;
- /* Character attributes */
- char *font_begin;
- char *font_end;
+ /* Character attributes */
+ char *font_begin;
+ char *font_end;
- char *fontsize_begin;
- char *fontsize_end;
+ char *fontsize_begin;
+ char *fontsize_end;
- /* standard font sizes are optional */
- char *fontsize8_begin;
- char *fontsize8_end;
+ /* standard font sizes are optional */
+ char *fontsize8_begin;
+ char *fontsize8_end;
- char *fontsize10_begin;
- char *fontsize10_end;
+ char *fontsize10_begin;
+ char *fontsize10_end;
- char *fontsize12_begin;
- char *fontsize12_end;
+ char *fontsize12_begin;
+ char *fontsize12_end;
- char *fontsize14_begin;
- char *fontsize14_end;
+ char *fontsize14_begin;
+ char *fontsize14_end;
- char *fontsize18_begin;
- char *fontsize18_end;
+ char *fontsize18_begin;
+ char *fontsize18_end;
- char *fontsize24_begin;
- char *fontsize24_end;
+ char *fontsize24_begin;
+ char *fontsize24_end;
- char *fontsize36_begin;
- char *fontsize36_end;
+ char *fontsize36_begin;
+ char *fontsize36_end;
- char *fontsize48_begin;
- char *fontsize48_end;
+ char *fontsize48_begin;
+ char *fontsize48_end;
- char *smaller_begin;
- char *smaller_end;
+ char *smaller_begin;
+ char *smaller_end;
- char *bigger_begin;
- char *bigger_end;
+ char *bigger_begin;
+ char *bigger_end;
- char *foreground_begin;
- char *foreground_end;
+ char *foreground_begin;
+ char *foreground_end;
- char *background_begin;
- char *background_end;
+ char *background_begin;
+ char *background_end;
- char *bold_begin;
- char *bold_end;
+ char *bold_begin;
+ char *bold_end;
- char *italic_begin;
- char *italic_end;
+ char *italic_begin;
+ char *italic_end;
- char *underline_begin;
- char *underline_end;
+ char *underline_begin;
+ char *underline_end;
- char *dbl_underline_begin;
- char *dbl_underline_end;
+ char *dbl_underline_begin;
+ char *dbl_underline_end;
- char *superscript_begin;
- char *superscript_end;
+ char *superscript_begin;
+ char *superscript_end;
- char *subscript_begin;
- char *subscript_end;
+ char *subscript_begin;
+ char *subscript_end;
- char *strikethru_begin;
- char *strikethru_end;
+ char *strikethru_begin;
+ char *strikethru_end;
- char *dbl_strikethru_begin;
- char *dbl_strikethru_end;
+ char *dbl_strikethru_begin;
+ char *dbl_strikethru_end;
- char *emboss_begin;
- char *emboss_end;
+ char *emboss_begin;
+ char *emboss_end;
- char *engrave_begin;
- char *engrave_end;
+ char *engrave_begin;
+ char *engrave_end;
- char *shadow_begin;
- char *shadow_end;
+ char *shadow_begin;
+ char *shadow_end;
- char *outline_begin;
- char *outline_end;
+ char *outline_begin;
+ char *outline_end;
- char *small_caps_begin;
- char *small_caps_end;
+ char *small_caps_begin;
+ char *small_caps_end;
- char *pointlist_begin;
- char *pointlist_end;
+ char *pointlist_begin;
+ char *pointlist_end;
- char *pointlist_item_begin;
- char *pointlist_item_end;
+ char *pointlist_item_begin;
+ char *pointlist_item_end;
- char *numericlist_begin;
- char *numericlist_end;
+ char *numericlist_begin;
+ char *numericlist_end;
- char *numericlist_item_begin;
- char *numericlist_item_end;
+ char *numericlist_item_begin;
+ char *numericlist_item_end;
- char *expand_begin;
- char *expand_end;
+ char *expand_begin;
+ char *expand_end;
- char *toc_entry_begin;
- char *toc_entry_end;
+ char *toc_entry_begin;
+ char *toc_entry_end;
- char *index_entry_begin;
- char *index_entry_end;
+ char *index_entry_begin;
+ char *index_entry_end;
- char *fonttable_begin;
- char *fonttable_end;
- char *fonttable_fontnr;
- char *fonttable_fontname;
+ char *fonttable_begin;
+ char *fonttable_end;
+ char *fonttable_fontnr;
+ char *fonttable_fontname;
- /* XX These should really be replaced by references
- * to one of the charsets.
- */
- struct {
- char *bullet;
- char *left_quote;
- char *right_quote;
- char *left_dbl_quote;
- char *right_dbl_quote;
- char *nonbreaking_space;
- char *emdash;
- char *endash;
- char *lessthan;
- char *greaterthan;
- char *amp;
- char *copyright;
- char *trademark;
- char *nonbreaking_hyphen;
- char *optional_hyphen;
- } chars;
+ /* XX These should really be replaced by references
+ * to one of the charsets.
+ */
+ struct {
+ char *bullet;
+ char *left_quote;
+ char *right_quote;
+ char *left_dbl_quote;
+ char *right_dbl_quote;
+ char *nonbreaking_space;
+ char *emdash;
+ char *endash;
+ char *lessthan;
+ char *greaterthan;
+ char *amp;
+ char *copyright;
+ char *trademark;
+ char *nonbreaking_hyphen;
+ char *optional_hyphen;
+ } chars;
- int simulate_small_caps : 1;
- int simulate_all_caps : 1;
- int simulate_word_underline : 1;
- char *unisymbol_print;
- char *utf8_encoding;
- Aliases *aliases;
-}
-OutputPersonality;
+ int simulate_small_caps : 1;
+ int simulate_all_caps : 1;
+ int simulate_word_underline : 1;
+ char *unisymbol_print;
+ char *utf8_encoding;
+ Aliases *aliases;
+} OutputPersonality;
+typedef struct OutputContext {
+ struct ConversionContext *conversion;
+ struct OutputPersonality *personality;
+} OutputContext;
-extern OutputPersonality* op_create(void);
+extern OutputPersonality* op_create(const struct ConversionContext *);
extern void op_free (OutputPersonality*);
-extern char* op_translate_char (OutputPersonality *op, my_iconv_t cd, int ch);
+extern char* op_translate_char (const struct ConversionContext *cc, const OutputPersonality *op, int ch);
#if 1 /* daved - 0.21.2 */
-extern char* op_translate_str (OutputPersonality *op, my_iconv_t cd, int * doublet);
-extern char* op_translate_doublet (OutputPersonality *op, my_iconv_t cd, int ch1, int ch2);
+extern char* op_translate_str (const struct ConversionContext *cc, const OutputPersonality *op, int * doublet);
+extern char* op_translate_doublet (const struct ConversionContext *cc, const OutputPersonality *op, int ch1, int ch2);
#endif
-extern void op_begin_std_fontsize (OutputPersonality*, int);
-extern void op_end_std_fontsize (OutputPersonality*, int);
+extern void op_begin_std_fontsize (const struct OutputContext *, int);
+extern void op_end_std_fontsize (const struct OutputContext *, int);
-void add_alias(OutputPersonality *op, int nr, char *text);
-char *get_alias(OutputPersonality *op, int nr);
+void add_alias(struct OutputPersonality *op, int nr, char *text);
+char *get_alias(const struct OutputPersonality *op, int nr);
#define _OUTPUT
#endif
-
diff -durpN unrtf-0.21.2.old/src/parse.c unrtf-0.21.2/src/parse.c
--- unrtf-0.21.2.old/src/parse.c 2010-07-04 04:30:58.000000000 +0200
+++ unrtf-0.21.2/src/parse.c 2013-01-17 02:41:09.685864239 +0100
@@ -1,23 +1,23 @@
/*=============================================================================
- GNU UnRTF, a command-line program to convert RTF documents to other formats.
- Copyright (C) 2000,2001 Zachary Thayer Smith
+ GNU UnRTF, a command-line program to convert RTF documents to other formats.
+ Copyright (C) 2000,2001 Zachary Thayer Smith
- 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 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.
+ 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, write to the Free Software
- Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- The author is reachable by electronic mail at tuorfa@yahoo.com.
-=============================================================================*/
+ The author is reachable by electronic mail at tuorfa@yahoo.com.
+ =============================================================================*/
/*----------------------------------------------------------------------
@@ -59,6 +59,7 @@
#include <string.h>
#endif
+#include "convert.h"
#include "defs.h"
#include "parse.h"
#include "malloc.h"
@@ -67,14 +68,6 @@
#include "word.h"
#include "hash.h"
-
-
-/* local to getchar stuff */
-static int ungot_char = -1;
-static int ungot_char2 = -1;
-static int ungot_char3 = -1;
-
-
/*========================================================================
* Name: my_unget_char
* Purpose: My own unget routine, handling up to 3 ungot characters.
@@ -82,30 +75,16 @@ static int ungot_char3 = -1;
* Returns: None.
*=======================================================================*/
-static void my_unget_char (int ch)
+static void my_unget_char (struct ConversionContext *cc, int ch)
{
- if (ungot_char>=0 && ungot_char2>=0 && ungot_char3>=0)
- error_handler("More than 3 ungot chars");
+ if (cc->ungot_char>=0 && cc->ungot_char2>=0 && cc->ungot_char3>=0)
+ error_handler(cc, "More than 3 ungot chars");
- ungot_char3 = ungot_char2;
- ungot_char2 = ungot_char;
- ungot_char = ch;
+ cc->ungot_char3 = cc->ungot_char2;
+ cc->ungot_char2 = cc->ungot_char;
+ cc->ungot_char = ch;
}
-
-static int last_returned_ch=0;
-
-
-#define READ_BUF_LEN 2048
-static int buffer_size = 0;
-static char *read_buf = NULL;
-static int read_buf_end = 0;
-static int read_buf_index = 0;
-
-
-
-
-
/*========================================================================
* Name: my_getchar
* Purpose: Gets a character: either an ungot one, or a buffered one.
@@ -113,76 +92,54 @@ static int read_buf_index = 0;
* Returns: Character, or EOF.
*=======================================================================*/
-static int my_getchar (FILE* f)
+static int my_getchar (struct ConversionContext *cc)
{
- int ch;
-
- CHECK_PARAM_NOT_NULL(f);
+ int ch;
- if (ungot_char>=0) {
- ch = ungot_char;
- ungot_char = ungot_char2;
- ungot_char2 = ungot_char3;
- ungot_char3 = -1;
- last_returned_ch = ch;
- if(ch > 255)
- {
- fprintf(stderr, "returning bad ch = '%c' (0%o)\n",
- ch, ch);
- }
- return ch;
- }
- do {
- if (read_buf_index >= read_buf_end) {
- if (!read_buf) {
- buffer_size = READ_BUF_LEN;
- read_buf = my_malloc (buffer_size);
- if (!read_buf) {
- buffer_size /= 4;
- read_buf = my_malloc (buffer_size);
- if (!read_buf)
- error_handler("Cannot allocate read buffer");
- }
- }
- read_buf_end = fread (read_buf, 1, buffer_size, f);
- read_buf_index = 0;
- if (!read_buf_end)
- return EOF;
- }
- ch = read_buf [read_buf_index++];
+ if (cc->ungot_char>=0) {
+ ch = cc->ungot_char;
+ cc->ungot_char = cc->ungot_char2;
+ cc->ungot_char2 = cc->ungot_char3;
+ cc->ungot_char3 = -1;
+ cc->last_returned_ch = ch;
+ if(ch > 255)
+ {
+ fprintf(stderr, "returning bad ch = '%c' (0%o)\n",
+ ch, ch);
+ }
+ return ch;
+ }
+ do {
+ if (cc->read_buf_index >= cc->read_buf_end) {
+ return EOF;
+ }
+ ch = cc->read_buf [cc->read_buf_index++];
- if (ch=='\n') {
- lineno++;
- /* Convert \(newline) into \par here */
- if (last_returned_ch=='\\') {
- my_unget_char (' ');
- my_unget_char ('r');
- my_unget_char ('a');
- ch = 'p';
- break;
- }
- }
- }
- while (ch=='\r' /* || ch=='\n' */ );
+ if (ch=='\n') {
+ cc->lineno++;
+ /* Convert \(newline) into \par here */
+ if (cc->last_returned_ch=='\\') {
+ my_unget_char (cc, ' ');
+ my_unget_char (cc, 'r');
+ my_unget_char (cc, 'a');
+ ch = 'p';
+ break;
+ }
+ }
+ }
+ while (ch=='\r' /* || ch=='\n' */ );
- if (ch=='\t') ch = ' ';
+ if (ch=='\t') ch = ' ';
- last_returned_ch = ch;
- if(ch > 255)
- {
- fprintf(stderr,"returning bad ch '%c' (0%o)\n", ch, ch);
- exit(1);
- }
- return ch;
+ cc->last_returned_ch = ch;
+ if(ch > 255)
+ {
+ fprintf(stderr,"returning bad ch '%c' (0%o)\n", ch, ch);
+ exit(1);
+ }
+ return ch;
}
-
-/* local to read_word */
-static char *input_str = NULL;
-static unsigned long current_max_length = 1;
-
-
-
/*========================================================================
* Name: expand_word_buffer
* Purpose: Expands the buffer used to store an incoming word.
@@ -192,22 +149,22 @@ static unsigned long current_max_length
*=======================================================================*/
static int
-expand_word_buffer ()
+expand_word_buffer (struct ConversionContext *cc)
{
- char *new_ptr;
- unsigned long old_length;
- if (!input_str)
- error_handler("No input buffer allocated");
- old_length = current_max_length;
- current_max_length *= 2;
- new_ptr = my_malloc (current_max_length);
- if (!new_ptr)
- error_handler("Out of memory while resizing buffer");
+ char *new_ptr;
+ unsigned long old_length;
+ if (!cc->input_str)
+ error_handler(cc, "No input buffer allocated");
+ old_length = cc->current_max_length;
+ cc->current_max_length *= 2;
+ new_ptr = unrtf_malloc (cc->current_max_length);
+ if (!new_ptr)
+ error_handler(cc, "Out of memory while resizing buffer");
- memcpy (new_ptr, input_str, old_length);
- my_free(input_str);
- input_str = new_ptr;
- return TRUE;
+ memcpy (new_ptr, cc->input_str, old_length);
+ unrtf_free(cc->input_str);
+ cc->input_str = new_ptr;
+ return TRUE;
}
@@ -222,183 +179,184 @@ expand_word_buffer ()
*=======================================================================*/
static int
-read_word (FILE *f)
+read_word (struct ConversionContext *cc)
{
- int ch, ch2;
- unsigned long ix=0;
- int have_whitespace=FALSE;
- int is_control_word=FALSE;
- int has_numeric_param=FALSE; /* if is_control_word==TRUE */
- int need_unget=FALSE;
-
- CHECK_PARAM_NOT_NULL(f);
+ int ch, ch2;
+ unsigned long ix=0;
+ int have_whitespace=FALSE;
+ int is_control_word=FALSE;
+ int has_numeric_param=FALSE; /* if is_control_word==TRUE */
+ int need_unget=FALSE;
- current_max_length = 10; /* XX */
+ cc->current_max_length = 10; /* XX */
- /* Get some storage for a word.
- */
- input_str = my_malloc (current_max_length);
- if (!input_str)
- error_handler("Cannot allocate word storage");
+ /* Get some storage for a word.
+ */
+ if (cc->input_str) {
+ unrtf_free(cc->input_str);
+ }
+ cc->input_str = unrtf_malloc (cc->current_max_length);
+ if (!cc->input_str)
+ error_handler(cc, "Cannot allocate word storage");
- do {
- ch = my_getchar(f);
- }
- while (ch=='\n');
+ do {
+ ch = my_getchar(cc);
+ }
+ while (ch=='\n');
- if (ch==' ')
- {
- /* Compress multiple space chars down to one.
- */
- while (ch == ' ') {
- ch = my_getchar(f);
- have_whitespace=TRUE;
- }
- if (have_whitespace) {
- my_unget_char (ch);
- input_str[0]=' ';
- input_str[1]=0;
- return 1;
- }
- }
+ if (ch==' ')
+ {
+ /* Compress multiple space chars down to one.
+ */
+ while (ch == ' ') {
+ ch = my_getchar(cc);
+ have_whitespace=TRUE;
+ }
+ if (have_whitespace) {
+ my_unget_char (cc, ch);
+ cc->input_str[0]=' ';
+ cc->input_str[1]=0;
+ return 1;
+ }
+ }
- switch(ch)
- {
- case EOF:
- return 0;
+ switch(ch)
+ {
+ case EOF:
+ return 0;
- case '\\':
- ch2 = my_getchar(f);
+ case '\\':
+ ch2 = my_getchar(cc);
- /* Look for two-character command words.
- */
- switch (ch2)
- {
- case '\n':
- strcpy (input_str, "\\par");
- return 4;
- case '~':
- case '{':
- case '}':
- case '\\':
- case '_':
- case '-':
- input_str[0] = '\\';
- input_str[1] = ch2;
- input_str[2] = 0;
- return 2;
- case '\'':
- /* Preserve \'## expressions (hex char exprs) for later.
- */
- input_str[0]='\\';
- input_str[1]='\'';
- ix=2;
- if(ix==current_max_length) {
- if (!expand_word_buffer ())
- error_handler("Word too long");
- }
- ch = my_getchar(f);
- input_str[ix++]=ch;
- if(ix==current_max_length) {
- if (!expand_word_buffer ())
- error_handler("Word too long");
- }
- ch = my_getchar(f);
- input_str[ix++]=ch;
- if(ix==current_max_length) {
- if (!expand_word_buffer ())
- error_handler("Word too long");
- }
- input_str[ix]=0;
- return ix;
- }
+ /* Look for two-character command words.
+ */
+ switch (ch2)
+ {
+ case '\n':
+ strcpy (cc->input_str, "\\par");
+ return 4;
+ case '~':
+ case '{':
+ case '}':
+ case '\\':
+ case '_':
+ case '-':
+ cc->input_str[0] = '\\';
+ cc->input_str[1] = ch2;
+ cc->input_str[2] = 0;
+ return 2;
+ case '\'':
+ /* Preserve \'## expressions (hex char exprs) for later.
+ */
+ cc->input_str[0]='\\';
+ cc->input_str[1]='\'';
+ ix=2;
+ if(ix==cc->current_max_length) {
+ if (!expand_word_buffer (cc))
+ error_handler(cc, "Word too long");
+ }
+ ch = my_getchar(cc);
+ cc->input_str[ix++]=ch;
+ if(ix==cc->current_max_length) {
+ if (!expand_word_buffer (cc))
+ error_handler(cc, "Word too long");
+ }
+ ch = my_getchar(cc);
+ cc->input_str[ix++]=ch;
+ if(ix==cc->current_max_length) {
+ if (!expand_word_buffer (cc))
+ error_handler(cc, "Word too long");
+ }
+ cc->input_str[ix]=0;
+ return ix;
+ }
- is_control_word=TRUE;
- ix=1;
- input_str[0]=ch;
- ch=ch2;
- break;
+ is_control_word=TRUE;
+ ix=1;
+ cc->input_str[0]=ch;
+ ch=ch2;
+ break;
- case '\t':
- /* In RTF, a tab char is the same as \tab.
- */
- strcpy (input_str, "\\tab");
- return 4;
+ case '\t':
+ /* In RTF, a tab char is the same as \tab.
+ */
+ strcpy (cc->input_str, "\\tab");
+ return 4;
- case '{':
- case '}':
- case ';':
- input_str[0]=ch;
- input_str[1]=0;
- return 1;
+ case '{':
+ case '}':
+ case ';':
+ cc->input_str[0]=ch;
+ cc->input_str[1]=0;
+ return 1;
- }
+ }
- while (ch!=EOF)
- {
- /* Several chars always ends a word, and we need to save them.
- */
- if (ch=='\t' || ch=='{' || ch=='}' || ch=='\\') {
- need_unget=TRUE;
- break;
- }
+ while (ch!=EOF)
+ {
+ /* Several chars always ends a word, and we need to save them.
+ */
+ if (ch=='\t' || ch=='{' || ch=='}' || ch=='\\') {
+ need_unget=TRUE;
+ break;
+ }
- /* A newline always ends a command word; we don't save it.
- * A newline is ignored if this is not a command word.
- */
- if (ch=='\n') {
- if (is_control_word)
- break;
- ch = my_getchar(f);
- continue;
- }
+ /* A newline always ends a command word; we don't save it.
+ * A newline is ignored if this is not a command word.
+ */
+ if (ch=='\n') {
+ if (is_control_word)
+ break;
+ ch = my_getchar(cc);
+ continue;
+ }
- /* A semicolon always ends a command word; we do save it.
- * A semicolon never ends a regular word.
- */
- if (ch==';') {
- if (is_control_word) {
- need_unget=TRUE;
- break;
- }
- }
+ /* A semicolon always ends a command word; we do save it.
+ * A semicolon never ends a regular word.
+ */
+ if (ch==';') {
+ if (is_control_word) {
+ need_unget=TRUE;
+ break;
+ }
+ }
- /* In this parser, a space character terminates
- * any word, and if it does not follow a command,
- * then it is a word in itself.
- */
- if (ch==' ') {
- if (!is_control_word)
- need_unget=TRUE;
- break;
- }
+ /* In this parser, a space character terminates
+ * any word, and if it does not follow a command,
+ * then it is a word in itself.
+ */
+ if (ch==' ') {
+ if (!is_control_word)
+ need_unget=TRUE;
+ break;
+ }
- /* Identify a control word's numeric parameter.
- */
- if (is_control_word) {
- if (!has_numeric_param && (isdigit(ch) || ch=='-'))
- has_numeric_param = TRUE;
- else
- if (has_numeric_param && !isdigit(ch)) {
- if (ch!=' ')
- need_unget=TRUE;
- break;
- }
- }
+ /* Identify a control word's numeric parameter.
+ */
+ if (is_control_word) {
+ if (!has_numeric_param && (isdigit(ch) || ch=='-'))
+ has_numeric_param = TRUE;
+ else
+ if (has_numeric_param && !isdigit(ch)) {
+ if (ch!=' ')
+ need_unget=TRUE;
+ break;
+ }
+ }
- input_str[ix++] = ch;
- if (ix==current_max_length) {
- if (!expand_word_buffer ())
- error_handler("Word too long");
- }
- ch = my_getchar (f);
- }
+ cc->input_str[ix++] = ch;
+ if (ix==cc->current_max_length) {
+ if (!expand_word_buffer (cc))
+ error_handler(cc, "Word too long");
+ }
+ ch = my_getchar (cc);
+ }
- if (need_unget)
- my_unget_char(ch);
+ if (need_unget)
+ my_unget_char(cc, ch);
- input_str[ix]=0;
- return ix;
+ cc->input_str[ix]=0;
+ return ix;
}
@@ -412,44 +370,42 @@ read_word (FILE *f)
*=======================================================================*/
Word *
-word_read (FILE* f) {
- Word * prev_word = NULL;
- Word * first_word = NULL;
- Word * new_word = NULL; /* temp */
-
- CHECK_PARAM_NOT_NULL(f);
-
- do {
- if (!read_word(f))
- return first_word;
+word_read (struct ConversionContext *cc) {
+ Word * prev_word = NULL;
+ Word * first_word = NULL;
+ Word * new_word = NULL; /* temp */
- if (input_str[0] == '{') {
- /* Process subwords */
+ do {
+ if (!read_word(cc))
+ return first_word;
- /* Create a dummy word to point to a sublist */
- new_word = word_new(NULL);
- if (!new_word)
- error_handler("Cannot allocate word");
+ if (cc->input_str[0] == '{') {
+ /* Process subwords */
- /* Get the sublist */
- new_word->child = word_read(f);
+ /* Create a dummy word to point to a sublist */
+ new_word = word_new(cc, NULL);
+ if (!new_word)
+ error_handler(cc, "Cannot allocate word");
- } else if (input_str[0] == '}') {
- return first_word;
- } else {
- new_word = word_new(input_str);
- }
+ /* Get the sublist */
+ new_word->child = word_read(cc);
+
+ } else if (cc->input_str[0] == '}') {
+ return first_word;
+ } else {
+ new_word = word_new(cc, cc->input_str);
+ }
- if (prev_word)
- prev_word->next = new_word;
+ if (prev_word)
+ prev_word->next = new_word;
- if (!first_word)
- first_word = new_word;
+ if (!first_word)
+ first_word = new_word;
- prev_word = new_word;
+ prev_word = new_word;
- /* Free up the memory allocated by read_word. */
- my_free(input_str);
- input_str = NULL;
- } while (1);
+ /* Free up the memory allocated by read_word. */
+ unrtf_free(cc->input_str);
+ cc->input_str = NULL;
+ } while (1);
}
diff -durpN unrtf-0.21.2.old/src/parse.h unrtf-0.21.2/src/parse.h
--- unrtf-0.21.2.old/src/parse.h 2010-07-04 04:30:58.000000000 +0200
+++ unrtf-0.21.2/src/parse.h 2013-01-17 02:41:09.685864239 +0100
@@ -38,8 +38,6 @@
#include "word.h"
#endif
+struct ConversionContext;
-extern Word *word_read(FILE*);
-
-
-
+extern Word *word_read(struct ConversionContext *cc);
diff -durpN unrtf-0.21.2.old/src/path.c unrtf-0.21.2/src/path.c
--- unrtf-0.21.2.old/src/path.c 2010-07-04 04:30:58.000000000 +0200
+++ unrtf-0.21.2/src/path.c 1970-01-01 01:00:00.000000000 +0100
@@ -1,55 +0,0 @@
-#include <stdio.h>
-#include <string.h>
-#include <unistd.h>
-#include <stdlib.h>
-
-#include "path.h"
-
-struct path_dir *path_dir_p = &topdir;
-
-int check_dirs()
-{
- char *p;
- char *colon;
- char *dir_name;
- int a;
-
- for(p = search_path; *p != '\0';)
- {
- dir_name = p;
- if((colon = strchr(p, ':')) != NULL)
- {
- p = colon;
- *p++ = '\0';
- }
- else
- p += strlen(p);
- a = access(dir_name, R_OK|X_OK);
- if(a)
- continue;
- path_dir_p->dir_name = dir_name;
- if((path_dir_p->next = (struct path_dir *)malloc(sizeof (struct path_dir))) == NULL)
- {
- fprintf(stderr,"cannot malloc\n");
- exit(1);
- }
- path_dir_p = path_dir_p->next;
- path_dir_p->dir_name = 0;
- n_path_dirs++;
- }
- path_checked = 1;
- return(n_path_dirs);
-}
-
-void show_dirs()
-{
- if(n_path_dirs == 0)
- {
- fprintf(stderr,"no directories to show\n");
- exit(1);
- }
- fprintf(stderr,"show_dirs: %d directories\n", n_path_dirs);
- for(path_dir_p = &topdir; path_dir_p->dir_name; path_dir_p = path_dir_p->next)
- fprintf(stderr,"directory = %s\n", path_dir_p->dir_name);
-}
-
diff -durpN unrtf-0.21.2.old/src/path.h unrtf-0.21.2/src/path.h
--- unrtf-0.21.2.old/src/path.h 2010-07-04 04:30:58.000000000 +0200
+++ unrtf-0.21.2/src/path.h 1970-01-01 01:00:00.000000000 +0100
@@ -1,16 +0,0 @@
-#define DEFAULT_UNRTF_SEARCH_PATH "/usr/local/lib/unrtf/"
-
-char *search_path;
-int n_path_dirs;
-int path_checked;
-
-struct path_dir
-{
- char *dir_name;
- struct path_dir *next;
-};
-
-struct path_dir topdir;
-
-int check_dirs();
-void show_dirs();
diff -durpN unrtf-0.21.2.old/src/unicode.c unrtf-0.21.2/src/unicode.c
--- unrtf-0.21.2.old/src/unicode.c 2011-06-07 14:06:43.000000000 +0200
+++ unrtf-0.21.2/src/unicode.c 2013-01-17 02:41:09.685864239 +0100
@@ -55,20 +55,20 @@ unicode_to_string(int uc)
if (uc < 0x7f)
{
- string = my_malloc(2 * sizeof(char));
+ string = unrtf_malloc(2 * sizeof(char));
string[0] = (unsigned char) uc;
string[1] = '\0';
}
else if (uc < 0x7ff)
{
- string = my_malloc(3 * sizeof(char));
+ string = unrtf_malloc(3 * sizeof(char));
string[0] = (unsigned char) 192 + (uc / 64);
string[1] = (unsigned char) 128 + (uc % 64);
string[2] = '\0';
}
else if (uc < 0xffff)
{
- string = my_malloc(4 * sizeof(char));
+ string = unrtf_malloc(4 * sizeof(char));
string[0] = (unsigned char) 224 + (uc / (64 * 64));
string[1] = (unsigned char) 128 + ((uc / 64) % 64);
string[2] = (unsigned char) 128 + (uc % 64);
@@ -76,7 +76,7 @@ unicode_to_string(int uc)
}
else if (uc < 0x1FFFFF)
{
- string = my_malloc(5 * sizeof(char));
+ string = unrtf_malloc(5 * sizeof(char));
string[0] = (unsigned char) 240 + (uc / (64 * 64 * 64));
string[1] = (unsigned char) 128 + ((uc / (64 * 64)) % 64);
string[2] = (unsigned char) 128 + ((uc / 64) % 64);
@@ -85,7 +85,7 @@ unicode_to_string(int uc)
}
else if (uc < 0x3FFFFFF)
{
- string = my_malloc(6 * sizeof(char));
+ string = unrtf_malloc(6 * sizeof(char));
string[0] = (unsigned char) 248 + (uc / (64 * 64 * 64 * 64));
string[1] = (unsigned char) 128 + ((uc / (64 * 64 * 64)) % 64);
string[2] = (unsigned char) 128 + ((uc / (64 * 64)) % 64);
@@ -95,7 +95,7 @@ unicode_to_string(int uc)
}
else if (uc < 0x7FFFFFFF)
{
- string = my_malloc(7 * sizeof(char));
+ string = unrtf_malloc(7 * sizeof(char));
string[0] = (unsigned char) 252 + (uc / (64 * 64 * 64 * 64 * 64));
string[1] = (unsigned char) 128 + ((uc / (64 * 64 * 64 * 64)) % 64);
string[2] = (unsigned char) 128 + ((uc / (64 * 64 * 64)) % 64);
@@ -122,7 +122,7 @@ char *
get_unicode_char(FILE *file)
{
int allocated = 5, len = 0, uc;
- char c, *unicode_number = my_malloc(allocated * sizeof(char));
+ char c, *unicode_number = unrtf_malloc(allocated * sizeof(char));
c = fgetc(file);
@@ -139,7 +139,7 @@ get_unicode_char(FILE *file)
if (len == allocated)
{
allocated *= 2;
- unicode_number = my_realloc(unicode_number, allocated / 2, allocated);
+ unicode_number = unrtf_realloc(unicode_number, allocated / 2, allocated);
}
}
diff -durpN unrtf-0.21.2.old/src/unrtf.h unrtf-0.21.2/src/unrtf.h
--- unrtf-0.21.2.old/src/unrtf.h 1970-01-01 01:00:00.000000000 +0100
+++ unrtf-0.21.2/src/unrtf.h 2013-01-17 02:41:09.689864239 +0100
@@ -0,0 +1,55 @@
+/*===========================================================================
+ GNU UnRTF, a command-line program to convert RTF documents to other formats.
+ Copyright (C) 2000,2001,2004 by Zachary Smith
+ Copyright (C) 2011 by Inverse
+
+ 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, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+
+ The maintainer is reachable by electronic mail at daved@physiol.usyd.edu.au
+===========================================================================*/
+
+#ifndef UNRTF_H
+#define UNRTF_H
+
+typedef int (*unrtf_output_device_func)(void *, const char *, size_t);
+
+struct unRTFOutputDevice {
+ unrtf_output_device_func print;
+ void *data;
+};
+
+typedef struct unRTFOptions {
+ struct unRTFOutputDevice device; /* stdout if NULL */
+ const char *config_directory;
+ const char *output_format; /* DEFAULT_OUTPUT if NULL */
+
+ int nopict_mode; /* TRUE => Do not write \pict's to files */
+ int dump_mode; /* TRUE => Output a dump of the RTF word tree */
+ int debug_mode; /* TRUE => Output debug comments within HTML */
+ int simple_mode; /* TRUE => Output HTML without SPAN/DIV tags -- This would
+ probably be more useful if we could pull out <font> tags
+ as well. */
+ int inline_mode; /* TRUE => Output HTML without HTML/BODY/HEAD -- This is
+ buggy. I've seen it output pages of </font> tags. */
+ /* marcossamaral - 0.19.9 */
+ int verbose_mode; /* TRUE => Output additional informations about unrtf */
+ int no_remap_mode; /* don't remap codepoints */
+} unRTFOptions;
+
+void unrtf_set_output_device (unRTFOptions *, unrtf_output_device_func, void *);
+int unrtf_convert_from_filename (unRTFOptions *, const char *);
+int unrtf_convert_from_string (unRTFOptions *, const char *, size_t);
+
+#endif /* UNRTF_H */
diff -durpN unrtf-0.21.2.old/src/user.c unrtf-0.21.2/src/user.c
--- unrtf-0.21.2.old/src/user.c 2011-06-07 14:08:17.000000000 +0200
+++ unrtf-0.21.2/src/user.c 2013-01-17 02:41:09.689864239 +0100
@@ -7,7 +7,7 @@
*----------------------------------------------------------------------
* Changes:
* 21 Aug 10, daved@physiol.usyd.edu.au: test feof() rather than EOF for
- AIX support
+ AIX support
*--------------------------------------------------------------------*/
#ifndef HAVE_STDIO_H
@@ -38,9 +38,9 @@
typedef struct my_F
{
- FILE *file;
- int line_nr;
- char *name;
+ FILE *file;
+ int line_nr;
+ char *name;
} my_FILE;
@@ -54,15 +54,15 @@ typedef struct my_F
my_FILE *
my_fopen(char *file_name, char *mode)
{
- my_FILE *f = (my_FILE *) malloc(sizeof(my_FILE));
+ my_FILE *f = (my_FILE *) malloc(sizeof(my_FILE));
- if ((f->file = fopen(file_name, "r")) == NULL || (f->name = my_malloc((strlen(file_name) + 1) * sizeof(char))) == NULL)
- return NULL;
+ if ((f->file = fopen(file_name, "r")) == NULL || (f->name = unrtf_malloc((strlen(file_name) + 1) * sizeof(char))) == NULL)
+ return NULL;
- f->line_nr = 1;
- strcpy(f->name, file_name);
+ f->line_nr = 1;
+ strcpy(f->name, file_name);
- return f;
+ return f;
}
/*========================================================================
@@ -75,8 +75,8 @@ my_fopen(char *file_name, char *mode)
void
my_fclose(my_FILE *f)
{
- fclose(f->file);
- my_free(f->name);
+ fclose(f->file);
+ unrtf_free(f->name);
}
/*========================================================================
@@ -86,103 +86,103 @@ my_fclose(my_FILE *f)
* Returns: Definition or NULL on error.
*=======================================================================*/
-#define ADD_CHAR(char)\
- if (def_buffer_length == chars_nr)\
- {\
- if ((def = my_realloc(def, def_buffer_length, def_buffer_length * 2)) == NULL)\
- {\
- perror("Cannot allocate memory.");\
- return NULL;\
- }\
- def_buffer_length *= 2;\
- }\
- def[chars_nr] = char;\
- chars_nr++;
+#define ADD_CHAR(char) \
+ if (def_buffer_length == chars_nr) \
+ { \
+ if ((def = unrtf_realloc(def, def_buffer_length, def_buffer_length * 2)) == NULL) \
+ { \
+ perror("Cannot allocate memory."); \
+ return NULL; \
+ } \
+ def_buffer_length *= 2; \
+ } \
+ def[chars_nr] = char; \
+ chars_nr++;
char *
give_definition(my_FILE *file)
{
- char c, c2 = 0, c3 = 0, c4 = 0, *def, *unicode_char;
- int i;
- unsigned long def_buffer_length = STANDARD_BUFFER_LENGTH, chars_nr = 0;
+ char c, c2 = 0, c3 = 0, c4 = 0, *def, *unicode_char;
+ int i;
+ unsigned long def_buffer_length = STANDARD_BUFFER_LENGTH, chars_nr = 0;
- if ((def = my_malloc(def_buffer_length)) == NULL)
- return NULL;
+ if ((def = unrtf_malloc(def_buffer_length)) == NULL)
+ return NULL;
- c = fgetc(file->file);
+ c = fgetc(file->file);
- while (c == '\t' || c == '#')
- {
- if (c == '#')
- leave_line(file->file);
- else
- {
- c = fgetc(file->file);
+ while (c == '\t' || c == '#')
+ {
+ if (c == '#')
+ leave_line(file->file);
+ else
+ {
+ c = fgetc(file->file);
#if 1 /* daved 0.21.2 */
- while (c != '\n' && !feof(file->file))
+ while (c != '\n' && !feof(file->file))
#else
- while (c != '\n' && c != EOF)
+ while (c != '\n' && c != EOF)
#endif
- {
- if (c == 'U' && c2 == '<' && (c3 != '\\' || (c3 == '\\' && c4 == '\\')))
- {
- unicode_char = get_unicode_char(file->file);
+ {
+ if (c == 'U' && c2 == '<' && (c3 != '\\' || (c3 == '\\' && c4 == '\\')))
+ {
+ unicode_char = get_unicode_char(file->file);
- for (i = 0; unicode_char[i] != '\0'; i++)
- ADD_CHAR(unicode_char[i])
- c = fgetc(file->file);
- c2 = 0;
- c3 = 0;
- c4 = 0;
- }
- else
- {
- if (c2 == '<')
- {
- ADD_CHAR('<');
- }
+ for (i = 0; unicode_char[i] != '\0'; i++)
+ ADD_CHAR(unicode_char[i])
+ c = fgetc(file->file);
+ c2 = 0;
+ c3 = 0;
+ c4 = 0;
+ }
+ else
+ {
+ if (c2 == '<')
+ {
+ ADD_CHAR('<');
+ }
- /* daved - support \n in definitions */
- if (c == 'n' && c2 == '\\')
- {
- ADD_CHAR('\n');
- }
- else
- if (c != '<' && c != '\\' || (c == '\\' && c2 == '\\'))
- {
- ADD_CHAR(c)
- }
+ /* daved - support \n in definitions */
+ if (c == 'n' && c2 == '\\')
+ {
+ ADD_CHAR('\n');
+ }
+ else
+ if (c != '<' && c != '\\' || (c == '\\' && c2 == '\\'))
+ {
+ ADD_CHAR(c);
+ }
- c4 = c3;
- c3 = c2;
- c2 = c;
- c = fgetc(file->file);
- }
- }
+ c4 = c3;
+ c3 = c2;
+ c2 = c;
+ c = fgetc(file->file);
+ }
+ }
- file->line_nr++;
- ADD_CHAR('\n');
- }
+ file->line_nr++;
+ ADD_CHAR('\n');
+ }
- c = fgetc(file->file);
- }
+ c = fgetc(file->file);
+ }
#if 1 /* daved 0.21.2 */
- if (!feof(file->file))
+ if (!feof(file->file))
#else
- if (c != EOF)
+ if (c != EOF)
#endif
- {
- ungetc(c, file->file);
- }
+ {
+ ungetc(c, file->file);
+ }
- if (chars_nr > 0)
- def[chars_nr - 1] = '\0';
- else
- def[0] = '\0';
+ if (chars_nr > 0)
+ def[chars_nr - 1] = '\0';
+ else
+ def[0] = '\0';
- return def;
+ return def;
}
/*========================================================================
@@ -190,49 +190,71 @@ give_definition(my_FILE *file)
* Purpose: Tries to match known tag names with first argument
* Args: Tag name, Output Personality, file to read from
* Returns: -1 on error,
- 0 on success,
- 1 when tag name "name" is unknown
+ 0 on success,
+ 1 when tag name "name" is unknown
*=======================================================================*/
int
match_name (char *name, OutputPersonality *op, my_FILE *file)
{
- struct definition
- {
- char *name;
- char **variable;
- } defs[] = DEFS_ARRAY(op);
-
- char *endptr;
- int i;
+ struct definition
+ {
+ char *name;
+ char **variable;
+ } defs[] = DEFS_ARRAY(op);
+ char *def, *endptr;
+ int i;
#if 1 /* daved 0.21.0-rc2 */
- for (i = 0; defs[i].name && strcmp(defs[i].name, name); i++);
+ for (i = 0; defs[i].name && strcmp(defs[i].name, name); i++);
- if (!defs[i].name)
+ if (!defs[i].name)
#else
- for (i = 0; defs[i].name[0] != '\0' && strcmp(defs[i].name, name); i++);
+ for (i = 0; defs[i].name[0] != '\0' && strcmp(defs[i].name, name); i++);
- if (defs[i].name[0] == '\0')
+ if (defs[i].name[0] == '\0')
#endif
- {
- i = strtol(name, &endptr, 10);
+ {
+ i = strtol(name, &endptr, 10);
- if (*endptr == '\0')
- add_alias(op, i, give_definition(file));
- else if (name[0] == '<' && name[1] == 'U')
- add_alias(op, get_unicode(&name[2]), give_definition(file));
- else
- {
- fprintf(stderr, "unrtf: unknown name \"%s\" in line %d of \"%s\"\n", name, file->line_nr, file->name);
- return 1;
- }
- }
- else
- if ((*defs[i].variable = give_definition(file)) == NULL)
- return -1;
+ def = give_definition(file);
+ if (*endptr == '\0')
+ add_alias(op, i, def);
+ else if (name[0] == '<' && name[1] == 'U')
+ add_alias(op, get_unicode(&name[2]), def);
+ else
+ {
+ unrtf_free (def);
+ fprintf(stderr, "unrtf: unknown name \"%s\" in line %d of \"%s\"\n", name, file->line_nr, file->name);
+ return 1;
+ }
+ unrtf_free (def);
+ }
+ else
+ if ((*defs[i].variable = give_definition(file)) == NULL)
+ return -1;
- return 0;
+ return 0;
+}
+
+void
+free_user_definitions (OutputPersonality *op)
+{
+ struct definition
+ {
+ char *name;
+ char **variable;
+ } defs[] = DEFS_ARRAY(op);
+ char *variable;
+ int i;
+
+ for (i = 0; defs[i].name; i++)
+ {
+ variable = *defs[i].variable;
+ if (variable)
+ free(variable);
+ *defs[i].variable = NULL;
+ }
}
/*========================================================================
@@ -243,52 +265,55 @@ match_name (char *name, OutputPersonalit
*=======================================================================*/
OutputPersonality *
-user_init (OutputPersonality *op, char *definitions_file_path)
+user_init (const struct ConversionContext *cc, char *definitions_file_path)
{
- my_FILE *f;
- char name_buffer[BUFFER_SIZE];
+ my_FILE *f;
+ char name_buffer[BUFFER_SIZE];
+ OutputPersonality *op;
- if (op == NULL)
- op = op_create();
+ op = op_create(cc);
- if ((f = my_fopen(definitions_file_path, "r")) == NULL)
- {
- perror(definitions_file_path);
- return op;
- }
+ if ((f = my_fopen(definitions_file_path, "r")) == NULL)
+ {
+ perror(definitions_file_path);
+ op_free (op);
+ op = NULL;
+ return op;
+ }
#if 1 /* daved 0.21.2 */
- while
- (
- fgets(name_buffer, BUFFER_SIZE - 1, f->file) != NULL
- &&
- !feof(f->file)
- )
+ while
+ (
+ fgets(name_buffer, BUFFER_SIZE - 1, f->file) != NULL
+ &&
+ !feof(f->file)
+ )
#else
- while (fgets(name_buffer, BUFFER_SIZE - 1, f->file) != NULL)
+ while (fgets(name_buffer, BUFFER_SIZE - 1, f->file) != NULL)
#endif
- {
- if (name_buffer[strlen(name_buffer) - 1] != '\n')
- leave_line(f->file);
+ {
+ if (name_buffer[strlen(name_buffer) - 1] != '\n')
+ leave_line(f->file);
- f->line_nr++;
+ f->line_nr++;
- if (name_buffer[0] != '#' && name_buffer[0] != '\n')
- {
- name_buffer[strlen(name_buffer) - 1] = '\0';
+ if (name_buffer[0] != '#' && name_buffer[0] != '\n')
+ {
+ name_buffer[strlen(name_buffer) - 1] = '\0';
- if (match_name(name_buffer, op, f) == -1)
- {
- my_fclose(f);
- free(f);
- return NULL;
- }
- }
- }
+ if (match_name(name_buffer, op, f) == -1)
+ {
+ my_fclose(f);
+ free(f);
+ op_free (op);
+ return NULL;
+ }
+ }
+ }
- my_fclose(f);
- free(f);
+ my_fclose(f);
+ free(f);
- return op;
+ return op;
}
diff -durpN unrtf-0.21.2.old/src/user.h unrtf-0.21.2/src/user.h
--- unrtf-0.21.2.old/src/user.h 2010-07-04 04:30:58.000000000 +0200
+++ unrtf-0.21.2/src/user.h 2013-01-17 02:41:09.689864239 +0100
@@ -151,9 +151,10 @@
#ifndef _USER
+struct ConversionContext;
-extern OutputPersonality* user_init(OutputPersonality *, char *tags_file_path);
-
+extern OutputPersonality* user_init(const struct ConversionContext *cc, char *tags_file_path);
+extern void free_user_definitions (OutputPersonality *op);
#define _USER
#endif
diff -durpN unrtf-0.21.2.old/src/util.c unrtf-0.21.2/src/util.c
--- unrtf-0.21.2.old/src/util.c 2010-08-09 14:05:30.000000000 +0200
+++ unrtf-0.21.2/src/util.c 2013-01-17 02:41:09.689864239 +0100
@@ -110,7 +110,7 @@ concatenate (const char *s1, const char
{
char *result;
- result = my_malloc((strlen(s1) + strlen(s2) + 1) * sizeof(char));
+ result = unrtf_malloc((strlen(s1) + strlen(s2) + 1) * sizeof(char));
strcpy(result, s1);
strcat(result, s2);
diff -durpN unrtf-0.21.2.old/src/word.c unrtf-0.21.2/src/word.c
--- unrtf-0.21.2.old/src/word.c 2010-07-04 04:30:58.000000000 +0200
+++ unrtf-0.21.2/src/word.c 2013-01-17 02:41:09.689864239 +0100
@@ -1,23 +1,23 @@
/*=============================================================================
- GNU UnRTF, a command-line program to convert RTF documents to other formats.
- Copyright (C) 2000,2001,2004 by Zachary Smith
+ GNU UnRTF, a command-line program to convert RTF documents to other formats.
+ Copyright (C) 2000,2001,2004 by Zachary Smith
- 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 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.
+ 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, write to the Free Software
- Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- The maintainer is reachable by electronic mail at daved@physiol.usyd.edu.au
-=============================================================================*/
+ The maintainer is reachable by electronic mail at daved@physiol.usyd.edu.au
+ =============================================================================*/
/*----------------------------------------------------------------------
@@ -69,6 +69,7 @@
#endif
#include "defs.h"
+#include "convert.h"
#include "parse.h"
#include "malloc.h"
#include "main.h"
@@ -77,10 +78,6 @@
#include "hash.h"
-/* For word_dump */
-static int indent_level=0;
-
-
/*========================================================================
* Name: word_string
* Purpose: Obtains the string of a Word object. This involves accessing
@@ -90,12 +87,14 @@ static int indent_level=0;
*=======================================================================*/
char *
-word_string (Word *w) {
- char *str;
- CHECK_PARAM_NOT_NULL(w);
- if (w->hash_index) str = hash_get_string (w->hash_index);
- else str = NULL;
- return str;
+word_string (const struct ConversionContext *cc, Word *w) {
+ char *str;
+ CHECK_PARAM_NOT_NULL(w);
+
+ if (w->hash_index) str = hash_get_string (cc, w->hash_index);
+ else str = NULL;
+
+ return str;
}
@@ -108,24 +107,22 @@ word_string (Word *w) {
*=======================================================================*/
Word *
-word_new (char *str) {
- Word * w;
+word_new (struct ConversionContext *cc, char *str) {
+ Word * w;
- w = (Word *) my_malloc(sizeof(Word));
- if (!w)
- error_handler ("out of memory");
- memset ((void*) w, 0, sizeof(Word));
- if (!w) error_handler ("cannot allocate a Word");
+ w = (Word *) unrtf_malloc(sizeof(Word));
+ if (!w)
+ error_handler (cc, "out of memory");
+ memset ((void*) w, 0, sizeof(Word));
+ if (!w) error_handler (cc, "cannot allocate a Word");
- if (str) w->hash_index = hash_get_index (str);
- else w->hash_index = 0;
+ if (str) w->hash_index = hash_get_index (cc, str);
+ else w->hash_index = 0;
- return w;
+ return w;
}
-
-
/*========================================================================
* Name: word_free
* Purpose: Deallocates a Word object. This is only called at the end of
@@ -135,20 +132,20 @@ word_new (char *str) {
*=======================================================================*/
void word_free (Word *w) {
- Word *prev;
- Word *w2;
+ Word *prev;
+ Word *w2;
- CHECK_PARAM_NOT_NULL(w);
+ CHECK_PARAM_NOT_NULL(w);
- while (w) {
- w2 = w->child;
- if (w2)
- word_free(w2);
+ while (w) {
+ w2 = w->child;
+ if (w2)
+ word_free(w2);
- prev = w;
- w = w->next;
- my_free((char*) prev);
- }
+ prev = w;
+ w = w->next;
+ unrtf_free((char*) prev);
+ }
}
@@ -165,14 +162,14 @@ void word_free (Word *w) {
static void
print_indentation (int level)
{
- int i;
+ int i;
- if (level) {
- for (i=0;i<level;i+=2)
- printf (". ");
- } else {
- printf ("\n-----------------------------------------------------------------------\n\n");
- }
+ if (level) {
+ for (i=0;i<level;i+=2)
+ printf (". ");
+ } else {
+ printf ("\n-----------------------------------------------------------------------\n\n");
+ }
}
@@ -186,33 +183,33 @@ print_indentation (int level)
*=======================================================================*/
void
-word_dump (Word *w)
+word_dump (struct ConversionContext *cc, Word *w)
{
- char *s;
+ char *s;
- CHECK_PARAM_NOT_NULL(w);
+ CHECK_PARAM_NOT_NULL(w);
- printf ("\n");
- indent_level += 2;
- print_indentation (indent_level);
+ printf ("\n");
+ cc->indent_level += 2;
+ print_indentation (cc->indent_level);
- while (w) {
- s = word_string (w);
- if (s) {
- printf ("\"%s\" ", s);
- } else {
- if (w->child) {
- word_dump (w->child);
- printf ("\n");
- print_indentation (indent_level);
- }
- else
- warning_handler ("Word object has no string and no children");
- }
- w = w->next;
- }
+ while (w) {
+ s = word_string (cc, w);
+ if (s) {
+ printf ("\"%s\" ", s);
+ } else {
+ if (w->child) {
+ word_dump (cc, w->child);
+ printf ("\n");
+ print_indentation (cc->indent_level);
+ }
+ else
+ warning_handler ("Word object has no string and no children");
+ }
+ w = w->next;
+ }
- indent_level -= 2;
+ cc->indent_level -= 2;
}
#if 1 /* AK6 - AF */
@@ -223,56 +220,56 @@ word_dump (Word *w)
* Returns: Optimized word.
*=======================================================================*/
Word *
-optimize_word(Word *w)
+optimize_word(const struct ConversionContext *cc, Word *w)
{
- char *s, *s1;
- int i = 0, len;
- Collection *c = NULL;
- Tag tags_to_opt[] = OPT_ARRAY;
- Word *root = w, *w2;
+ char *s, *s1;
+ int i = 0, len;
+ Collection *c = NULL;
+ Tag tags_to_opt[] = OPT_ARRAY;
+ Word *root = w, *w2;
- for (; w != NULL; w = w->next)
- {
+ for (; w != NULL; w = w->next)
+ {
- if (s = word_string(w))
- {
- for (i = 0; tags_to_opt[i].name[0] != '\0'; i++)
- {
- if (tags_to_opt[i].has_param)
- {
- len = strlen(tags_to_opt[i].name);
- if (!strncmp(tags_to_opt[i].name, s, len) && (isdigit(s[len]) || s[len] == '-'))
- break;
- }
- else
- if (!strcmp(tags_to_opt[i].name, s))
- break;
- }
+ if (s = word_string(cc, w))
+ {
+ for (i = 0; tags_to_opt[i].name[0] != '\0'; i++)
+ {
+ if (tags_to_opt[i].has_param)
+ {
+ len = strlen(tags_to_opt[i].name);
+ if (!strncmp(tags_to_opt[i].name, s, len) && (isdigit(s[len]) || s[len] == '-'))
+ break;
+ }
+ else
+ if (!strcmp(tags_to_opt[i].name, s))
+ break;
+ }
- if (tags_to_opt[i].name[0] != '\0')
- {
- s1 = get_from_collection(c, i);
+ if (tags_to_opt[i].name[0] != '\0')
+ {
+ s1 = get_from_collection(c, i);
- if (s != NULL && s1 != NULL && !strcmp(s1, s))
- {
- w2->next = w->next;
- my_free((char *)w);
- w = w2;
- }
- else
- c = add_to_collection(c, i, s);
- }
- }
+ if (s != NULL && s1 != NULL && !strcmp(s1, s))
+ {
+ w2->next = w->next;
+ unrtf_free((char *)w);
+ w = w2;
+ }
+ else
+ c = add_to_collection(c, i, s);
+ }
+ }
- if (w->child != NULL)
- w->child = optimize_word(w->child);
+ if (w->child != NULL)
+ w->child = optimize_word(cc, w->child);
- w2 = w;
- }
+ w2 = w;
+ }
-// free_collection(c);
+ free_collection(c);
- return root;
+ return root;
}
#endif
diff -durpN unrtf-0.21.2.old/src/word.h unrtf-0.21.2/src/word.h
--- unrtf-0.21.2.old/src/word.h 2010-07-04 04:30:58.000000000 +0200
+++ unrtf-0.21.2/src/word.h 2013-01-17 02:41:09.689864239 +0100
@@ -41,14 +41,15 @@ typedef struct _w {
struct _w * child;
} Word;
-extern Word* word_new (char*);
+struct ConversionContext;
+
+extern Word* word_new (struct ConversionContext *, char*);
extern void word_free (Word*);
-extern Word* word_read (FILE*);
-extern char* word_string (Word*);
-extern void word_dump (Word*);
+extern char* word_string (const struct ConversionContext *, Word*);
+extern void word_dump (struct ConversionContext *, Word*);
extern void word_print_html (Word*);
-extern Word* optimize_word(Word*);
+extern Word* optimize_word(const struct ConversionContext *, Word*);
typedef struct _t {
char *name;
Reference in a new issue View git blame Copy permalink