Copyright (C) 1995, 1996 Ben Wing.
Copyright (C) 1995, 1997, 1999 Electrotechnical Laboratory, JAPAN.
Licensed to the Free Software Foundation.
- Copyright (C) 1999,2000,2001,2002,2003,2004 MORIOKA Tomohiko
+ Copyright (C) 1999,2000,2001,2002,2003,2004,2005,2006 MORIOKA Tomohiko
This file is part of XEmacs.
extern Lisp_Object Qideographic_structure;
Lisp_Object Vnext_defined_char_id;
-EXFUN (Fdefine_char, 1);
EXFUN (Fmap_char_attribute, 3);
Lisp_Object Qcomposition;
+Lisp_Object Qmap_decomposition;
+Lisp_Object Qto_decomposition_at_superscript;
+Lisp_Object Qto_decomposition_at_circled;
+Lisp_Object Q_canonical;
+Lisp_Object Q_halfwidth_of;
+Lisp_Object Q_superscript_of;
+Lisp_Object Q_subscript_of;
+Lisp_Object Q_circled_of;
Lisp_Object Q_decomposition;
Lisp_Object Q_identical;
Lisp_Object Q_identical_from;
*/
(character))
{
- Lisp_Object ret;
-
CHECK_CHAR (character);
- ret = Fchar_feature (character, Q_ucs_unified, Qnil,
- Qnil, Qnil);
- if (CONSP (ret))
- return Fcopy_list (ret);
- else
- return Qnil;
+ return
+ nconc2
+ (Fcopy_list (Fget_char_attribute (character, Q_subsumptive, Qnil)),
+ (nconc2
+ (Fcopy_list (Fget_char_attribute (character, Q_denotational, Qnil)),
+ (nconc2
+ (Fcopy_list (Fget_char_attribute (character, Q_identical, Qnil)),
+ Fcopy_list (Fchar_feature (character, Q_ucs_unified, Qnil,
+ Qnil, Qnil)))))));
}
#endif
{
switch (type)
{
- default: abort();
+ default: ABORT();
case CHAR_TABLE_TYPE_GENERIC: return Qgeneric;
case CHAR_TABLE_TYPE_SYNTAX: return Qsyntax;
case CHAR_TABLE_TYPE_DISPLAY: return Qdisplay;
When Mule support exists, the types of ranges that can be assigned
values are
--- all characters
+-- all characters (represented by t)
-- an entire charset
--- a single row in a two-octet charset
+-- a single row in a two-octet charset (represented by a vector of two
+ elements: a two-octet charset and a row number; the row must be an
+ integer, not a character)
-- a single character
When Mule support is not present, the types of ranges that can be
assigned values are
--- all characters
+-- all characters (represented by t)
-- a single character
To create a char table, use `make-char-table'.
break;
default:
- abort ();
+ ABORT ();
}
return Qnil;
return (0 << 8) | 255;
#endif
default:
- abort ();
+ ABORT ();
return 0;
}
}
}
#endif
else
- abort ();
+ ABORT ();
}
else
{
}
DEFUN ("get-range-char-table", Fget_range_char_table, 2, 3, 0, /*
-Find value for a range in CHAR-TABLE.
+Find value for RANGE in CHAR-TABLE.
If there is more than one value, return MULTI (defaults to nil).
+
+Valid values for RANGE are single characters, charsets, a row in a
+two-octet charset, and all characters. See `put-char-table'.
*/
(range, char_table, multi))
{
#endif /* not UTF2000 */
#endif /* not MULE */
+#ifdef UTF2000
+ case CHARTAB_RANGE_DEFAULT:
+ return ct->default_value;
+#endif /* not UTF2000 */
+
default:
- abort ();
+ ABORT ();
}
return Qnil; /* not reached */
break;
default:
- abort ();
+ ABORT ();
}
return 0; /* not reached */
-- t (all characters are affected)
-- A charset (only allowed when Mule support is present)
--- A vector of two elements: a two-octet charset and a row number
- (only allowed when Mule support is present)
+-- A vector of two elements: a two-octet charset and a row number; the row
+ must be an integer, not a character (only allowed when Mule support is
+ present)
-- A single character
VALUE must be a value appropriate for the type of CHAR-TABLE.
break;
default:
- abort ();
+ ABORT ();
}
return 0;
}
default:
- abort ();
+ ABORT ();
}
return 0;
ranjarg = make_char (range->ch);
break;
default:
- abort ();
+ ABORT ();
}
closure->retval = call2 (closure->function, ranjarg, val);
}
DEFUN ("map-char-table", Fmap_char_table, 2, 3, 0, /*
-Map FUNCTION over entries in CHAR-TABLE, calling it with two args,
-each key and value in the table.
+Map FUNCTION over CHAR-TABLE until it returns non-nil; return that value.
+FUNCTION is called with two arguments, each key and entry in the table.
RANGE specifies a subrange to map over and is in the same format as
the RANGE argument to `put-range-table'. If omitted or t, it defaults to
return default_value;
}
-void put_char_composition (Lisp_Object character, Lisp_Object value);
-void
+Lisp_Object
+put_char_composition (Lisp_Object character, Lisp_Object value);
+Lisp_Object
put_char_composition (Lisp_Object character, Lisp_Object value)
{
if (!CONSP (value))
- signal_simple_error ("Invalid value for ->decomposition",
+ signal_simple_error ("Invalid value for =decomposition",
value);
- if (CONSP (Fcdr (value)))
+ if (CONSP (XCDR (value)))
{
- if (NILP (Fcdr (Fcdr (value))))
+ if (NILP (Fcdr (XCDR (value))))
{
- Lisp_Object base = Fcar (value);
- Lisp_Object modifier = Fcar (Fcdr (value));
+ Lisp_Object base = XCAR (value);
+ Lisp_Object modifier = XCAR (XCDR (value));
if (INTP (base))
{
if (INTP (modifier))
{
modifier = make_char (XINT (modifier));
- Fsetcar (Fcdr (value), modifier);
+ Fsetcar (XCDR (value), modifier);
}
if (CHARP (base))
{
else
Fsetcdr (ret, character);
}
+ else if (EQ (base, Qnarrow))
+ return Q_halfwidth_of;
+ else if (EQ (base, Qsuper))
+ return Q_superscript_of;
+ else if (EQ (base, Qsub))
+ return Q_subscript_of;
+ else if (EQ (base, Qcircle))
+ return Q_circled_of;
+ else if ( EQ (base, Qisolated)||
+ EQ (base, Qinitial) ||
+ EQ (base, Qmedial) ||
+ EQ (base, Qfinal) )
+ return
+ Fintern (concat2 (build_string ("<-formed@"),
+ Fsymbol_name (base)),
+ Qnil);
+ else if (SYMBOLP (base))
+ return
+ Fintern (concat2 (build_string ("<-"),
+ Fsymbol_name (base)),
+ Qnil);
}
+ else if (EQ (XCAR (value), Qsuper))
+ return Qto_decomposition_at_superscript;
+ else if (EQ (XCAR (value), Qcircle))
+ return Qto_decomposition_at_circled;
+ else
+ return
+ Fintern (concat2 (build_string ("=>decomposition@"),
+ Fsymbol_name (XCAR (value))),
+ Qnil);
}
else
{
+ return Q_canonical;
+#if 0
Lisp_Object v = Fcar (value);
if (INTP (v))
{
- Emchar c = XINT (v);
+ Emchar c = DECODE_CHAR (Vcharset_ucs, XINT (v), 0);
Lisp_Object ret
= Fchar_feature (make_char (c), Q_ucs_unified, Qnil,
Qnil, Qnil);
Fcons (character, ret));
}
}
+#endif
}
+ return Qmap_decomposition;
}
static Lisp_Object
value = put_char_ccs_code_point (character, ccs, value);
attribute = XCHARSET_NAME (ccs);
}
- else if (EQ (attribute, Q_decomposition))
- put_char_composition (character, value);
+ else if ( EQ (attribute, Qmap_decomposition) ||
+ EQ (attribute, Q_decomposition) )
+ {
+ value = Fcopy_sequence (Fchar_refs_simplify_char_specs (value));
+ attribute = put_char_composition (character, value);
+ if ( !EQ (attribute, Qmap_decomposition) &&
+ SYMBOLP (XCAR (value)) )
+ value = XCDR (value);
+ }
else if (EQ (attribute, Qto_ucs))
{
Lisp_Object ret;
if (!INTP (value))
signal_simple_error ("Invalid value for =>ucs", value);
- c = XINT (value);
+ c = DECODE_CHAR (Vcharset_ucs, XINT (value), 0);
ret = Fchar_feature (make_char (c), Q_ucs_unified, Qnil,
Qnil, Qnil);
Fput_char_attribute (make_char (c), Q_ucs_unified,
Fcons (character, ret));
}
- else if ( EQ (attribute, Q_subsumptive) ||
- EQ (attribute, Q_subsumptive_from) ||
- EQ (attribute, Q_denotational) ||
- EQ (attribute, Q_denotational_from) ||
- EQ (attribute, Q_identical) ||
- EQ (attribute, Q_identical_from) ||
- EQ (attribute, Q_component) ||
- EQ (attribute, Q_component_of) ||
- !NILP (Fstring_match
- (build_string ("^\\(<-\\|->\\)\\(simplified"
- "\\|same\\|vulgar\\|wrong"
- "\\|original\\|ancient"
- "\\)[^*]*$"),
+ if ( EQ (attribute, Q_subsumptive) ||
+ EQ (attribute, Q_subsumptive_from) ||
+ EQ (attribute, Q_denotational) ||
+ EQ (attribute, Q_denotational_from) ||
+ EQ (attribute, Q_identical) ||
+ EQ (attribute, Q_identical_from) ||
+ EQ (attribute, Q_canonical) ||
+ EQ (attribute, Q_halfwidth_of) ||
+ EQ (attribute, Q_superscript_of) ||
+ EQ (attribute, Q_subscript_of) ||
+ EQ (attribute, Q_circled_of) ||
+ EQ (attribute, Q_component) ||
+ EQ (attribute, Q_component_of) ||
+ ( !EQ (attribute, Q_ucs_unified)
+ && !NILP (Fstring_match
+ (build_string ("^\\(<-\\|->\\)[^*]*$"),
Fsymbol_name (attribute),
- Qnil, Qnil)) )
+ Qnil, Qnil))
+ )
+ )
{
Lisp_Object rest = value;
Lisp_Object ret;
if (CONSP (ret))
ret = Fdefine_char (ret);
-
+ else if (INTP (ret))
+ {
+ int code_point = XINT (ret);
+ Emchar cid = DECODE_CHAR (Vcharset_ucs, code_point, 0);
+
+ if (cid >= 0)
+ ret = make_char (cid);
+ else
+ ret = make_char (code_point);
+ }
+
if ( !NILP (ret) && !EQ (ret, character) )
{
Lisp_Object ffv;
UNGCPRO;
}
#if 1
- else if (EQ (attribute, Qideographic_structure))
+ else if ( EQ (attribute, Qideographic_structure) ||
+ !NILP (Fstring_match
+ (build_string ("^=>decomposition\\(\\|@[^*]+\\)$"),
+ Fsymbol_name (attribute),
+ Qnil, Qnil)) )
value = Fcopy_sequence (Fchar_refs_simplify_char_specs (value));
#endif
return put_char_attribute (character, attribute, value);
{
if (default_chise_data_source == NULL)
{
- Lisp_Object db_dir = Vexec_directory;
+ Lisp_Object db_dir = Vdata_directory;
int modemask = 0755; /* rwxr-xr-x */
if (NILP (db_dir))
- db_dir = build_string ("../lib-src");
+ db_dir = build_string ("../etc");
db_dir = Fexpand_file_name (build_string ("chise-db"), db_dir);
default_chise_data_source
0 /* DB_HASH */, modemask);
if (default_chise_data_source == NULL)
return -1;
+#if 0
+ chise_ds_set_make_string_function (default_chise_data_source,
+ &make_string);
+#endif
}
return 0;
}
if (!status)
{
+#if 0
val = Fread (make_string (chise_value_data (&value),
chise_value_size (&value) ));
+#else
+ val = read_from_c_string (chise_value_data (&value),
+ chise_value_size (&value) );
+#endif
}
else
val = Qunbound;
char_attribute_system_db_file (Lisp_Object key_type, Lisp_Object attribute,
int writing_mode)
{
- Lisp_Object db_dir = Vexec_directory;
+ Lisp_Object db_dir = Vdata_directory;
if (NILP (db_dir))
- db_dir = build_string ("../lib-src");
+ db_dir = build_string ("../etc");
db_dir = Fexpand_file_name (build_string ("chise-db"), db_dir);
if (writing_mode && NILP (Ffile_exists_p (db_dir)))
}
#endif /* not HAVE_LIBCHISE */
-#ifdef HAVE_LIBCHISE
-Lisp_Object save_charset_properties (Lisp_Object charset);
-#endif /* HAVE_LIBCHISE */
-
DEFUN ("save-char-attribute-table", Fsave_char_attribute_table, 1, 1, 0, /*
Save values of ATTRIBUTE into database file.
*/
Lisp_Object (*filter)(Lisp_Object value);
if ( !NILP (Ffind_charset (attribute)) )
- {
-#ifdef HAVE_LIBCHISE
- save_charset_properties (attribute);
-#endif /* HAVE_LIBCHISE */
- filter = NULL;
- }
- else if ( EQ (attribute, Qideographic_structure)
- || EQ (attribute, Q_identical)
- || EQ (attribute, Q_identical_from)
- || !NILP (Fstring_match
- (build_string ("^\\(<-\\|->\\)\\(simplified"
- "\\|same\\|vulgar\\|wrong"
- "\\|original\\|ancient"
- "\\)[^*]*$"),
- Fsymbol_name (attribute),
- Qnil, Qnil)) )
+ filter = NULL;
+ else if ( EQ (attribute, Qideographic_structure) ||
+ EQ (attribute, Q_identical) ||
+ EQ (attribute, Q_identical_from) ||
+ EQ (attribute, Q_canonical) ||
+ EQ (attribute, Q_halfwidth_of) ||
+ EQ (attribute, Q_superscript_of) ||
+ EQ (attribute, Q_subscript_of) ||
+ EQ (attribute, Q_circled_of) ||
+ !NILP (Fstring_match
+ (build_string ("^\\(<-\\|->\\)\\(simplified"
+ "\\|same\\|vulgar\\|wrong"
+ "\\|original\\|ancient"
+ "\\|Oracle-Bones\\)[^*]*$"),
+ Fsymbol_name (attribute),
+ Qnil, Qnil)) )
filter = &Fchar_refs_simplify_char_specs;
else
filter = NULL;
#endif /* HAVE_CHISE */
DEFUN ("map-char-attribute", Fmap_char_attribute, 2, 3, 0, /*
-Map FUNCTION over entries in ATTRIBUTE, calling it with two args,
-each key and value in the table.
+Map FUNCTION over ATTRIBUTE until it returns non-nil; return that value.
+FUNCTION is called with two arguments, each key and entry in the table.
-RANGE specifies a subrange to map over and is in the same format as
-the RANGE argument to `put-range-table'. If omitted or t, it defaults to
+RANGE specifies a subrange to map over. If omitted or t, it defaults to
the entire table.
+
+Both RANGE and the keys passed to FUNCTION are in the same format as the
+RANGE argument to `put-char-table'. N.B. This function does NOT map over
+all characters in RANGE, but over the subranges that have been assigned to.
+Thus this function is most suitable for searching a char-table, or for
+populating one char-table based on the contents of another. The current
+implementation does not coalesce ranges all of whose values are the same.
*/
(function, attribute, range))
{
Fput_char_table (make_char (i), val, chartab);
}
else
- abort ();
+ ABORT ();
}
else
Fput_char_table (range, val, chartab);
void
syms_of_chartab (void)
{
+#if defined(UTF2000) || defined(HAVE_CONCORD)
+ defsymbol (&Q_subsumptive, "->subsumptive");
+ defsymbol (&Q_subsumptive_from, "<-subsumptive");
+ defsymbol (&Q_denotational, "->denotational");
+ defsymbol (&Q_denotational_from, "<-denotational");
+#endif
#ifdef UTF2000
INIT_LRECORD_IMPLEMENTATION (uint8_byte_table);
INIT_LRECORD_IMPLEMENTATION (uint16_byte_table);
defsymbol (&Qto_ucs, "=>ucs");
defsymbol (&Q_ucs_unified, "->ucs-unified");
- defsymbol (&Q_subsumptive, "->subsumptive");
- defsymbol (&Q_subsumptive_from, "<-subsumptive");
- defsymbol (&Q_denotational, "->denotational");
- defsymbol (&Q_denotational_from, "<-denotational");
defsymbol (&Q_identical, "->identical");
defsymbol (&Q_identical_from, "<-identical");
defsymbol (&Q_component, "->ideographic-component-forms");
defsymbol (&Q_component_of, "<-ideographic-component-forms");
defsymbol (&Qcomposition, "composition");
+ defsymbol (&Qmap_decomposition, "=decomposition");
+ defsymbol (&Qto_decomposition_at_superscript,
+ "=>decomposition@superscript");
+ defsymbol (&Qto_decomposition_at_circled, "=>decomposition@circled");
+ defsymbol (&Q_canonical, "->canonical");
+ defsymbol (&Q_halfwidth_of, "<-halfwidth");
+ defsymbol (&Q_superscript_of, "<-superscript");
+ defsymbol (&Q_subscript_of, "<-subscript");
+ defsymbol (&Q_circled_of, "<-circled");
defsymbol (&Q_decomposition, "->decomposition");
defsymbol (&Qcompat, "compat");
defsymbol (&Qisolated, "isolated");