#include "encoding.h"
#include "tag_data.h"
#include "buffer.h"
-#include "utf8.h"
+#include "utf8tools.h"
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#define MAXWRITELEN MAXGEDCLINELEN
+#define MAXCHARSETLEN 32
+char charset[MAXCHARSETLEN+1] = "ASCII";
const char* encoding = "ASCII";
int write_encoding_details = ONE_BYTE;
/* SYS_NEWLINE is defined in config.h */
}
int write_simple(Gedcom_write_hndl hndl,
- int level, char* xref, char* tag, char* value)
+ int level, const char* xref, const char* tag,
+ const char* value)
{
int res;
return 0;
}
+int write_encoding(Gedcom_write_hndl hndl,
+ int level, char* xref, char* tag, char* value)
+{
+ if (strcmp(value, charset))
+ gedcom_warning(_("Forcing HEAD.CHAR value to '%s'"), charset);
+ return write_simple(hndl, level, xref, tag, charset);
+}
+
int supports_continuation(int elt_or_rec, int which_continuation)
{
return tag_data[elt_or_rec].options & which_continuation;
}
int write_long(Gedcom_write_hndl hndl, int elt_or_rec,
- int level, char* xref, char* tag, char* value)
+ int level, const char* xref, const char* tag, const char* value)
{
- int prefix_len, value_len, term_len;
- char* nl_pos = strchr(value, '\n');
+ int prefix_len, value_len = 0, term_len;
+ char* nl_pos = NULL;
+ if (value) nl_pos = strchr(value, '\n');
prefix_len = utf8_strlen(tag) + 3; /* for e.g. "0 INDI " */
if (level > 9) prefix_len++;
if (xref) prefix_len += utf8_strlen(xref) + 1;
- value_len = utf8_strlen(value);
+ if (value) value_len = utf8_strlen(value);
term_len = strlen(hndl->term);
if (!nl_pos && prefix_len + value_len + term_len <= MAXWRITELEN)
write_simple(hndl, level, xref, tag, value);
else {
- char* value_ptr = value;
+ const char* value_ptr = value;
int cont_supported = supports_continuation(elt_or_rec, OPT_CONT);
int cont_as_conc = supports_continuation(elt_or_rec, OPT_CONT_AS_CONC);
if (nl_pos && !cont_supported) {
- gedcom_error (_("The tag %s doesn't support newlines\n"), tag);
+ gedcom_error (_("The tag %s doesn't support newlines"), tag);
return 1;
}
else {
return 0;
}
-int gedcom_write_set_encoding(const char* charset,
+int gedcom_write_set_encoding(const char* new_charset,
Encoding width, Enc_bom bom)
{
char* new_encoding = NULL;
- if (!strcmp(charset, "UNICODE")) {
+ if (!strcmp(new_charset, "UNICODE")) {
if (width == ONE_BYTE) {
gedcom_error(_("Unicode cannot be encoded into one byte"));
return 1;
}
else {
- new_encoding = get_encoding(charset, width);
+ new_encoding = get_encoding(new_charset, width);
if (new_encoding) {
encoding = new_encoding;
write_encoding_details = width | bom;
+ strncpy(charset, new_charset, MAXCHARSETLEN);
}
else
return 1;
}
}
else {
- new_encoding = get_encoding(charset, ONE_BYTE);
+ new_encoding = get_encoding(new_charset, ONE_BYTE);
if (new_encoding) {
encoding = new_encoding;
write_encoding_details = ONE_BYTE;
+ strncpy(charset, new_charset, MAXCHARSETLEN);
}
else
return 1;
}
}
else {
- gedcom_error(_("The element or record type '%s' requires a specific tag"
+ gedcom_error(_("The element or record type '%s' requires a specific tag "
"for writing"),
tag_data[elt_or_rec].elt_name);
return NULL;
tag_str = get_tag_string(rec_or_elt, tag);
level = get_level(hndl, rec_or_elt, parent_rec_or_elt);
if (tag_str && (level != -1)) {
- if (supports_continuation(rec_or_elt, OPT_CONT|OPT_CONC|OPT_CONT_AS_CONC))
+ if (rec_or_elt == ELT_HEAD_CHAR)
+ result = write_encoding(hndl, level, xrefstr, tag_str, val);
+ else if (supports_continuation(rec_or_elt, OPT_CONT|OPT_CONC))
result = write_long(hndl, rec_or_elt, level, xrefstr, tag_str, val);
else
result = write_simple(hndl, level, xrefstr, tag_str, val);
}
int gedcom_write_record_str(Gedcom_write_hndl hndl,
- Gedcom_rec rec, int tag,
- char* xrefstr, char* val)
+ Gedcom_rec rec, char* xrefstr, char* val)
{
int result = 1;
if (check_type(rec, (val ? GV_CHAR_PTR : GV_NULL)))
- result = _gedcom_write_val(hndl, rec, tag, -1, xrefstr, convert_at(val));
+ result = _gedcom_write_val(hndl, rec, 0, -1, xrefstr, convert_at(val));
return result;
}
return result;
}
-int gedcom_write_record_xref(Gedcom_write_hndl hndl,
- Gedcom_rec rec, int tag,
- char* xrefstr, struct xref_value* val)
-{
- int result = 1;
- if (check_type(rec, (val ? GV_XREF_PTR : GV_NULL)))
- result = _gedcom_write_val(hndl, rec, tag, -1, xrefstr, val->string);
- return result;
-}
-
int gedcom_write_element_xref(Gedcom_write_hndl hndl,
Gedcom_elt elt, int tag, int parent_rec_or_elt,
struct xref_value* val)