"Stephen J. Turnbull" wrote: you are confused. "c string" is simply one special case of an external representation. eicpy_c(ei, c_string) is exactly the same as eicpy_ext(ei, c_string, Qbinary), other than this check. This is defined only to make it easier to use literal ASCII strings, which is going to be extremely common. If the string has any non-ASCII characters in it, they need to explicitly specify the encoding -- hence the restriction. not true, the only thing i pasted in came from a .c file, wrapped at 75 chars per line. the rest was typed in. sorry, i am using netscape 4.7 and i'm not sure i have much control over this. could you please send me back one of my messages as an attachment in text/plain (i.e. not marked as a mail message, so that Netscape doesn't try to wrap it on input)? i'm really not sure what my messages look like to others because of all the futzing that Netscape does. probably i should use vm, but in a great number of ways it just totally sucks in comparison to netscape. (can't handle large folders well, is really slow in general, doesn't provide its own filtering mechanism, i don't like its ui, doesn't seem to handle multiple folders well, etc.) perhaps i'm missing something here -- i know that some of vm's annoyances can be fixed by just fiddling with some variables (how come it doesn't just work right out of the box???) and i haven't used it for awhile, so it may have totally changed and my complaints may not be valid. -- Ben In order to save my hands, I am cutting back on my mail. I also write as succinctly as possible -- please don't be offended. If you send me mail, you _will_ get a response, but please be patient, especially for XEmacs-related mail. If you need an immediate response and it is not apparent in your message, please say so. Thanks for your understanding. See also http://www.666.com/ben/typing.html.

i absolutely don't understand what you're complaining about. the point is to allow things like (Lisp Object filename from somewhere;) Eistring (wild); eicpy_str (wild, filename); eicat_c (wild, "\\*"); without making people create another Eistring just for this literal. Obviously it shouldn't be used for data that isn't 100% known to be ASCII. This will be well-documented in the API. But completely stupid people who can't read shouldn't be working on the Mule code, anyway. I'm surprised you're so worked up over a silly convenience function! "Stephen J. Turnbull" wrote: -- Ben In order to save my hands, I am cutting back on my mail. I also write as succinctly as possible -- please don't be offended. If you send me mail, you _will_ get a response, but please be patient, especially for XEmacs-related mail. If you need an immediate response and it is not apparent in your message, please say so. Thanks for your understanding. See also http://www.666.com/ben/typing.html.

"Stephen J. Turnbull" wrote: I think you're misguided as to the correct usage of Eistrings. Eistrings are supposed to hold Mule-internal data inside them. They're definitely not supposed to hold random string stuff in them. So I'm not quite sure of what you're trying to do. Could you explain it in words? Then I'll tell you how you could do it best, using Eistrings and/or other interfaces. If you want to copy or concatenate JIS format text, you need to mark it as JIS. For example, you could imagine Eistring (outline); eicpy_ext (outline, "\033$B", Qjapanese_jis_0208); eicat_ext (outline, "<+J,$G$7$g$&!#", Qjapanese_jis_0208); eicat_ext (outline, "\033(B\n", Qjapanese_jis_0208); In fact eicat_ext does not exist, so you'd have to use eicpy_ext() to create new Eistrings in those two cases, and then use eicat_ei. But the real problem here is that the data conversion that goes on inside the Eistrings is EXTREMELY SIMPLE and stateless. In fact, it just uses TO_INTERNAL_FORMAT() and TO_EXTERNAL_FORMAT() for all conversions, which assume a complete encoding block. In your example above, you'd need to concatenate the Japanese strings together separately, using some other mechanism, and then feed the whole thing to eicat_ext(), so that it would correctly encode it into Japanese. Or alternatively, you might be wanting to feed the bytes directly into the string? Then you can go ahead, but use Qbinary, e.g. Eistring (outline); eicpy_ext (outline, "\033$B", Qbinary); eicat_ext (outline, "<+J,$G$7$g$&!#", Qbinary); eicat_ext (outline, "\033(B\n", Qbinary); but from the Eistring's perspective, you don't have Japanese in here; you have gobbledygook which could be decoded into Japanese. But that's not part of the design of the Eistring -- it's supposed to entirely keep internally-formatted text in it, and provide routines to manipulate this internally-formatted text. It seems that you're trying to rather ad-hoc-ish extend the design to do something else, and then you start complaing when there are problems! IMHO, my design is extremely well thought out. Take a look at the example function I just posted to Hrvoje showing how this all should be used. -- Ben In order to save my hands, I am cutting back on my mail. I also write as succinctly as possible -- please don't be offended. If you send me mail, you _will_ get a response, but please be patient, especially for XEmacs-related mail. If you need an immediate response and it is not apparent in your message, please say so. Thanks for your understanding. See also http://www.666.com/ben/typing.html.

