/[emacs]/emacs/src/fns.c
ViewVC logotype

Diff of /emacs/src/fns.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1.298 by gerd, Wed Oct 31 10:57:18 2001 UTC revision 1.299 by pj, Fri Nov 2 20:27:07 2001 UTC
# Line 207  If STRING is a multibyte string, this is Line 207  If STRING is a multibyte string, this is
207       (string)       (string)
208       Lisp_Object string;       Lisp_Object string;
209  {  {
210    CHECK_STRING (string, 1);    CHECK_STRING (string);
211    return make_number (STRING_BYTES (XSTRING (string)));    return make_number (STRING_BYTES (XSTRING (string)));
212  }  }
213    
# Line 222  Symbols are also allowed; their print na Line 222  Symbols are also allowed; their print na
222      XSETSTRING (s1, XSYMBOL (s1)->name);      XSETSTRING (s1, XSYMBOL (s1)->name);
223    if (SYMBOLP (s2))    if (SYMBOLP (s2))
224      XSETSTRING (s2, XSYMBOL (s2)->name);      XSETSTRING (s2, XSYMBOL (s2)->name);
225    CHECK_STRING (s1, 0);    CHECK_STRING (s1);
226    CHECK_STRING (s2, 1);    CHECK_STRING (s2);
227    
228    if (XSTRING (s1)->size != XSTRING (s2)->size    if (XSTRING (s1)->size != XSTRING (s2)->size
229        || STRING_BYTES (XSTRING (s1)) != STRING_BYTES (XSTRING (s2))        || STRING_BYTES (XSTRING (s1)) != STRING_BYTES (XSTRING (s2))
# Line 253  If string STR1 is greater, the value is Line 253  If string STR1 is greater, the value is
253    register int end1_char, end2_char;    register int end1_char, end2_char;
254    register int i1, i1_byte, i2, i2_byte;    register int i1, i1_byte, i2, i2_byte;
255    
256    CHECK_STRING (str1, 0);    CHECK_STRING (str1);
257    CHECK_STRING (str2, 1);    CHECK_STRING (str2);
258    if (NILP (start1))    if (NILP (start1))
259      start1 = make_number (0);      start1 = make_number (0);
260    if (NILP (start2))    if (NILP (start2))
261      start2 = make_number (0);      start2 = make_number (0);
262    CHECK_NATNUM (start1, 2);    CHECK_NATNUM (start1);
263    CHECK_NATNUM (start2, 3);    CHECK_NATNUM (start2);
264    if (! NILP (end1))    if (! NILP (end1))
265      CHECK_NATNUM (end1, 4);      CHECK_NATNUM (end1);
266    if (! NILP (end2))    if (! NILP (end2))
267      CHECK_NATNUM (end2, 4);      CHECK_NATNUM (end2);
268    
269    i1 = XINT (start1);    i1 = XINT (start1);
270    i2 = XINT (start2);    i2 = XINT (start2);
# Line 349  Symbols are also allowed; their print na Line 349  Symbols are also allowed; their print na
349      XSETSTRING (s1, XSYMBOL (s1)->name);      XSETSTRING (s1, XSYMBOL (s1)->name);
350    if (SYMBOLP (s2))    if (SYMBOLP (s2))
351      XSETSTRING (s2, XSYMBOL (s2)->name);      XSETSTRING (s2, XSYMBOL (s2)->name);
352    CHECK_STRING (s1, 0);    CHECK_STRING (s1);
353    CHECK_STRING (s2, 1);    CHECK_STRING (s2);
354    
355    i1 = i1_byte = i2 = i2_byte = 0;    i1 = i1_byte = i2 = i2_byte = 0;
356    
# Line 791  concat (nargs, args, target_type, last_s Line 791  concat (nargs, args, target_type, last_s
791                XVECTOR (val)->contents[toindex++] = elt;                XVECTOR (val)->contents[toindex++] = elt;
792              else              else
793                {                {
794                  CHECK_NUMBER (elt, 0);                  CHECK_NUMBER (elt);
795                  if (SINGLE_BYTE_CHAR_P (XINT (elt)))                  if (SINGLE_BYTE_CHAR_P (XINT (elt)))
796                    {                    {
797                      if (some_multibyte)                      if (some_multibyte)
# Line 1061  each unibyte character to a multibyte ch Line 1061  each unibyte character to a multibyte ch
1061       (string)       (string)
1062       Lisp_Object string;       Lisp_Object string;
1063  {  {
1064    CHECK_STRING (string, 0);    CHECK_STRING (string);
1065    
1066    return string_make_multibyte (string);    return string_make_multibyte (string);
1067  }  }
# Line 1074  by using just the low 8 bits. */) Line 1074  by using just the low 8 bits. */)
1074       (string)       (string)
1075       Lisp_Object string;       Lisp_Object string;
1076  {  {
1077    CHECK_STRING (string, 0);    CHECK_STRING (string);
1078    
1079    return string_make_unibyte (string);    return string_make_unibyte (string);
1080  }  }
# Line 1090  corresponding single byte.  */) Line 1090  corresponding single byte.  */)
1090       (string)       (string)
1091       Lisp_Object string;       Lisp_Object string;
1092  {  {
1093    CHECK_STRING (string, 0);    CHECK_STRING (string);
1094    
1095    if (STRING_MULTIBYTE (string))    if (STRING_MULTIBYTE (string))
1096      {      {
# Line 1116  multibyte character of charset `eight-bi Line 1116  multibyte character of charset `eight-bi
1116       (string)       (string)
1117       Lisp_Object string;       Lisp_Object string;
1118  {  {
1119    CHECK_STRING (string, 0);    CHECK_STRING (string);
1120    
1121    if (! STRING_MULTIBYTE (string))    if (! STRING_MULTIBYTE (string))
1122      {      {
# Line 1150  Elements of ALIST that are not conses ar Line 1150  Elements of ALIST that are not conses ar
1150  {  {
1151    register Lisp_Object tem;    register Lisp_Object tem;
1152    
1153    CHECK_LIST (alist, 0);    CHECK_LIST (alist);
1154    if (NILP (alist))    if (NILP (alist))
1155      return alist;      return alist;
1156    alist = concat (1, &alist, Lisp_Cons, 0);    alist = concat (1, &alist, Lisp_Cons, 0);
# Line 1185  This function allows vectors as well as Line 1185  This function allows vectors as well as
1185    if (! (STRINGP (string) || VECTORP (string)))    if (! (STRINGP (string) || VECTORP (string)))
1186      wrong_type_argument (Qarrayp, string);      wrong_type_argument (Qarrayp, string);
1187    
1188    CHECK_NUMBER (from, 1);    CHECK_NUMBER (from);
1189    
1190    if (STRINGP (string))    if (STRINGP (string))
1191      {      {
# Line 1202  This function allows vectors as well as Line 1202  This function allows vectors as well as
1202      }      }
1203    else    else
1204      {      {
1205        CHECK_NUMBER (to, 2);        CHECK_NUMBER (to);
1206    
1207        to_char = XINT (to);        to_char = XINT (to);
1208        if (to_char < 0)        if (to_char < 0)
# Line 1285  DEFUN ("nthcdr", Fnthcdr, Snthcdr, 2, 2, Line 1285  DEFUN ("nthcdr", Fnthcdr, Snthcdr, 2, 2,
1285       register Lisp_Object list;       register Lisp_Object list;
1286  {  {
1287    register int i, num;    register int i, num;
1288    CHECK_NUMBER (n, 0);    CHECK_NUMBER (n);
1289    num = XINT (n);    num = XINT (n);
1290    for (i = 0; i < num && !NILP (list); i++)    for (i = 0; i < num && !NILP (list); i++)
1291      {      {
# Line 1311  DEFUN ("elt", Felt, Selt, 2, 2, 0, Line 1311  DEFUN ("elt", Felt, Selt, 2, 2, 0,
1311       (sequence, n)       (sequence, n)
1312       register Lisp_Object sequence, n;       register Lisp_Object sequence, n;
1313  {  {
1314    CHECK_NUMBER (n, 0);    CHECK_NUMBER (n);
1315    while (1)    while (1)
1316      {      {
1317        if (CONSP (sequence) || NILP (sequence))        if (CONSP (sequence) || NILP (sequence))
# Line 1891  This is the last value stored with `(put Line 1891  This is the last value stored with `(put
1891       (symbol, propname)       (symbol, propname)
1892       Lisp_Object symbol, propname;       Lisp_Object symbol, propname;
1893  {  {
1894    CHECK_SYMBOL (symbol, 0);    CHECK_SYMBOL (symbol);
1895    return Fplist_get (XSYMBOL (symbol)->plist, propname);    return Fplist_get (XSYMBOL (symbol)->plist, propname);
1896  }  }
1897    
# Line 1937  It can be retrieved with `(get SYMBOL PR Line 1937  It can be retrieved with `(get SYMBOL PR
1937       (symbol, propname, value)       (symbol, propname, value)
1938       Lisp_Object symbol, propname, value;       Lisp_Object symbol, propname, value;
1939  {  {
1940    CHECK_SYMBOL (symbol, 0);    CHECK_SYMBOL (symbol);
1941    XSYMBOL (symbol)->plist    XSYMBOL (symbol)->plist
1942      = Fplist_put (XSYMBOL (symbol)->plist, propname, value);      = Fplist_put (XSYMBOL (symbol)->plist, propname, value);
1943    return value;    return value;
# Line 2098  ARRAY is a vector, string, char-table, o Line 2098  ARRAY is a vector, string, char-table, o
2098    else if (STRINGP (array))    else if (STRINGP (array))
2099      {      {
2100        register unsigned char *p = XSTRING (array)->data;        register unsigned char *p = XSTRING (array)->data;
2101        CHECK_NUMBER (item, 1);        CHECK_NUMBER (item);
2102        charval = XINT (item);        charval = XINT (item);
2103        size = XSTRING (array)->size;        size = XSTRING (array)->size;
2104        if (STRING_MULTIBYTE (array))        if (STRING_MULTIBYTE (array))
# Line 2148  DEFUN ("char-table-subtype", Fchar_table Line 2148  DEFUN ("char-table-subtype", Fchar_table
2148       (char_table)       (char_table)
2149       Lisp_Object char_table;       Lisp_Object char_table;
2150  {  {
2151    CHECK_CHAR_TABLE (char_table, 0);    CHECK_CHAR_TABLE (char_table);
2152    
2153    return XCHAR_TABLE (char_table)->purpose;    return XCHAR_TABLE (char_table)->purpose;
2154  }  }
# Line 2163  then the actual applicable value is inhe Line 2163  then the actual applicable value is inhe
2163       (char_table)       (char_table)
2164       Lisp_Object char_table;       Lisp_Object char_table;
2165  {  {
2166    CHECK_CHAR_TABLE (char_table, 0);    CHECK_CHAR_TABLE (char_table);
2167    
2168    return XCHAR_TABLE (char_table)->parent;    return XCHAR_TABLE (char_table)->parent;
2169  }  }
# Line 2177  PARENT must be either nil or another cha Line 2177  PARENT must be either nil or another cha
2177  {  {
2178    Lisp_Object temp;    Lisp_Object temp;
2179    
2180    CHECK_CHAR_TABLE (char_table, 0);    CHECK_CHAR_TABLE (char_table);
2181    
2182    if (!NILP (parent))    if (!NILP (parent))
2183      {      {
2184        CHECK_CHAR_TABLE (parent, 0);        CHECK_CHAR_TABLE (parent);
2185    
2186        for (temp = parent; !NILP (temp); temp = XCHAR_TABLE (temp)->parent)        for (temp = parent; !NILP (temp); temp = XCHAR_TABLE (temp)->parent)
2187          if (EQ (temp, char_table))          if (EQ (temp, char_table))
# Line 2199  DEFUN ("char-table-extra-slot", Fchar_ta Line 2199  DEFUN ("char-table-extra-slot", Fchar_ta
2199       (char_table, n)       (char_table, n)
2200       Lisp_Object char_table, n;       Lisp_Object char_table, n;
2201  {  {
2202    CHECK_CHAR_TABLE (char_table, 1);    CHECK_CHAR_TABLE (char_table);
2203    CHECK_NUMBER (n, 2);    CHECK_NUMBER (n);
2204    if (XINT (n) < 0    if (XINT (n) < 0
2205        || XINT (n) >= CHAR_TABLE_EXTRA_SLOTS (XCHAR_TABLE (char_table)))        || XINT (n) >= CHAR_TABLE_EXTRA_SLOTS (XCHAR_TABLE (char_table)))
2206      args_out_of_range (char_table, n);      args_out_of_range (char_table, n);
# Line 2215  DEFUN ("set-char-table-extra-slot", Fset Line 2215  DEFUN ("set-char-table-extra-slot", Fset
2215       (char_table, n, value)       (char_table, n, value)
2216       Lisp_Object char_table, n, value;       Lisp_Object char_table, n, value;
2217  {  {
2218    CHECK_CHAR_TABLE (char_table, 1);    CHECK_CHAR_TABLE (char_table);
2219    CHECK_NUMBER (n, 2);    CHECK_NUMBER (n);
2220    if (XINT (n) < 0    if (XINT (n) < 0
2221        || XINT (n) >= CHAR_TABLE_EXTRA_SLOTS (XCHAR_TABLE (char_table)))        || XINT (n) >= CHAR_TABLE_EXTRA_SLOTS (XCHAR_TABLE (char_table)))
2222      args_out_of_range (char_table, n);      args_out_of_range (char_table, n);
# Line 2233  a character set name, or a character cod Line 2233  a character set name, or a character cod
2233       (char_table, range)       (char_table, range)
2234       Lisp_Object char_table, range;       Lisp_Object char_table, range;
2235  {  {
2236    CHECK_CHAR_TABLE (char_table, 0);    CHECK_CHAR_TABLE (char_table);
2237    
2238    if (EQ (range, Qnil))    if (EQ (range, Qnil))
2239      return XCHAR_TABLE (char_table)->defalt;      return XCHAR_TABLE (char_table)->defalt;
# Line 2244  a character set name, or a character cod Line 2244  a character set name, or a character cod
2244        Lisp_Object charset_info;        Lisp_Object charset_info;
2245    
2246        charset_info = Fget (range, Qcharset);        charset_info = Fget (range, Qcharset);
2247        CHECK_VECTOR (charset_info, 0);        CHECK_VECTOR (charset_info);
2248    
2249        return Faref (char_table,        return Faref (char_table,
2250                      make_number (XINT (XVECTOR (charset_info)->contents[0])                      make_number (XINT (XVECTOR (charset_info)->contents[0])
# Line 2281  a coding system, or a character code.  * Line 2281  a coding system, or a character code.  *
2281  {  {
2282    int i;    int i;
2283    
2284    CHECK_CHAR_TABLE (char_table, 0);    CHECK_CHAR_TABLE (char_table);
2285    
2286    if (EQ (range, Qt))    if (EQ (range, Qt))
2287      for (i = 0; i < CHAR_TABLE_ORDINARY_SLOTS; i++)      for (i = 0; i < CHAR_TABLE_ORDINARY_SLOTS; i++)
# Line 2293  a coding system, or a character code.  * Line 2293  a coding system, or a character code.  *
2293        Lisp_Object charset_info;        Lisp_Object charset_info;
2294    
2295        charset_info = Fget (range, Qcharset);        charset_info = Fget (range, Qcharset);
2296        CHECK_VECTOR (charset_info, 0);        CHECK_VECTOR (charset_info);
2297    
2298        return Faset (char_table,        return Faset (char_table,
2299                      make_number (XINT (XVECTOR (charset_info)->contents[0])                      make_number (XINT (XVECTOR (charset_info)->contents[0])
# Line 2335  See also the documentation of make-char. Line 2335  See also the documentation of make-char.
2335    int c, charset, code1, code2;    int c, charset, code1, code2;
2336    Lisp_Object temp;    Lisp_Object temp;
2337    
2338    CHECK_CHAR_TABLE (char_table, 0);    CHECK_CHAR_TABLE (char_table);
2339    CHECK_NUMBER (ch, 1);    CHECK_NUMBER (ch);
2340    
2341    c = XINT (ch);    c = XINT (ch);
2342    SPLIT_CHAR (c, charset, code1, code2);    SPLIT_CHAR (c, charset, code1, code2);
# Line 2424  DEFUN ("optimize-char-table", Foptimize_ Line 2424  DEFUN ("optimize-char-table", Foptimize_
2424    int dim;    int dim;
2425    int i, j;    int i, j;
2426    
2427    CHECK_CHAR_TABLE (table, 0);    CHECK_CHAR_TABLE (table);
2428    
2429    for (i = CHAR_TABLE_SINGLE_BYTE_SLOTS; i < CHAR_TABLE_ORDINARY_SLOTS; i++)    for (i = CHAR_TABLE_SINGLE_BYTE_SLOTS; i < CHAR_TABLE_ORDINARY_SLOTS; i++)
2430      {      {
# Line 2533  The key is always a possible IDX argumen Line 2533  The key is always a possible IDX argumen
2533    /* The depth of char table is at most 3. */    /* The depth of char table is at most 3. */
2534    Lisp_Object indices[3];    Lisp_Object indices[3];
2535    
2536    CHECK_CHAR_TABLE (char_table, 1);    CHECK_CHAR_TABLE (char_table);
2537    
2538    map_char_table (NULL, function, char_table, char_table, 0, indices);    map_char_table (NULL, function, char_table, char_table, 0, indices);
2539    return Qnil;    return Qnil;
# Line 2817  is nil and `use-dialog-box' is non-nil. Line 2817  is nil and `use-dialog-box' is non-nil.
2817    
2818    map = Fsymbol_value (intern ("query-replace-map"));    map = Fsymbol_value (intern ("query-replace-map"));
2819    
2820    CHECK_STRING (prompt, 0);    CHECK_STRING (prompt);
2821    xprompt = prompt;    xprompt = prompt;
2822    GCPRO2 (prompt, xprompt);    GCPRO2 (prompt, xprompt);
2823    
# Line 2947  is nil, and `use-dialog-box' is non-nil. Line 2947  is nil, and `use-dialog-box' is non-nil.
2947    Lisp_Object args[2];    Lisp_Object args[2];
2948    struct gcpro gcpro1;    struct gcpro gcpro1;
2949    
2950    CHECK_STRING (prompt, 0);    CHECK_STRING (prompt);
2951    
2952  #ifdef HAVE_MENUS  #ifdef HAVE_MENUS
2953    if ((NILP (last_nonmenu_event) || CONSP (last_nonmenu_event))    if ((NILP (last_nonmenu_event) || CONSP (last_nonmenu_event))
# Line 3043  SUBFEATURE can be used to check a specif Line 3043  SUBFEATURE can be used to check a specif
3043       Lisp_Object feature, subfeature;       Lisp_Object feature, subfeature;
3044  {  {
3045    register Lisp_Object tem;    register Lisp_Object tem;
3046    CHECK_SYMBOL (feature, 0);    CHECK_SYMBOL (feature);
3047    tem = Fmemq (feature, Vfeatures);    tem = Fmemq (feature, Vfeatures);
3048    if (!NILP (tem) && !NILP (subfeature))    if (!NILP (tem) && !NILP (subfeature))
3049      tem = Fmemq (subfeature, Fget (feature, Qsubfeatures));      tem = Fmemq (subfeature, Fget (feature, Qsubfeatures));
# Line 3058  particular subfeatures supported in this Line 3058  particular subfeatures supported in this
3058       Lisp_Object feature, subfeatures;       Lisp_Object feature, subfeatures;
3059  {  {
3060    register Lisp_Object tem;    register Lisp_Object tem;
3061    CHECK_SYMBOL (feature, 0);    CHECK_SYMBOL (feature);
3062    if (!NILP (Vautoload_queue))    if (!NILP (Vautoload_queue))
3063      Vautoload_queue = Fcons (Fcons (Vfeatures, Qnil), Vautoload_queue);      Vautoload_queue = Fcons (Fcons (Vfeatures, Qnil), Vautoload_queue);
3064    tem = Fmemq (feature, Vfeatures);    tem = Fmemq (feature, Vfeatures);
# Line 3106  The normal messages at start and end of Line 3106  The normal messages at start and end of
3106    register Lisp_Object tem;    register Lisp_Object tem;
3107    struct gcpro gcpro1, gcpro2;    struct gcpro gcpro1, gcpro2;
3108    
3109    CHECK_SYMBOL (feature, 0);    CHECK_SYMBOL (feature);
3110    
3111    tem = Fmemq (feature, Vfeatures);    tem = Fmemq (feature, Vfeatures);
3112    
# Line 3194  The value can later be retrieved with `w Line 3194  The value can later be retrieved with `w
3194       (widget, property, value)       (widget, property, value)
3195       Lisp_Object widget, property, value;       Lisp_Object widget, property, value;
3196  {  {
3197    CHECK_CONS (widget, 1);    CHECK_CONS (widget);
3198    XSETCDR (widget, Fplist_put (XCDR (widget), property, value));    XSETCDR (widget, Fplist_put (XCDR (widget), property, value));
3199    return value;    return value;
3200  }  }
# Line 3212  later with `widget-put'.  */) Line 3212  later with `widget-put'.  */)
3212      {      {
3213        if (NILP (widget))        if (NILP (widget))
3214          return Qnil;          return Qnil;
3215        CHECK_CONS (widget, 1);        CHECK_CONS (widget);
3216        tmp = Fplist_member (XCDR (widget), property);        tmp = Fplist_member (XCDR (widget), property);
3217        if (CONSP (tmp))        if (CONSP (tmp))
3218          {          {
# Line 3410  into shorter lines.  */) Line 3410  into shorter lines.  */)
3410    char *encoded;    char *encoded;
3411    Lisp_Object encoded_string;    Lisp_Object encoded_string;
3412    
3413    CHECK_STRING (string, 1);    CHECK_STRING (string);
3414    
3415    /* We need to allocate enough room for encoding the text.    /* We need to allocate enough room for encoding the text.
3416       We need 33 1/3% more space, plus a newline every 76       We need 33 1/3% more space, plus a newline every 76
# Line 3616  DEFUN ("base64-decode-string", Fbase64_d Line 3616  DEFUN ("base64-decode-string", Fbase64_d
3616    int length, decoded_length;    int length, decoded_length;
3617    Lisp_Object decoded_string;    Lisp_Object decoded_string;
3618    
3619    CHECK_STRING (string, 1);    CHECK_STRING (string);
3620    
3621    length = STRING_BYTES (XSTRING (string));    length = STRING_BYTES (XSTRING (string));
3622    /* We need to allocate enough room for decoding the text. */    /* We need to allocate enough room for decoding the text. */
# Line 3825  static struct Lisp_Hash_Table * Line 3825  static struct Lisp_Hash_Table *
3825  check_hash_table (obj)  check_hash_table (obj)
3826       Lisp_Object obj;       Lisp_Object obj;
3827  {  {
3828    CHECK_HASH_TABLE (obj, 0);    CHECK_HASH_TABLE (obj);
3829    return XHASH_TABLE (obj);    return XHASH_TABLE (obj);
3830  }  }
3831    
# Line 5109  guesswork fails.  Normally, an error is Line 5109  guesswork fails.  Normally, an error is
5109    
5110        if (!NILP (start))        if (!NILP (start))
5111          {          {
5112            CHECK_NUMBER (start, 1);            CHECK_NUMBER (start);
5113    
5114            start_char = XINT (start);            start_char = XINT (start);
5115    
# Line 5126  guesswork fails.  Normally, an error is Line 5126  guesswork fails.  Normally, an error is
5126          }          }
5127        else        else
5128          {          {
5129            CHECK_NUMBER (end, 2);            CHECK_NUMBER (end);
5130                        
5131            end_char = XINT (end);            end_char = XINT (end);
5132    
# Line 5142  guesswork fails.  Normally, an error is Line 5142  guesswork fails.  Normally, an error is
5142      }      }
5143    else    else
5144      {      {
5145        CHECK_BUFFER (object, 0);        CHECK_BUFFER (object);
5146    
5147        bp = XBUFFER (object);        bp = XBUFFER (object);
5148                        
# Line 5150  guesswork fails.  Normally, an error is Line 5150  guesswork fails.  Normally, an error is
5150          b = BUF_BEGV (bp);          b = BUF_BEGV (bp);
5151        else        else
5152          {          {
5153            CHECK_NUMBER_COERCE_MARKER (start, 0);            CHECK_NUMBER_COERCE_MARKER (start);
5154            b = XINT (start);            b = XINT (start);
5155          }          }
5156    
# Line 5158  guesswork fails.  Normally, an error is Line 5158  guesswork fails.  Normally, an error is
5158          e = BUF_ZV (bp);          e = BUF_ZV (bp);
5159        else        else
5160          {          {
5161            CHECK_NUMBER_COERCE_MARKER (end, 1);            CHECK_NUMBER_COERCE_MARKER (end);
5162            e = XINT (end);            e = XINT (end);
5163          }          }
5164                

Legend:
Removed from v.1.298  
changed lines
  Added in v.1.299

savannah-hackers-public@gnu.org
ViewVC Help
Powered by ViewVC 1.1.26