Mercurial > emacs
view src/character.c @ 94414:d86cb59eea9f
2008-04-27 Carsten Dominik <dominik@science.uva.nl>
* org/org.el (org-html-level-start): Always have id's in HTML
(org-export-as-html): Use `org-link-protocols' to
retrieve the export form of the link.
(org-add-link-type): Final parameter renamed from PUBLISH. Better
documentation of how it is to be used. Avoid double entries for
the same link type.
(org-add-link-props): New function.
(org-modules-loaded): New variable.
(org-load-modules-maybe, org-set-modules): New function.
(org-modules): New option.
(org-mode, org-cycle, orgstruct-mode, org-run-like-in-org-mode)
(orgtbl-mode, org-store-link, org-insert-link-global)
(org-open-at-point): Call `org-load-modules-maybe'.
(org-search-view): Add more text properties.
(org-agenda-schedule, org-agenda-deadline): Allow also in
search-type agendas.
(org-search-view): Order of arguments has been changed.
Interpret prefix-arg as TODO-ONLY.
(org-agenda, org-run-agenda-series, org-agenda-manipulate-query):
Take new argument order of `org-search-view' into account.
(org-todo-only): New variable.
(org-search-syntax-table): New variable and function.
(org-search-view): Do the search with the special syntax table.
(define-obsolete-function-alias): Make work with XEmacs.
(org-add-planning-info): Use old date as default when modifying an
existing deadline or scheduled item.
(org-agenda-compute-time-span): Make argument N optional.
(org-agenda-format-date-aligned): Require `cal-iso'.
(org-agenda-list): Include week into into agenda heading, don't
list it at each date (only on Mondays).
(org-read-date-analyze): Define local variable `iso-date'.
(org-agenda-format-date-aligned): Remove dependency on
`calendar-time-from-absolute'.
(org-remember-apply-template, org-go-to-remember-target):
Interpret filenames relative to `org-directory'.
(org-complete): Silently fail when trying to complete
keywords that don't have a default value.
(org-get-current-options): Added a #+DATE: option.
(org-additional-option-like-keywords): Removed "DATE:" from the
list of additional keywords.
(org-export-as-html): Removed (current-time) as unnecessary second
argument of `format-time-string'.
(org-clock-find-position): Handle special case at end of
buffer.
(org-agenda-day-view): New argument DAY-OF-YEAR, pass it on to
`org-agenda-change-time-span'.
(org-agenda-week-view): New argument ISO-WEEK, pass it on to
`org-agenda-change-time-span'.
(org-agenda-month-view): New argument MONTH, pass it on to
`org-agenda-change-time-span'.
(org-agenda-year-view): New argument YEAR, pass it on to
`org-agenda-change-time-span'.
(org-agenda-change-time-span): New optional argument N, pass it on
to `org-agenda-compute-time-span'.
(org-agenda-compute-time-span): New argument N, interpret it by
changing the starting day.
(org-small-year-to-year): New function.
(org-scheduled-past-days): Respect
`org-scheduled-past-days'.
(org-auto-repeat-maybe): Make sure that repeating
dates are pushed into the future, and that the shift is at least
one interval, never 0.
(org-update-checkbox-count): Fix bug with checkbox
counting.
(org-add-note): New command.
(org-add-log-setup): Renamed from `org-add-log-maybe'.
(org-log-note-headings): New entry for plain notes (i.e. notes not
related to state changes or clocking).
(org-get-org-file): Check for availability of
`remember-data-file'.
(org-cached-entry-get): Allow a regexp value for
`org-use-property-inheritance'.
(org-use-property-inheritance): Allow regexp value. Fix bug in
customization type.
(org-use-tag-inheritance): Allow a list and a regexp value for
this variable.
(org-scan-tags, org-get-tags-at): Implement selective tag
inheritance.
(org-entry-get): Respect value `selective' for the INHERIT
argument.
(org-tag-inherit-p, org-property-inherit-p): New functions.
(org-agenda-format-date-aligned): Allow 10 characters for
weekday, to acomodate German locale.
(org-add-archive-files): New function.
(org-agenda-files): New argument `ext', to
get archive files as well.
(org-tbl-menu): Protect the use of variables that
are only available when org-table.el gets loaded.
(org-read-agenda-file-list): Error if `org-agenda-files' is a
single directory.
(org-open-file): Allow a batch process to trigger
waiting after executing a system command.
(org-store-link): Link to headline when there is not
target and no region in an org-mode buffer when creating a link.
(org-link-types-re): New variable.
(org-make-link-regexps): Compute `org-link-types-re'.
(org-make-link-description-function): New option.
(org-agenda-date, org-agenda-date-weekend): New faces.
(org-archive-sibling-heading): New option.
(org-archive-to-archive-sibling): New function.
(org-iswitchb): New command.
(org-buffer-list): New function.
(org-agenda-columns): Also try the #+COLUMNS line in
the buffer associated with the entry at point (or with the first
entry in the agenda view).
(org-modules): Add entry for org-bibtex.el.
(org-completion-fallback-command): Moved into `org-completion'
group.
(org-clock-heading-function): Moved to `org-progress' group.
(org-auto-repeat-maybe): Make sure that a note can
be enforces if `org-log-repeat' is `note'.
(org-modules): Allow additional symbols for external
packages.
(org-ctrl-c-ctrl-c): Allow for `org-clock-overlays' to be
undefined.
(org-clock-goto): Hide drawers after showing an
entry with `org-clock-goto.'
(org-shiftup, org-shiftdown, org-shiftright, org-shiftleft): Try
also a clocktable block shift.
(org-clocktable-try-shift): New function.
(org-columns-hscoll-title): New function.
(org-columns-previous-hscroll): New variable.
(org-columns-full-header-line-format): New variable.
(org-columns-display-here-title, org-columns-remove-overlays):
Install `org-columns-hscoll-title' in post-command-hook.
* org/org.el: Split into many small files.
* org/org-agenda.el: New file, split off from org.el.
* org/org-archive.el: New file, split off from org.el.
* org/org-bbdb.el: New file.
* org/org-bibtex.el: New file, split off from org.el.
* org/org-clock.el: New file, split off from org.el.
* org/org-colview.el: New file, split off from org.el.
* org/org-compat.el: New file, split off from org.el.
* org/org-exp.el: New file, split off from org.el.
* org/org-faces.el: New file, split off from org.el.
* org/org-gnus.el: New file, split off from org.el.
* org/org-info.el: New file, split off from org.el.
* org/org-infojs.el: New file.
* org/org-irc.el: New file.
* org/org-macs.el: New file, split off from org.el.
* org/org-mew.el: New file.
* org/org-mhe.el: New file, split off from org.el.
* org/org-publish.el: New file, split off from org.el.
* org/org-remember.el: New file, split off from org.el.
* org/org-rmail.el: New file, split off from org.el.
* org/org-table.el: New file, split off from org.el.
* org/org-vm.el: New file, split off from org.el.
* org/org-wl.el: New file, split off from org.el.
2008-04-27 Jason Riedy <jason@acm.org>
* lisp/org-table.el (orgtbl-to-generic): Add a :remove-nil-lines
parameter that supresses lines that evaluate to NIL.
(orgtbl-get-fmt): New inline function for
picking apart formats that may be lists.
(orgtbl-apply-fmt): New inline function for applying formats that
may be functions.
(orgtbl-eval-str): New inline function for strings that may be
functions.
(orgtbl-format-line, orgtbl-to-generic): Use and document.
(orgtbl-to-latex, orgtbl-to-texinfo): Document.
(*orgtbl-llfmt*, *orgtbl-llstart*)
(*orgtbl-llend*): Dynamic variables for last-line formatting.
(orgtbl-format-section): Shift formatting to support detecting the
last line and formatting it specially.
(orgtbl-to-generic): Document :ll* formats. Set to the non-ll
formats unless overridden.
(orgtbl-to-latex): Suggest using :llend to suppress the final \\.
(*orgtbl-table*, *orgtbl-rtn*): Dynamically
bound variables to hold the input collection of lines and output
formatted text.
(*orgtbl-hline*, *orgtbl-sep*, *orgtbl-fmt*, *orgtbl-efmt*,
(*orgtbl-lfmt*, *orgtbl-lstart*, *orgtbl-lend*): Dynamically bound
format parameters.
(orgtbl-format-line): New function encapsulating formatting for a
single line.
(orgtbl-format-section): Similar for each section. Rebinding the
dynamic vars customizes the formatting for each section.
(orgtbl-to-generic): Use orgtbl-format-line and
orgtbl-format-section.
(org-get-param): Now unused, so delete.
(orgtbl-gather-send-defs): New function to
gather all the SEND definitions before a table.
(orgtbl-send-replace-tbl): New function to find the RECEIVE
corresponding to the current name.
(orgtbl-send-table): Use the previous two functions and implement
multiple destinations for each table.
* doc/org.texi (A LaTeX example): Note that fmt may be a
one-argument function, and efmt may be a two-argument function.
(Radio tables): Document multiple destinations.
2008-04-27 Carsten Dominik <dominik@science.uva.nl>
* org/org-agenda.el (org-add-to-diary-list): New function.
(org-prefix-has-effort): New variable.
(org-sort-agenda-noeffort-is-high): New option.
(org-agenda-columns-show-summaries)
(org-agenda-columns-compute-summary-properties): New options.
(org-format-agenda-item): Compute the duration of the item.
(org-agenda-weekend-days): New variable.
(org-agenda-list, org-timeline): Use the proper faces for dates in
the agenda and timeline buffers.
(org-agenda-archive-to-archive-sibling): New command.
(org-agenda-start-with-clockreport-mode): New option.
(org-agenda-clockreport-parameter-plist): New option.
(org-agenda-clocktable-mode): New variable.
(org-agenda-deadline-leaders): Allow a function value for the
deadline leader.
(org-agenda-get-deadlines): Deal with new function value.
* lisp/org-clock.el (org-clock): New customization group.
(org-clock-into-drawer, org-clock-out-when-done)
(org-clock-in-switch-to-state, org-clock-heading-function): Moved
into the new group.
(org-clock-out-remove-zero-time-clocks): New option.
(org-clock-out): Use `org-clock-out-remove-zero-time-clocks'.
(org-dblock-write:clocktable): Allow a Lisp form for the scope
parameter.
(org-dblock-write:clocktable): Fixed bug with total time
calculation.
(org-dblock-write:clocktable): Request the unrestricted list of
files.
(org-get-clocktable): New function.
(org-dblock-write:clocktable): Make sure :tstart and :tend can not
only be strings but also integers (an absolute day number) and
lists (m d y).
* org/org-colview.el (org-columns-next-allowed-value)
(org-columns-edit-value): Limit the effort for updatig in the
agenda to recomputing a single file.
(org-columns-compute): Only write property value if it has
changed. This avoids raising the buffer-change-flag
unnecessarily.
(org-agenda-colview-summarize)
(org-agenda-colview-compute): New functions.
(org-agenda-columns): Call `org-agenda-colview-summarize'.
* org/org-exp.el (org-export-run-in-background): New option.
(org-export-icalendar): Allow a batch process to trigger waiting
after executing a system command.
(org-export-preprocess-string): Renamed-from
`org-cleaned-string-for-export'.
(org-export-html-style): Made target class look like normal text.
(org-export-as-html): Make use of the better proprocessing in
`org-cleaned-string-for-export'.
(org-cleaned-string-for-export): Better treatment of heuristic
targets, many more internal links will now work in HTML export.
(org-get-current-options): Incorporate LINK_UP, LINK_HOME, and
INFOJS.
(org-export-inbuffer-options-extra): New variable.
(org-export-options-filters): New hook.
(org-infile-export-plist): Find also the settings keywords in
`org-export-inbuffer-options-extra'.
(org-infile-export-plist): Allow multiple #+OPTIONS lines and
multiple #+INFOJS_OPT lines.
(org-export-html-handle-js-options): New function.
(org-export-html-infojs-setup): New option.
(org-export-as-html): Call `org-export-html-handle-js-options'.
Add autoload to all entry points.
(org-skip-comments): Function removed.
* org/org-table.el (org-table-make-reference): Extra parenthesis
around single fields, to make sure that algebraic formulas get
correctly interpreted by calc.
(org-table-current-column): No longer interactive.
* org/org-export-latex.el (org-export-latex-preprocess): Renamed
from `org-export-latex-cleaned-string'.
2008-04-27 Bastien Guerry <bzg@altern.org>
* org/org-publish.el (org-publish-get-base-files-1): New function.
(org-publish-get-base-files): Use it.
(org-publish-temp-files): New variable.
Don't require 'dired-aux anymore.
(org-publish-initial-buffer): New variable.
(org-publish-org-to, org-publish): Use it.
(org-publish-get-base-files-1): Bug fix: get
the proper list of files when recursing thru a directory.
(org-publish-get-base-files): Use the :exclude property to skip
both files and directories.
author | Carsten Dominik <dominik@science.uva.nl> |
---|---|
date | Sun, 27 Apr 2008 18:33:39 +0000 |
parents | 096ad76b9ccf |
children | 8971ddf55736 |
line wrap: on
line source
/* Basic character support. Copyright (C) 1995, 1997, 1998, 2001 Electrotechnical Laboratory, JAPAN. Licensed to the Free Software Foundation. Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc. Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008 National Institute of Advanced Industrial Science and Technology (AIST) Registration Number H13PRO009 This file is part of GNU Emacs. GNU Emacs 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, or (at your option) any later version. GNU Emacs 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 GNU Emacs; see the file COPYING. If not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */ /* At first, see the document in `character.h' to understand the code in this file. */ #ifdef emacs #include <config.h> #endif #include <stdio.h> #ifdef emacs #include <sys/types.h> #include "lisp.h" #include "character.h" #include "buffer.h" #include "charset.h" #include "composite.h" #include "disptab.h" #else /* not emacs */ #include "mulelib.h" #endif /* emacs */ Lisp_Object Qcharacterp; /* Vector of translation table ever defined. ID of a translation table is used to index this vector. */ Lisp_Object Vtranslation_table_vector; /* A char-table for characters which may invoke auto-filling. */ Lisp_Object Vauto_fill_chars; Lisp_Object Qauto_fill_chars; /* Char-table of information about which character to unify to which Unicode character. */ Lisp_Object Vchar_unify_table; /* A char-table. An element is non-nil iff the corresponding character has a printable glyph. */ Lisp_Object Vprintable_chars; /* A char-table. An elemnent is a column-width of the corresponding character. */ Lisp_Object Vchar_width_table; /* A char-table. An element is a symbol indicating the direction property of corresponding character. */ Lisp_Object Vchar_direction_table; /* Variable used locally in the macro FETCH_MULTIBYTE_CHAR. */ unsigned char *_fetch_multibyte_char_p; /* Char table of scripts. */ Lisp_Object Vchar_script_table; /* Alist of scripts vs representative characters. */ Lisp_Object Vscript_representative_chars; static Lisp_Object Qchar_script_table; /* Mapping table from unibyte chars to multibyte chars. */ int unibyte_to_multibyte_table[256]; /* Nth element is 1 iff unibyte char N can be mapped to a multibyte char. */ char unibyte_has_multibyte_table[256]; /* If character code C has modifier masks, reflect them to the character code if possible. Return the resulting code. */ int char_resolve_modifier_mask (c) int c; { /* A non-ASCII character can't reflect modifier bits to the code. */ if (! ASCII_CHAR_P ((c & ~CHAR_MODIFIER_MASK))) return c; /* For Meta, Shift, and Control modifiers, we need special care. */ if (c & CHAR_SHIFT) { /* Shift modifier is valid only with [A-Za-z]. */ if ((c & 0377) >= 'A' && (c & 0377) <= 'Z') c &= ~CHAR_SHIFT; else if ((c & 0377) >= 'a' && (c & 0377) <= 'z') c = (c & ~CHAR_SHIFT) - ('a' - 'A'); /* Shift modifier for control characters and SPC is ignored. */ else if ((c & ~CHAR_MODIFIER_MASK) <= 0x20) c &= ~CHAR_SHIFT; } if (c & CHAR_CTL) { /* Simulate the code in lread.c. */ /* Allow `\C- ' and `\C-?'. */ if ((c & 0377) == ' ') c &= ~0177 & ~ CHAR_CTL; else if ((c & 0377) == '?') c = 0177 | (c & ~0177 & ~CHAR_CTL); /* ASCII control chars are made from letters (both cases), as well as the non-letters within 0100...0137. */ else if ((c & 0137) >= 0101 && (c & 0137) <= 0132) c &= (037 | (~0177 & ~CHAR_CTL)); else if ((c & 0177) >= 0100 && (c & 0177) <= 0137) c &= (037 | (~0177 & ~CHAR_CTL)); } if (c & CHAR_META) { /* Move the meta bit to the right place for a string. */ c = (c & ~CHAR_META) | 0x80; } return c; } /* Store multibyte form of character C at P. If C has modifier bits, handle them appropriately. */ int char_string (c, p) unsigned c; unsigned char *p; { int bytes; if (c & CHAR_MODIFIER_MASK) { c = (unsigned) char_resolve_modifier_mask ((int) c); /* If C still has any modifier bits, just ignore it. */ c &= ~CHAR_MODIFIER_MASK; } MAYBE_UNIFY_CHAR (c); if (c <= MAX_3_BYTE_CHAR) { bytes = CHAR_STRING (c, p); } else if (c <= MAX_4_BYTE_CHAR) { p[0] = (0xF0 | (c >> 18)); p[1] = (0x80 | ((c >> 12) & 0x3F)); p[2] = (0x80 | ((c >> 6) & 0x3F)); p[3] = (0x80 | (c & 0x3F)); bytes = 4; } else if (c <= MAX_5_BYTE_CHAR) { p[0] = 0xF8; p[1] = (0x80 | ((c >> 18) & 0x0F)); p[2] = (0x80 | ((c >> 12) & 0x3F)); p[3] = (0x80 | ((c >> 6) & 0x3F)); p[4] = (0x80 | (c & 0x3F)); bytes = 5; } else if (c <= MAX_CHAR) { c = CHAR_TO_BYTE8 (c); bytes = BYTE8_STRING (c, p); } else error ("Invalid character: %d", c); return bytes; } /* Return a character whose multibyte form is at P. Set LEN is not NULL, it must be a pointer to integer. In that case, set *LEN to the byte length of the multibyte form. If ADVANCED is not NULL, is must be a pointer to unsigned char. In that case, set *ADVANCED to the ending address (i.e. the starting address of the next character) of the multibyte form. */ int string_char (p, advanced, len) const unsigned char *p; const unsigned char **advanced; int *len; { int c; const unsigned char *saved_p = p; if (*p < 0x80 || ! (*p & 0x20) || ! (*p & 0x10)) { c = STRING_CHAR_ADVANCE (p); } else if (! (*p & 0x08)) { c = ((((p)[0] & 0xF) << 18) | (((p)[1] & 0x3F) << 12) | (((p)[2] & 0x3F) << 6) | ((p)[3] & 0x3F)); p += 4; } else { c = ((((p)[1] & 0x3F) << 18) | (((p)[2] & 0x3F) << 12) | (((p)[3] & 0x3F) << 6) | ((p)[4] & 0x3F)); p += 5; } MAYBE_UNIFY_CHAR (c); if (len) *len = p - saved_p; if (advanced) *advanced = p; return c; } /* Translate character C by translation table TABLE. If C is negative, translate a character specified by CHARSET and CODE. If no translation is found in TABLE, return the untranslated character. If TABLE is a list, elements are char tables. In this case, translace C by all tables. */ int translate_char (table, c) Lisp_Object table; int c; { if (CHAR_TABLE_P (table)) { Lisp_Object ch; ch = CHAR_TABLE_REF (table, c); if (CHARACTERP (ch)) c = XINT (ch); } else { for (; CONSP (table); table = XCDR (table)) c = translate_char (XCAR (table), c); } return c; } /* Convert the multibyte character C to unibyte 8-bit character based on the current value of charset_unibyte. If dimension of charset_unibyte is more than one, return (C & 0xFF). The argument REV_TBL is now ignored. It will be removed in the future. */ int multibyte_char_to_unibyte (c, rev_tbl) int c; Lisp_Object rev_tbl; { struct charset *charset; unsigned c1; if (CHAR_BYTE8_P (c)) return CHAR_TO_BYTE8 (c); charset = CHARSET_FROM_ID (charset_unibyte); c1 = ENCODE_CHAR (charset, c); return ((c1 != CHARSET_INVALID_CODE (charset)) ? c1 : c & 0xFF); } /* Like multibyte_char_to_unibyte, but return -1 if C is not supported by charset_unibyte. */ int multibyte_char_to_unibyte_safe (c) int c; { struct charset *charset; unsigned c1; if (CHAR_BYTE8_P (c)) return CHAR_TO_BYTE8 (c); charset = CHARSET_FROM_ID (charset_unibyte); c1 = ENCODE_CHAR (charset, c); return ((c1 != CHARSET_INVALID_CODE (charset)) ? c1 : -1); } DEFUN ("characterp", Fcharacterp, Scharacterp, 1, 2, 0, doc: /* Return non-nil if OBJECT is a character. */) (object, ignore) Lisp_Object object, ignore; { return (CHARACTERP (object) ? Qt : Qnil); } DEFUN ("max-char", Fmax_char, Smax_char, 0, 0, 0, doc: /* Return the character of the maximum code. */) () { return make_number (MAX_CHAR); } DEFUN ("unibyte-char-to-multibyte", Funibyte_char_to_multibyte, Sunibyte_char_to_multibyte, 1, 1, 0, doc: /* Convert the byte CH to multibyte character. */) (ch) Lisp_Object ch; { int c; struct charset *charset; CHECK_CHARACTER (ch); c = XFASTINT (ch); if (c >= 0400) error ("Invalid unibyte character: %d", c); charset = CHARSET_FROM_ID (charset_unibyte); c = DECODE_CHAR (charset, c); if (c < 0) c = BYTE8_TO_CHAR (XFASTINT (ch)); return make_number (c); } DEFUN ("multibyte-char-to-unibyte", Fmultibyte_char_to_unibyte, Smultibyte_char_to_unibyte, 1, 1, 0, doc: /* Convert the multibyte character CH to a byte. If the multibyte character does not represent a byte, return -1. */) (ch) Lisp_Object ch; { int cm; CHECK_CHARACTER (ch); cm = XFASTINT (ch); if (cm < 256) /* Can't distinguish a byte read from a unibyte buffer from a latin1 char, so let's let it slide. */ return ch; else { int cu = CHAR_TO_BYTE8 (cm); return make_number (cu); } } DEFUN ("char-bytes", Fchar_bytes, Schar_bytes, 1, 1, 0, doc: /* Return 1 regardless of the argument CHAR. This is now an obsolete function. We keep it just for backward compatibility. usage: (char-bytes CHAR) */) (ch) Lisp_Object ch; { CHECK_CHARACTER (ch); return make_number (1); } DEFUN ("char-width", Fchar_width, Schar_width, 1, 1, 0, doc: /* Return width of CHAR when displayed in the current buffer. The width is measured by how many columns it occupies on the screen. Tab is taken to occupy `tab-width' columns. usage: (char-width CHAR) */) (ch) Lisp_Object ch; { Lisp_Object disp; int c, width; struct Lisp_Char_Table *dp = buffer_display_table (); CHECK_CHARACTER (ch); c = XINT (ch); /* Get the way the display table would display it. */ disp = dp ? DISP_CHAR_VECTOR (dp, c) : Qnil; if (VECTORP (disp)) width = ASIZE (disp); else width = CHAR_WIDTH (c); return make_number (width); } /* Return width of string STR of length LEN when displayed in the current buffer. The width is measured by how many columns it occupies on the screen. If PRECISION > 0, return the width of longest substring that doesn't exceed PRECISION, and set number of characters and bytes of the substring in *NCHARS and *NBYTES respectively. */ int c_string_width (str, len, precision, nchars, nbytes) const unsigned char *str; int precision, *nchars, *nbytes; { int i = 0, i_byte = 0; int width = 0; struct Lisp_Char_Table *dp = buffer_display_table (); while (i_byte < len) { int bytes, thiswidth; Lisp_Object val; int c = STRING_CHAR_AND_LENGTH (str + i_byte, len - i_byte, bytes); if (dp) { val = DISP_CHAR_VECTOR (dp, c); if (VECTORP (val)) thiswidth = XVECTOR (val)->size; else thiswidth = CHAR_WIDTH (c); } else { thiswidth = CHAR_WIDTH (c); } if (precision > 0 && (width + thiswidth > precision)) { *nchars = i; *nbytes = i_byte; return width; } i++; i_byte += bytes; width += thiswidth; } if (precision > 0) { *nchars = i; *nbytes = i_byte; } return width; } /* Return width of string STR of length LEN when displayed in the current buffer. The width is measured by how many columns it occupies on the screen. */ int strwidth (str, len) unsigned char *str; int len; { return c_string_width (str, len, -1, NULL, NULL); } /* Return width of Lisp string STRING when displayed in the current buffer. The width is measured by how many columns it occupies on the screen while paying attention to compositions. If PRECISION > 0, return the width of longest substring that doesn't exceed PRECISION, and set number of characters and bytes of the substring in *NCHARS and *NBYTES respectively. */ int lisp_string_width (string, precision, nchars, nbytes) Lisp_Object string; int precision, *nchars, *nbytes; { int len = SCHARS (string); /* This set multibyte to 0 even if STRING is multibyte when it contains only ascii and eight-bit-graphic, but that's intentional. */ int multibyte = len < SBYTES (string); unsigned char *str = SDATA (string); int i = 0, i_byte = 0; int width = 0; struct Lisp_Char_Table *dp = buffer_display_table (); while (i < len) { int chars, bytes, thiswidth; Lisp_Object val; int cmp_id; EMACS_INT ignore, end; if (find_composition (i, -1, &ignore, &end, &val, string) && ((cmp_id = get_composition_id (i, i_byte, end - i, val, string)) >= 0)) { thiswidth = composition_table[cmp_id]->width; chars = end - i; bytes = string_char_to_byte (string, end) - i_byte; } else { int c; if (multibyte) c = STRING_CHAR_AND_LENGTH (str + i_byte, len - i_byte, bytes); else c = str[i_byte], bytes = 1; chars = 1; if (dp) { val = DISP_CHAR_VECTOR (dp, c); if (VECTORP (val)) thiswidth = XVECTOR (val)->size; else thiswidth = CHAR_WIDTH (c); } else { thiswidth = CHAR_WIDTH (c); } } if (precision > 0 && (width + thiswidth > precision)) { *nchars = i; *nbytes = i_byte; return width; } i += chars; i_byte += bytes; width += thiswidth; } if (precision > 0) { *nchars = i; *nbytes = i_byte; } return width; } DEFUN ("string-width", Fstring_width, Sstring_width, 1, 1, 0, doc: /* Return width of STRING when displayed in the current buffer. Width is measured by how many columns it occupies on the screen. When calculating width of a multibyte character in STRING, only the base leading-code is considered; the validity of the following bytes is not checked. Tabs in STRING are always taken to occupy `tab-width' columns. usage: (string-width STRING) */) (str) Lisp_Object str; { Lisp_Object val; CHECK_STRING (str); XSETFASTINT (val, lisp_string_width (str, -1, NULL, NULL)); return val; } DEFUN ("char-direction", Fchar_direction, Schar_direction, 1, 1, 0, doc: /* Return the direction of CHAR. The returned value is 0 for left-to-right and 1 for right-to-left. usage: (char-direction CHAR) */) (ch) Lisp_Object ch; { int c; CHECK_CHARACTER (ch); c = XINT (ch); return CHAR_TABLE_REF (Vchar_direction_table, c); } /* Return the number of characters in the NBYTES bytes at PTR. This works by looking at the contents and checking for multibyte sequences while assuming that there's no invalid sequence. However, if the current buffer has enable-multibyte-characters = nil, we treat each byte as a character. */ EMACS_INT chars_in_text (ptr, nbytes) const unsigned char *ptr; EMACS_INT nbytes; { /* current_buffer is null at early stages of Emacs initialization. */ if (current_buffer == 0 || NILP (current_buffer->enable_multibyte_characters)) return nbytes; return multibyte_chars_in_text (ptr, nbytes); } /* Return the number of characters in the NBYTES bytes at PTR. This works by looking at the contents and checking for multibyte sequences while assuming that there's no invalid sequence. It ignores enable-multibyte-characters. */ EMACS_INT multibyte_chars_in_text (ptr, nbytes) const unsigned char *ptr; EMACS_INT nbytes; { const unsigned char *endp = ptr + nbytes; int chars = 0; while (ptr < endp) { int len = MULTIBYTE_LENGTH (ptr, endp); if (len == 0) abort (); ptr += len; chars++; } return chars; } /* Parse unibyte text at STR of LEN bytes as a multibyte text, count characters and bytes in it, and store them in *NCHARS and *NBYTES respectively. On counting bytes, pay attention to that 8-bit characters not constructing a valid multibyte sequence are represented by 2-byte in a multibyte text. */ void parse_str_as_multibyte (str, len, nchars, nbytes) const unsigned char *str; int len, *nchars, *nbytes; { const unsigned char *endp = str + len; int n, chars = 0, bytes = 0; if (len >= MAX_MULTIBYTE_LENGTH) { const unsigned char *adjusted_endp = endp - MAX_MULTIBYTE_LENGTH; while (str < adjusted_endp) { if ((n = MULTIBYTE_LENGTH_NO_CHECK (str)) > 0) str += n, bytes += n; else str++, bytes += 2; chars++; } } while (str < endp) { if ((n = MULTIBYTE_LENGTH (str, endp)) > 0) str += n, bytes += n; else str++, bytes += 2; chars++; } *nchars = chars; *nbytes = bytes; return; } /* Arrange unibyte text at STR of NBYTES bytes as a multibyte text. It actually converts only such 8-bit characters that don't contruct a multibyte sequence to multibyte forms of Latin-1 characters. If NCHARS is nonzero, set *NCHARS to the number of characters in the text. It is assured that we can use LEN bytes at STR as a work area and that is enough. Return the number of bytes of the resulting text. */ int str_as_multibyte (str, len, nbytes, nchars) unsigned char *str; int len, nbytes, *nchars; { unsigned char *p = str, *endp = str + nbytes; unsigned char *to; int chars = 0; int n; if (nbytes >= MAX_MULTIBYTE_LENGTH) { unsigned char *adjusted_endp = endp - MAX_MULTIBYTE_LENGTH; while (p < adjusted_endp && (n = MULTIBYTE_LENGTH_NO_CHECK (p)) > 0) p += n, chars++; } while ((n = MULTIBYTE_LENGTH (p, endp)) > 0) p += n, chars++; if (nchars) *nchars = chars; if (p == endp) return nbytes; to = p; nbytes = endp - p; endp = str + len; safe_bcopy ((char *) p, (char *) (endp - nbytes), nbytes); p = endp - nbytes; if (nbytes >= MAX_MULTIBYTE_LENGTH) { unsigned char *adjusted_endp = endp - MAX_MULTIBYTE_LENGTH; while (p < adjusted_endp) { if ((n = MULTIBYTE_LENGTH_NO_CHECK (p)) > 0) { while (n--) *to++ = *p++; } else { int c = *p++; c = BYTE8_TO_CHAR (c); to += CHAR_STRING (c, to); } } chars++; } while (p < endp) { if ((n = MULTIBYTE_LENGTH (p, endp)) > 0) { while (n--) *to++ = *p++; } else { int c = *p++; c = BYTE8_TO_CHAR (c); to += CHAR_STRING (c, to); } chars++; } if (nchars) *nchars = chars; return (to - str); } /* Parse unibyte string at STR of LEN bytes, and return the number of bytes it may ocupy when converted to multibyte string by `str_to_multibyte'. */ int parse_str_to_multibyte (str, len) unsigned char *str; int len; { unsigned char *endp = str + len; int bytes; for (bytes = 0; str < endp; str++) bytes += (*str < 0x80) ? 1 : 2; return bytes; } /* Convert unibyte text at STR of NBYTES bytes to a multibyte text that contains the same single-byte characters. It actually converts all 8-bit characters to multibyte forms. It is assured that we can use LEN bytes at STR as a work area and that is enough. */ int str_to_multibyte (str, len, bytes) unsigned char *str; int len, bytes; { unsigned char *p = str, *endp = str + bytes; unsigned char *to; while (p < endp && *p < 0x80) p++; if (p == endp) return bytes; to = p; bytes = endp - p; endp = str + len; safe_bcopy ((char *) p, (char *) (endp - bytes), bytes); p = endp - bytes; while (p < endp) { int c = *p++; if (c >= 0x80) c = BYTE8_TO_CHAR (c); to += CHAR_STRING (c, to); } return (to - str); } /* Arrange multibyte text at STR of LEN bytes as a unibyte text. It actually converts characters in the range 0x80..0xFF to unibyte. */ int str_as_unibyte (str, bytes) unsigned char *str; int bytes; { const unsigned char *p = str, *endp = str + bytes; unsigned char *to; int c, len; while (p < endp) { c = *p; len = BYTES_BY_CHAR_HEAD (c); if (CHAR_BYTE8_HEAD_P (c)) break; p += len; } to = str + (p - str); while (p < endp) { c = *p; len = BYTES_BY_CHAR_HEAD (c); if (CHAR_BYTE8_HEAD_P (c)) { c = STRING_CHAR_ADVANCE (p); *to++ = CHAR_TO_BYTE8 (c); } else { while (len--) *to++ = *p++; } } return (to - str); } int string_count_byte8 (string) Lisp_Object string; { int multibyte = STRING_MULTIBYTE (string); int nbytes = SBYTES (string); unsigned char *p = SDATA (string); unsigned char *pend = p + nbytes; int count = 0; int c, len; if (multibyte) while (p < pend) { c = *p; len = BYTES_BY_CHAR_HEAD (c); if (CHAR_BYTE8_HEAD_P (c)) count++; p += len; } else while (p < pend) { if (*p++ >= 0x80) count++; } return count; } Lisp_Object string_escape_byte8 (string) Lisp_Object string; { int nchars = SCHARS (string); int nbytes = SBYTES (string); int multibyte = STRING_MULTIBYTE (string); int byte8_count; const unsigned char *src, *src_end; unsigned char *dst; Lisp_Object val; int c, len; if (multibyte && nchars == nbytes) return string; byte8_count = string_count_byte8 (string); if (byte8_count == 0) return string; if (multibyte) /* Convert 2-byte sequence of byte8 chars to 4-byte octal. */ val = make_uninit_multibyte_string (nchars + byte8_count * 3, nbytes + byte8_count * 2); else /* Convert 1-byte sequence of byte8 chars to 4-byte octal. */ val = make_uninit_string (nbytes + byte8_count * 3); src = SDATA (string); src_end = src + nbytes; dst = SDATA (val); if (multibyte) while (src < src_end) { c = *src; len = BYTES_BY_CHAR_HEAD (c); if (CHAR_BYTE8_HEAD_P (c)) { c = STRING_CHAR_ADVANCE (src); c = CHAR_TO_BYTE8 (c); sprintf ((char *) dst, "\\%03o", c); dst += 4; } else while (len--) *dst++ = *src++; } else while (src < src_end) { c = *src++; if (c >= 0x80) { sprintf ((char *) dst, "\\%03o", c); dst += 4; } else *dst++ = c; } return val; } DEFUN ("string", Fstring, Sstring, 0, MANY, 0, doc: /* Concatenate all the argument characters and make the result a string. usage: (string &rest CHARACTERS) */) (n, args) int n; Lisp_Object *args; { int i; unsigned char *buf = (unsigned char *) alloca (MAX_MULTIBYTE_LENGTH * n); unsigned char *p = buf; int c; for (i = 0; i < n; i++) { CHECK_CHARACTER (args[i]); c = XINT (args[i]); p += CHAR_STRING (c, p); } return make_string_from_bytes ((char *) buf, n, p - buf); } DEFUN ("unibyte-string", Funibyte_string, Sunibyte_string, 0, MANY, 0, doc: /* Concatenate all the argument bytes and make the result a unibyte string. usage: (unibyte-string &rest BYTES) */) (n, args) int n; Lisp_Object *args; { int i; unsigned char *buf = (unsigned char *) alloca (n); unsigned char *p = buf; unsigned c; for (i = 0; i < n; i++) { CHECK_NATNUM (args[i]); c = XFASTINT (args[i]); if (c >= 256) args_out_of_range_3 (args[i], make_number (0), make_number (255)); *p++ = c; } return make_string_from_bytes ((char *) buf, n, p - buf); } DEFUN ("char-resolve-modifers", Fchar_resolve_modifiers, Schar_resolve_modifiers, 1, 1, 0, doc: /* Resolve modifiers in the character CHAR. The value is a character with modifiers resolved into the character code. Unresolved modifiers are kept in the value. usage: (char-resolve-modifers CHAR) */) (character) Lisp_Object character; { int c; CHECK_NUMBER (character); c = XINT (character); return make_number (char_resolve_modifier_mask (c)); } void init_character_once () { } #ifdef emacs void syms_of_character () { DEFSYM (Qcharacterp, "characterp"); DEFSYM (Qauto_fill_chars, "auto-fill-chars"); staticpro (&Vchar_unify_table); Vchar_unify_table = Qnil; defsubr (&Smax_char); defsubr (&Scharacterp); defsubr (&Sunibyte_char_to_multibyte); defsubr (&Smultibyte_char_to_unibyte); defsubr (&Schar_bytes); defsubr (&Schar_width); defsubr (&Sstring_width); defsubr (&Schar_direction); defsubr (&Sstring); defsubr (&Sunibyte_string); defsubr (&Schar_resolve_modifiers); DEFVAR_LISP ("translation-table-vector", &Vtranslation_table_vector, doc: /* Vector recording all translation tables ever defined. Each element is a pair (SYMBOL . TABLE) relating the table to the symbol naming it. The ID of a translation table is an index into this vector. */); Vtranslation_table_vector = Fmake_vector (make_number (16), Qnil); DEFVAR_LISP ("auto-fill-chars", &Vauto_fill_chars, doc: /* A char-table for characters which invoke auto-filling. Such characters have value t in this table. */); Vauto_fill_chars = Fmake_char_table (Qauto_fill_chars, Qnil); CHAR_TABLE_SET (Vauto_fill_chars, ' ', Qt); CHAR_TABLE_SET (Vauto_fill_chars, '\n', Qt); DEFVAR_LISP ("char-width-table", &Vchar_width_table, doc: /* A char-table for width (columns) of each character. */); Vchar_width_table = Fmake_char_table (Qnil, make_number (1)); char_table_set_range (Vchar_width_table, 0x80, 0x9F, make_number (4)); char_table_set_range (Vchar_width_table, MAX_5_BYTE_CHAR + 1, MAX_CHAR, make_number (4)); DEFVAR_LISP ("char-direction-table", &Vchar_direction_table, doc: /* A char-table for direction of each character. */); Vchar_direction_table = Fmake_char_table (Qnil, make_number (1)); DEFVAR_LISP ("printable-chars", &Vprintable_chars, doc: /* A char-table for each printable character. */); Vprintable_chars = Fmake_char_table (Qnil, Qnil); Fset_char_table_range (Vprintable_chars, Fcons (make_number (32), make_number (126)), Qt); Fset_char_table_range (Vprintable_chars, Fcons (make_number (160), make_number (MAX_5_BYTE_CHAR)), Qt); DEFVAR_LISP ("char-script-table", &Vchar_script_table, doc: /* Char table of script symbols. It has one extra slot whose value is a list of script symbols. */); /* Intern this now in case it isn't already done. Setting this variable twice is harmless. But don't staticpro it here--that is done in alloc.c. */ Qchar_table_extra_slots = intern ("char-table-extra-slots"); DEFSYM (Qchar_script_table, "char-script-table"); Fput (Qchar_script_table, Qchar_table_extra_slots, make_number (1)); Vchar_script_table = Fmake_char_table (Qchar_script_table, Qnil); DEFVAR_LISP ("script-representative-chars", &Vscript_representative_chars, doc: /* Alist of scripts vs the representative characters. */); Vscript_representative_chars = Qnil; } #endif /* emacs */ /* arch-tag: b6665960-3c3d-4184-85cd-af4318197999 (do not change this comment) */