stephen, i need to talk to you on the phone that way i'll have a reasonable chance of answering your ?'s before my hands fall off. let me know your # and your available hours. btw i've posted my implementation so far. /* ------------------------------ */ /* (E) For working with Eistrings */ /* ------------------------------ */ /* Note: Unfortunately, we have to write most of the Eistring functions as macros, because of the use of alloca(). The principle used below to assure no conflict in local variables is to prefix all local variables with "ei" plus a number, which should be unique among macros. In practice, when finding a new number, use one greater than all existing numbers. */ typedef struct { void *data; Bytecount max_size_allocated; Bytecount bytelen; Charcount charlen; int mallocp; void *extdata; Extcount extlen; } Eistring_; Eistring_ the_eistring_zero_init; #define Eistring(name) Eistring_ name = the_eistring_zero_init /* ----- Initialization ----- */ /* Make sure we can hold BYTELEN bytes plus a zero terminator. Preserve existing data as much as possible. */ #define EI_ALLOC_(ei, charlen, bytelen) \ do { \ int ei1oldeibytelen = (ei).bytelen; \ int ei1newbytelen = bytelen; \ int ei1newcharlen = charlen; \ \ (ei).charlen = ei1newcharlen; \ (ei).bytelen = ei1newbytelen; \ \ if (ei1oldeibytelen != (ei).bytelen) \ { \ if ((ei).mallocp) \ /* xrealloc always preserves existing data as much as possible */ \ (ei).data = xrealloc ((ei).data, (ei).bytelen + 1); \ else if ((ei).bytelen + 1 > (ei).max_size_allocated) \ { \ /* We don't have realloc, so just use the existing allocation \ if it's big enough; but remember how big it really is. */ \ void *ei1oldeidata = (ei).data; \ (ei).max_size_allocated = (ei).bytelen + 1; \ (ei).data = alloca ((ei).max_size_allocated); \ memcpy ((ei).data, ei1oldeidata, ei1oldeibytelen); \ } \ ((char *) (ei).data)[(ei).bytelen] = '\0'; \ } \ } while (0) #define EI_ALLOC_AND_COPY_(ei, data, charlen, bytelen) \ do { \ EI_ALLOC_ (ei, charlen, bytelen); \ memcpy ((ei).data, data, (ei).bytelen); \ } while (0) #define eicpy_ei(ei, eicpy) \ do { \ Eistring_ *ei2 = &(eicpy); \ EI_ALLOC_AND_COPY_ (ei, ei2->data, ei2->charlen, ei2->bytelen); \ } while (0) #define eicpy_str(ei, lisp_string) \ do { \ Lisp_Object ei3 = (lisp_string); \ EI_ALLOC_AND_COPY_ (ei, XSTRING_DATA (ei3), XSTRING_CHAR_LENGTH (ei3), \ XSTRING_LENGTH (ei3)); \ } while (0) #ifdef ERROR_CHECK_BUFPOS #define EI_ASSERT_ASCII_(ptr, len) do { \ int ei5; \ \ /* we use PTR and LEN multiply; we assume the callers have macro-protected \ them. */ \ for (ei5 = 0; ei5 < len; ei5++) \ assert (ptr[ei5] >= 0x20 && ptr[ei5] < 0x7F); \ } while (0) #else #define EI_ASSERT_ASCII_(ptr, len) #endif #define eicpy_c(ei, c_string) \ do { \ char *ei4 = (char *) (c_string); \ \ EI_ASSERT_ASCII_ (ei4, strlen (ei4)); \ eicpy_ext (ei, ei4c, Qbinary); \ } while (0) #define eicpy_c_len(ei, c_string, c_len) \ do { \ char *ei6 = (char *) (c_string); \ int ei6len = (c_len); \ \ EI_ASSERT_ASCII_ (ei6, ei6len); \ eicpy_ext_len (ei, ei6, ei6len, Qbinary); \ } while (0) #define eicpy_ext_len(ei, extdata, extlen, coding_system) \ do { \ char *ei7 = (char *) (extdata); \ int ei7len = (extlen); \ \ TO_INTERNAL_FORMAT (DATA, (ei7, ei7len), \ ALLOCA, ((ei).data, (ei).bytelen), \ coding_system); \ (ei).max_size_allocated = (ei).bytelen + 1; \ (ei).charlen = bytecount_to_charcount ((ei).data, (ei).bytelen); \ } while (0) #define eicpy_ext(ei, extdata, coding_system) \ do { \ char *ei8 = (char *) (extdata); \ \ eicpy_ext_len (ei, ei8, strlen (ei8), coding_system); \ } while (0) /* eicpy_str_off (eistr, lisp_string, charpos, charlen): ... from a section of a Lisp_Object string eicpy_str_off_byte (eistr, lisp_string, bytepos, bytelen): ... from a section of a Lisp_Object string, with offset and length specified in bytes rather than chars eicpy_buf (eistr, lisp_buf, charpos, charlen): ... from a Lisp_Object buffer eicpy_buf_byte (eistr, lisp_buf, bytepos, bytelen): ... from a Lisp_Object buffer, with offset and length specified in bytes rather than chars eicpy_raw (eistr, intdata, intlen, intfmt): ... from raw internal-format data in the specified format eicpy_lstream (eistr, lstream): ... from an lstream; reads data till eof. Data must be in default internal format; otherwise, interpose a decoding lstream. */ /* ----- Getting the data out of the Eistring ----- */ #define eirawdata(ei) ((ei).data) /* eimake_string (eistr): eimake_string_sect (eistr, charpos, charlen): eimake_string_sect_byte (eistr, bytepos, bytelen): eicpyout_raw_alloca (eistr, intfmt, intlen_out): eicpyout_raw_malloc (eistr, intfmt, intlen_out): eicpyout_c_alloca (eistr): eicpyout_c_malloc (eistr): eicpyout_c_len_alloca (eistr, len_out): eicpyout_c_len_malloc (eistr, len_out): */ /* ----- Moving to the heap ----- */ /* eito_malloc (eistr): eifree (eistr): eito_alloca (eistr): */ /* ----- Retrieving the length ----- */ #define eilen(ei) ((ei).charlen) #define eilen_byte(ei) ((ei).bytelen) /* ----- Working with positions ----- */ #define eicharpos_to_bytepos(ei, charpos) \ charcount_to_bytecount ((ei).data, charpos) #define eibytepos_to_charpos(ei, bytepos) \ bytecount_to_charcount ((ei).data, bytepos) /* ----- Getting the character at a position ----- */ #define eiref(ei, charpos) charptr_emchar_n ((ei).data, charpos) #define eiref_byte(ei, bytepos) \ charptr_emchar ((char *) ((ei).data) + (bytepos)) /* ----- Concatenation ----- */ #define eicat_ei(ei, ei2) \ do { \ Eistring__ *ei9 = &(ei2); \ int ei9oldeibytelen = (ei).bytelen; \ EI_ALLOC_ (ei, (ei).charlen + ei9->charlen, \ (ei).bytelen + ei9->bytelen); \ memcpy ((char *) (ei).data + ei9oldeibytelen, ei9->data, \ ei9->bytelen); \ } while (0) #define eicat_c(ei, c_string) \ do { \ Eistring (ei10); \ \ eicpy_c (ei10, c_string); \ eicat_ei (ei, ei10); \ } while (0) /* ----- Replacement ----- */ /* eisub_* (eistr, charoff, charlen, ...): eisub_*_byte (eistr, byteoff, bytelen, ...): Replace a section of the Eistring. eisub_ei (eistr, charoff, charlen, eistr2): eisub_ei_byte (eistr, byteoff, bytelen, eistr2): eisub_c (eistr, charoff, charlen, c_string): eisub_c_byte (eistr, byteoff, bytelen, c_string): */ /* ----- Converting to an external format ----- */ #define eito_external(ei, coding_system) \ do { \ TO_EXTERNAL_FORMAT (DATA, ((ei).data, (ei).bytelen), \ ALLOCA, ((ei).extdata, (ei).extlen), \ coding_system); \ } while (0) #define eiextdata(ei) ((ei).extdata) #define eiextlen(ei) ((ei).extlen) /* ----- Searching in the Eistring for a character ----- */ /* eichr (eistr, chr): eichr_byte (eistr, chr): eichr_off (eistr, chr, charpos): eichr_off_byte (eistr, chr, bytepos): eirchr (eistr, chr): eirchr_byte (eistr, chr): eirchr_off (eistr, chr, charpos): eirchr_off_byte (eistr, chr, bytepos): */ /* ----- Searching in the Eistring for a string ----- */ /* eistr_ei (eistr, eistr2): eistr_ei_byte (eistr, eistr2): eistr_ei_off (eistr, eistr2, charpos): eistr_ei_off_byte (eistr, eistr2, bytepos): eirstr_ei (eistr, eistr2): eirstr_ei_byte (eistr, eistr2): eirstr_ei_off (eistr, eistr2, charpos): eirstr_ei_off_byte (eistr, eistr2, bytepos): eistr_c (eistr, c_string): eistr_c_byte (eistr, c_string): eistr_c_off (eistr, c_string, charpos): eistr_c_off_byte (eistr, c_string, bytepos): eirstr_c (eistr, c_string): eirstr_c_byte (eistr, c_string): eirstr_c_off (eistr, c_string, charpos): eirstr_c_off_byte (eistr, c_string, bytepos): */ /* ----- Comparison ----- */ /* eicmp_* (eistr, ...): eicmp_off_* (eistr, charoff, charlen, ...): eicmp_off_*_byte (eistr, byteoff, bytelen, ...): eicasecmp_* (eistr, ...): eicasecmp_off_* (eistr, charoff, charlen, ...): eicasecmp_off_*_byte (eistr, byteoff, bytelen, ...): Compare the Eistring with the other data. Return value same as from strcmp. eicmp_ei (eistr, eistr2): eicmp_off_ei (eistr, charoff, charlen, eistr2): eicmp_off_ei_byte (eistr, byteoff, bytelen, eistr2): eicasecmp_ei (eistr, eistr2): eicasecmp_off_ei (eistr, charoff, charlen, eistr2): eicasecmp_off_ei_byte (eistr, byteoff, bytelen, eistr2): eicmp_c (eistr, c_string): eicmp_off_c (eistr, charoff, charlen, c_string): eicmp_off_c_byte (eistr, byteoff, bytelen, c_string): eicasecmp_c (eistr, c_string): eicasecmp_off_c (eistr, charoff, charlen, c_string): eicasecmp_off_c_byte (eistr, byteoff, bytelen, c_string): */ /* ----- Case-changing the Eistring ----- */ int eistr_casefiddle_1 (Bufbyte *olddata, Bytecount len, Bufbyte *newdata, int downp); #define EI_CASECHANGE_(ei, downp) \ do { \ int ei11new_allocmax = (ei).charlen * MAX_EMCHAR_LEN + 1; \ Bufbyte *ei11storage = alloca_array (Bufbyte, ei11new_allocmax); \ int ei11newlen = eistr_casefiddle_1 ((ei).data, (ei).bytelen, \ ei11storage, downp); \ \ if (ei11newlen) \ { \ (ei).max_size_allocated = ei11new_allocmax; \ (ei).data = ei11storage; \ (ei).bytelen = ei11newlen; \ /* charlen is the same. */ \ } \ } while (0) #define eilwr(ei) EI_CASECHANGE_ (ei, 1) #define eiupr(ei) EI_CASECHANGE_ (ei, 0) "Stephen J. Turnbull" wrote: -- Ben In order to save my hands, I am cutting back on my mail. I also write as succinctly as possible -- please don't be offended. If you send me mail, you _will_ get a response, but please be patient, especially for XEmacs-related mail. If you need an immediate response and it is not apparent in your message, please say so. Thanks for your understanding. See also http://www.666.com/ben/typing.html.

"Stephen J. Turnbull" wrote: yes, it tends to be in ext. contexts but doesn't have to. nothing in xemacs currently provides a good lightweight string mutator object. the alternatives are using a buffer or doing lots of concat()s and Fsubstrings and crap, and even then, many obvious string ops are missing (and should be impl. god damn it!). i still disagree because it can corrupt the innards unless you expect automatic binary conversion? Then someone who feeds in JIS-encoded data this way will not get Japanese, but raw data, and perhaps shouldve used eicpy_ext(). Yes, it's a char. ref not a byte ref, so it works in UTF8 (or in EBCDIC-UTF 8!) provided our Emchars work like ASCII/Latin1, which, bar an EBCDICkian revolt, will always be. by its nature, the default int. rep. must be able to represent all chars. that would rule out utf16 if we have more than 1,000,000 and some chars. but it doesn't rule out ucs4, or some utf16 extension that could encode gigs o' chars, etc. -- Ben In order to save my hands, I am cutting back on my mail. I also write as succinctly as possible -- please don't be offended. If you send me mail, you _will_ get a response, but please be patient, especially for XEmacs-related mail. If you need an immediate response and it is not apparent in your message, please say so. Thanks for your understanding. See also http://www.666.com/ben/typing.html.

I wrote this last night: NOTE: One possible default internal representation that was compatible with UTF16 but allowed all possible chars in UCS4 would be to take an unused range of 2048 chars (not from the private area because Microsoft actually uses up most or all of it with EUDC chars). Let's say we picked 4000 - 47FF. Then, we'd have: 0000 - FFFF Simple chars D[8-B]xx D[C-F]xx Surrogate char, represents 1M chars 4[0-7]xx D[C-F]xx D[C-F]xx Surrogate char, represents 2G chars This is exactly the same number of chars as UCS-4 handles, and it follows the same property as UTF8 and Mule-internal: 1. There are two disjoint groupings of units, one representing leading units and one representing non-leading units. 2. Given a leading unit, you immediately know how many units follow to make up a valid char, irrespective of any other context. "Stephen J. Turnbull" wrote: -- Ben In order to save my hands, I am cutting back on my mail. I also write as succinctly as possible -- please don't be offended. If you send me mail, you _will_ get a response, but please be patient, especially for XEmacs-related mail. If you need an immediate response and it is not apparent in your message, please say so. Thanks for your understanding. See also http://www.666.com/ben/typing.html.

urk! all of you guys are thinking too literally. the only intent of this proposal was to allow the *internal* use of 2^31 char codes, for whatever purpose we feel like, e.g. dynamic composition. this is *internal only*. perhaps i really should have rot13'd all the values; then it'd be clearer :) "Stephen J. Turnbull" wrote: -- Ben In order to save my hands, I am cutting back on my mail. I also write as succinctly as possible -- please don't be offended. If you send me mail, you _will_ get a response, but please be patient, especially for XEmacs-related mail. If you need an immediate response and it is not apparent in your message, please say so. Thanks for your understanding. See also http://www.666.com/ben/typing.html.

I couldn't read it easily, so I reformatted it. I'll comment in a separate mail, as soon as I find the time. OG. On Mon, Apr 17, 2000 at 11:23:02PM -0700, Ben Wing wrote: i've created a new api for simplifying mule-correct string operations. it'll take awhile to fully implement; perhaps i could get some help, e.g. hrvoje? i will be implementing piece by piece, as necessary. here's what i have so far, and i'd like comments: (E) For working with Eistrings: ------------------------------- NOTE: An Eistring is a structure that makes it easy to work with internally-formatted strings of data. It provides operations similar in feel to the standard strcpy(), strcat(), strlen(), etc., but (a) it is Mule-correct (b) it does dynamic allocation so you never have to worry about size restrictions (and all allocation is stack-local using alloca(), so there is no need to explicitly clean up) (c) it knows its own length, so it does not suffer from standard null byte brain-damage (d) it provides a much more powerful set of operations and knows about all the standard places where string data might reside: Lisp_Objects, other Eistrings, char * data with or without an explicit length, etc. (e) it provides easy operations to convert to/from externally-formatted data, and is much easier to use than the standard TO_INTERNAL_FORMAT and TO_EXTERNAL_FORMAT macros. The idea is to make it as easy to write Mule-correct string manipulation code as it is to write normal string manipulation code. We also make the API sufficiently general that it can handle multiple internal data formats (e.g. some fixed-width optimizing formats and a default variable width format) and allows for *ANY* data format we might choose in the future for the default format, including UCS2. (In other words, we can't assume that the internal format is ASCII-compatible and we can't assume it doesn't have embedded null bytes.) All of this is hidden from the user. #### It is really too bad that we don't have a real object-oriented language, or at least a language with polymorphism! Eistring (name): Declare a new Eistring. This is a standard local variable declaration and can go anywhere in the variable declaration section, but note that you *MUST* supply the parens. ----- Initialization ----- eicpy_* (eistr, ...): Initialize the Eistring from somewhere: eicpy_ei (eistr, eistr2): ... from another Eistring eicpy_str (eistr, lisp_string): ... from a Lisp_Object string eicpy_str_off (eistr, lisp_string, charpos, charlen): ... from a section of a Lisp_Object string eicpy_str_off_byte (eistr, lisp_string, bytepos, bytelen): ... from a section of a Lisp_Object string, with offset and length specified in bytes rather than chars eicpy_buf (eistr, lisp_buf, charpos, charlen): ... from a Lisp_Object buffer eicpy_buf_byte (eistr, lisp_buf, bytepos, bytelen): ... from a Lisp_Object buffer, with offset and length specified in bytes rather than chars eicpy_raw (eistr, intdata, intlen, intfmt): ... from raw internal-format data in the specified format eicpy_c (eistr, c_string): ... from an ASCII null-terminated string. Non-ASCII characters in the string are *ILLEGAL* (read abort() with error-checking defined). eicpy_c_len (eistr, c_string, len): ... from an ASCII string, with length specified. Non-ASCII characters in the string are *ILLEGAL* (read abort() with error-checking defined). eicpy_ext (eistr, extdata, coding_system): ... from external null-terminated data, with coding system specified. eicpy_ext_len (eistr, extdata, extlen, coding_system): ... from external data, with length and coding system specified. eicpy_lstream (eistr, lstream): ... from an lstream; reads data till eof. Data must be in default internal format; otherwise, interpose a decoding lstream. ----- Getting the data out of the Eistring ----- eirawdata (eistr): eimake_string (eistr): eimake_string_sect (eistr, charpos, charlen): eimake_string_sect_byte (eistr, bytepos, bytelen): eicpyout_raw_alloca (eistr, intfmt, intlen_out): eicpyout_raw_malloc (eistr, intfmt, intlen_out): eicpyout_c_alloca (eistr): eicpyout_c_malloc (eistr): eicpyout_c_len_alloca (eistr, len_out): eicpyout_c_len_malloc (eistr, len_out): ----- Moving to the heap ----- eito_malloc (eistr): eifree (eistr): eito_alloca (eistr): ----- Retrieving the length ----- eilen (eistr): eilen_byte (eistr): ----- Working with positions ----- eicharpos_to_bytepos (eistr, charpos): eibytepos_to_charpos (eistr, bytepos): ----- Getting the character at a position ----- eiref (eistr, charpos): eiref_byte (eistr, bytepos): ----- Concatenation ----- eicat_* (eistr, ...): Concatenate onto the end of the Eistring, with data coming from the same places as above. (All functions that take string sources allow only two possibilities: Another Eistring and a simple C string. In the general case, create another Eistring from the source.) eicat_ei (eistr, eistr2): eicat_c (eistr, c_string): ----- Replacement ----- eisub_* (eistr, charoff, charlen, ...): eisub_*_byte (eistr, byteoff, bytelen, ...): Replace a section of the Eistring. eisub_ei (eistr, charoff, charlen, eistr2): eisub_ei_byte (eistr, byteoff, bytelen, eistr2): eisub_c (eistr, charoff, charlen, c_string): eisub_c_byte (eistr, byteoff, bytelen, c_string): ----- Converting to an external format ----- eito_external (eistr, coding_system): eiextdata (eistr): eiextlen (eistr): ----- Searching in the Eistring for a character ----- eichr (eistr, chr): eichr_byte (eistr, chr): eichr_off (eistr, chr, charpos): eichr_off_byte (eistr, chr, bytepos): eirchr (eistr, chr): eirchr_byte (eistr, chr): eirchr_off (eistr, chr, charpos): eirchr_off_byte (eistr, chr, bytepos): ----- Searching in the Eistring for a string ----- eistr_ei (eistr, eistr2): eistr_ei_byte (eistr, eistr2): eistr_ei_off (eistr, eistr2, charpos): eistr_ei_off_byte (eistr, eistr2, bytepos): eirstr_ei (eistr, eistr2): eirstr_ei_byte (eistr, eistr2): eirstr_ei_off (eistr, eistr2, charpos): eirstr_ei_off_byte (eistr, eistr2, bytepos): eistr_c (eistr, c_string): eistr_c_byte (eistr, c_string): eistr_c_off (eistr, c_string, charpos): eistr_c_off_byte (eistr, c_string, bytepos): eirstr_c (eistr, c_string): eirstr_c_byte (eistr, c_string): eirstr_c_off (eistr, c_string, charpos): eirstr_c_off_byte (eistr, c_string, bytepos): ----- Comparison ----- eicmp_* (eistr, ...): eicmp_off_* (eistr, charoff, charlen, ...): eicmp_off_*_byte (eistr, byteoff, bytelen, ...): eicasecmp_* (eistr, ...): eicasecmp_off_* (eistr, charoff, charlen, ...): eicasecmp_off_*_byte (eistr, byteoff, bytelen, ...): Compare the Eistring with the other data. Return value same as from strcmp. eicmp_ei (eistr, eistr2): eicmp_off_ei (eistr, charoff, charlen, eistr2): eicmp_off_ei_byte (eistr, byteoff, bytelen, eistr2): eicasecmp_ei (eistr, eistr2): eicasecmp_off_ei (eistr, charoff, charlen, eistr2): eicasecmp_off_ei_byte (eistr, byteoff, bytelen, eistr2): eicmp_c (eistr, c_string): eicmp_off_c (eistr, charoff, charlen, c_string): eicmp_off_c_byte (eistr, byteoff, bytelen, c_string): eicasecmp_c (eistr, c_string): eicasecmp_off_c (eistr, charoff, charlen, c_string): eicasecmp_off_c_byte (eistr, byteoff, bytelen, c_string): ----- Case-changing the Eistring ----- eilwr (eistr): eiupr (eistr): And the implementation: /* ------------------------------ */ /* (E) For working with Eistrings */ /* ------------------------------ */ typedef struct { void *data; Bytecount bytelen; Charcount charlen; int mallocp; void *extdata; Extcount extlen; } Eistring_; Eistring_ the_eistring_zero_init; #define Eistring(name) Eistring_ name = the_eistring_zero_init #define EI_ALLOC_(ei, charlen_, bytelen_) do { ei.charlen = charlen_; ei.bytelen = bytelen_; if (ei.mallocp) ei.data = xmalloc (ei.bytelen + 1); else ei.data = alloca (ei.bytelen + 1); } while (0) #define EI_ALLOC_AND_COPY_(ei, data_, charlen_, bytelen_) do { EI_ALLOC_ (ei, charlen_, bytelen_); memcpy (ei.data, data_, ei.bytelen + 1); } while (0) #define eicpy_ei(ei, ei2) do { Eistring__ *ei__ = &ei2; EI_ALLOC_AND_COPY_ (ei, ei__->data, ei__->charlen, ei__->bytelen); } while (0) #define eicpy_str(ei, lisp_string) do { Lisp_Object ei__ = lisp_string; EI_ALLOC_AND_COPY_ (ei, XSTRING_DATA (ei__), XSTRING_CHAR_LENGTH (ei__), XSTRING_LENGTH (ei__)); } while (0)

On Tue, Apr 18, 2000 at 10:00:37PM -0700, Ben Wing wrote: Done. OG.

On Tue, Apr 18, 2000 at 09:53:36PM -0400, Olivier Galibert wrote: Found the time, after all, even if I should be doing something else. On the whole, I like it. Some remarks, though: - static inline functions are infinitely preferable to macros - alloca() doesn't go well with string concatenation (no realloca) - alloca() bites you if you try to return one of these strings to a caller or change a string which was given to you through a function call - we'll need a kind of sprintf - dynamically allocated strings tend to add a whole lot of overhead in all mutating operations to check whether they need to be extended. But what I'm the most afraid of is that it is going to add yet another copy of data in a number of cases, which will slow down the system. In particular I dread the Lisp_String->eistring->cstring->system call path which may be seen as an easy way to code this. But like I said, on the whole, I like it. OG.

On Wed, Apr 19, 2000 at 01:32:18AM -0700, Ben Wing wrote: Fuck. I'll have a look. No, I didn't miss it. That is going to make the code as intuitive as gcpro(). And as stable. Bad karma. Yikes. What about mule? Once upon a time, I started writing a web interface to Jim Breen's edict (japanese-english dictionary). In the first tests, I was generating the page by concatenating characters to a dynamic string (which was doing exponential reallocation, starting at 4K and doubling the size each time). On the biggest result (100 entries), building the page was taking 20s. I changed the code to do the test once per entry, allocating at least 4K in advance (which was enough for any entry) and using pointers to directly write the data. New time: 0.05s. Efficiency should not be harder. OG.

Ben> completely mule-safe. i know -- i rewrote it from scratch to Ben> be this way. You'd have to give up the claim about being transparent to use of UCS-[24] as the internal representation, wouldn't you? -- University of Tsukuba Tennodai 1-1-1 Tsukuba 305-8573 JAPAN Institute of Policy and Planning Sciences Tel/fax: +81 (298) 53-5091 _________________ _________________ _________________ _________________ What are those straight lines for? "XEmacs rules."