Mercurial > hg > xemacs-beta
annotate src/tparam.c @ 5602:c9e5612f5424
Support the MP library on recent FreeBSD, have it pass relevant tests.
src/ChangeLog addition:
2011-11-26 Aidan Kehoe <kehoea@parhasard.net>
* number-mp.c (bignum_to_string):
Don't overwrite the accumulator we've just set up for this
function.
* number-mp.c (BIGNUM_TO_TYPE):
mp_itom() doesn't necessarily do what this code used to think with
negative numbers, it can treat them as unsigned ints. Subtract
numbers from bignum_zero instead of multiplying them by -1 to
convert them to their negative equivalents.
* number-mp.c (bignum_to_int):
* number-mp.c (bignum_to_uint):
* number-mp.c (bignum_to_long):
* number-mp.c (bignum_to_ulong):
* number-mp.c (bignum_to_double):
Use the changed BIGNUM_TO_TYPE() in these functions.
* number-mp.c (bignum_ceil):
* number-mp.c (bignum_floor):
In these functions, be more careful about rounding to positive and
negative infinity, respectively. Don't use the sign of QUOTIENT
when working out out whether to add or subtract one, rather use
the sign QUOTIENT would have if arbitrary-precision division were
done.
* number-mp.h:
* number-mp.h (MP_GCD):
Wrap #include <mp.h> in BEGIN_C_DECLS/END_C_DECLS.
* number.c (Fbigfloat_get_precision):
* number.c (Fbigfloat_set_precision):
Don't attempt to call XBIGFLOAT_GET_PREC if this build doesn't
support big floats.
| author | Aidan Kehoe <kehoea@parhasard.net> |
|---|---|
| date | Sat, 26 Nov 2011 17:59:14 +0000 |
| parents | 308d34e9f07d |
| children |
| rev | line source |
|---|---|
| 0 | 1 /* Merge parameters into a termcap entry string. |
| 2 Copyright (C) 1985, 1987, 1992, 1993, 1994 Free Software Foundation, Inc. | |
| 3 | |
| 4 This file is part of XEmacs. | |
| 5 | |
|
5402
308d34e9f07d
Changed bulk of GPLv2 or later files identified by script
Mats Lidell <matsl@xemacs.org>
parents:
3025
diff
changeset
|
6 XEmacs is free software: you can redistribute it and/or modify it |
| 0 | 7 under the terms of the GNU General Public License as published by the |
|
5402
308d34e9f07d
Changed bulk of GPLv2 or later files identified by script
Mats Lidell <matsl@xemacs.org>
parents:
3025
diff
changeset
|
8 Free Software Foundation, either version 3 of the License, or (at your |
|
308d34e9f07d
Changed bulk of GPLv2 or later files identified by script
Mats Lidell <matsl@xemacs.org>
parents:
3025
diff
changeset
|
9 option) any later version. |
| 0 | 10 |
| 11 XEmacs is distributed in the hope that it will be useful, but WITHOUT | |
| 12 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 14 for more details. | |
| 15 | |
| 16 You should have received a copy of the GNU General Public License | |
|
5402
308d34e9f07d
Changed bulk of GPLv2 or later files identified by script
Mats Lidell <matsl@xemacs.org>
parents:
3025
diff
changeset
|
17 along with XEmacs. If not, see <http://www.gnu.org/licenses/>. */ |
| 0 | 18 |
| 19 /* Synched up with: Not synched with FSF. */ | |
| 20 | |
| 21 /* config.h may rename various library functions such as malloc. */ | |
| 22 #include <config.h> | |
| 647 | 23 #include "lisp.h" |
| 0 | 24 |
| 551 | 25 #undef realloc |
| 26 #undef malloc | |
| 0 | 27 #define realloc xrealloc |
| 28 #define malloc xmalloc | |
| 29 | |
| 30 /* Assuming STRING is the value of a termcap string entry | |
| 31 containing `%' constructs to expand parameters, | |
| 32 merge in parameter values and store result in block OUTSTRING points to. | |
| 33 LEN is the length of OUTSTRING. If more space is needed, | |
| 34 a block is allocated with `malloc'. | |
| 35 | |
| 36 The value returned is the address of the resulting string. | |
| 37 This may be OUTSTRING or may be the address of a block got with `malloc'. | |
| 38 In the latter case, the caller must free the block. | |
| 39 | |
| 40 The fourth and following args to tparam serve as the parameter values. */ | |
| 41 | |
| 398 | 42 static char *tparam1 (const char *string, char *outstring, int len, |
| 43 const char *up, const char *left, | |
| 0 | 44 int *argp); |
| 45 | |
| 46 /* XEmacs: renamed this function because just tparam() conflicts with | |
| 47 ncurses */ | |
| 398 | 48 char *emacs_tparam (const char *string, char *outstring, int len, int arg0, |
| 0 | 49 int arg1, int arg2, int arg3); |
| 50 char * | |
| 398 | 51 emacs_tparam (const char *string, char *outstring, int len, int arg0, |
| 0 | 52 int arg1, int arg2, int arg3) |
| 53 { | |
| 54 int arg[4]; | |
| 55 arg[0] = arg0; | |
| 56 arg[1] = arg1; | |
| 57 arg[2] = arg2; | |
| 58 arg[3] = arg3; | |
| 59 return tparam1 (string, outstring, len, 0, 0, arg); | |
| 60 } | |
| 61 | |
| 398 | 62 const char *BC; |
| 63 const char *UP; | |
| 0 | 64 |
| 65 static char tgoto_buf[50]; | |
| 66 | |
| 398 | 67 char *tgoto (const char *cm, int hpos, int vpos); |
| 0 | 68 char * |
| 398 | 69 tgoto (const char *cm, int hpos, int vpos) |
| 0 | 70 { |
| 71 int args[2]; | |
| 72 if (!cm) | |
| 73 return 0; | |
| 74 args[0] = vpos; | |
| 75 args[1] = hpos; | |
| 76 return tparam1 (cm, tgoto_buf, 50, UP, BC, args); | |
| 77 } | |
| 78 | |
| 79 static char * | |
| 398 | 80 tparam1 (const char *string, char *outstring, int len, const char *up, |
| 81 const char *left, int *argp) | |
| 0 | 82 { |
| 83 int c; | |
| 398 | 84 const char *p = string; |
| 0 | 85 char *op = outstring; |
| 86 char *outend; | |
| 87 int outlen = 0; | |
| 88 | |
| 89 int tem; | |
| 90 int *old_argp = argp; | |
| 91 int doleft = 0; | |
| 92 int doup = 0; | |
| 93 | |
| 94 outend = outstring + len; | |
| 95 | |
| 96 while (1) | |
| 97 { | |
| 98 /* If the buffer might be too short, make it bigger. */ | |
| 99 if (op + 5 >= outend) | |
| 100 { | |
| 3025 | 101 char *new_; |
| 0 | 102 if (outlen == 0) |
| 103 { | |
| 104 outlen = len + 40; | |
| 3025 | 105 new_ = (char *) malloc (outlen); |
| 0 | 106 outend += 40; |
| 3025 | 107 memcpy (new_, outstring, op - outstring); |
| 0 | 108 } |
| 109 else | |
| 110 { | |
| 111 outend += outlen; | |
| 112 outlen *= 2; | |
| 3025 | 113 new_ = (char *) realloc (outstring, outlen); |
| 0 | 114 } |
| 3025 | 115 op += new_ - outstring; |
| 116 outend += new_ - outstring; | |
| 117 outstring = new_; | |
| 0 | 118 } |
| 119 c = *p++; | |
| 120 if (!c) | |
| 121 break; | |
| 122 if (c == '%') | |
| 123 { | |
| 124 c = *p++; | |
| 125 tem = *argp; | |
| 126 switch (c) | |
| 127 { | |
| 128 case 'd': /* %d means output in decimal. */ | |
| 129 if (tem < 10) | |
| 130 goto onedigit; | |
| 131 if (tem < 100) | |
| 132 goto twodigit; | |
| 133 case '3': /* %3 means output in decimal, 3 digits. */ | |
| 134 if (tem > 999) | |
| 135 { | |
| 136 *op++ = tem / 1000 + '0'; | |
| 137 tem %= 1000; | |
| 138 } | |
| 139 *op++ = tem / 100 + '0'; | |
| 140 case '2': /* %2 means output in decimal, 2 digits. */ | |
| 141 twodigit: | |
| 142 tem %= 100; | |
| 143 *op++ = tem / 10 + '0'; | |
| 144 onedigit: | |
| 145 *op++ = tem % 10 + '0'; | |
| 146 argp++; | |
| 147 break; | |
| 148 | |
| 149 case 'C': | |
| 150 /* For c-100: print quotient of value by 96, if nonzero, | |
| 151 then do like %+. */ | |
| 152 if (tem >= 96) | |
| 153 { | |
| 154 *op++ = tem / 96; | |
| 155 tem %= 96; | |
| 156 } | |
| 157 case '+': /* %+x means add character code of char x. */ | |
| 158 tem += *p++; | |
| 159 case '.': /* %. means output as character. */ | |
| 160 if (left) | |
| 161 { | |
| 162 /* If want to forbid output of 0 and \n and \t, | |
| 163 and this is one of them, increment it. */ | |
| 164 while (tem == 0 || tem == '\n' || tem == '\t') | |
| 165 { | |
| 166 tem++; | |
| 167 if (argp == old_argp) | |
| 168 doup++, outend -= strlen (up); | |
| 169 else | |
| 170 doleft++, outend -= strlen (left); | |
| 171 } | |
| 172 } | |
| 173 *op++ = tem | 0200; | |
| 174 case 'f': /* %f means discard next arg. */ | |
| 175 argp++; | |
| 176 break; | |
| 177 | |
| 178 case 'b': /* %b means back up one arg (and re-use it). */ | |
| 179 argp--; | |
| 180 break; | |
| 181 | |
| 182 case 'r': /* %r means interchange following two args. */ | |
| 183 argp[0] = argp[1]; | |
| 184 argp[1] = tem; | |
| 185 old_argp++; | |
| 186 break; | |
| 187 | |
| 188 case '>': /* %>xy means if arg is > char code of x, */ | |
| 189 if (argp[0] > *p++) /* then add char code of y to the arg, */ | |
| 190 argp[0] += *p; /* and in any case don't output. */ | |
| 191 p++; /* Leave the arg to be output later. */ | |
| 192 break; | |
| 193 | |
| 194 case 'a': /* %a means arithmetic. */ | |
| 195 /* Next character says what operation. | |
| 196 Add or subtract either a constant or some other arg. */ | |
| 197 /* First following character is + to add or - to subtract | |
| 198 or = to assign. */ | |
| 199 /* Next following char is 'p' and an arg spec | |
| 200 (0100 plus position of that arg relative to this one) | |
| 201 or 'c' and a constant stored in a character. */ | |
| 202 tem = p[2] & 0177; | |
| 203 if (p[1] == 'p') | |
| 204 tem = argp[tem - 0100]; | |
| 205 if (p[0] == '-') | |
| 206 argp[0] -= tem; | |
| 207 else if (p[0] == '+') | |
| 208 argp[0] += tem; | |
| 209 else if (p[0] == '*') | |
| 210 argp[0] *= tem; | |
| 211 else if (p[0] == '/') | |
| 212 argp[0] /= tem; | |
| 213 else | |
| 214 argp[0] = tem; | |
| 215 | |
| 216 p += 3; | |
| 217 break; | |
| 218 | |
| 219 case 'i': /* %i means add one to arg, */ | |
| 220 argp[0] ++; /* and leave it to be output later. */ | |
| 221 argp[1] ++; /* Increment the following arg, too! */ | |
| 222 break; | |
| 223 | |
| 224 case '%': /* %% means output %; no arg. */ | |
| 225 goto ordinary; | |
| 226 | |
| 227 case 'n': /* %n means xor each of next two args with 140. */ | |
| 228 argp[0] ^= 0140; | |
| 229 argp[1] ^= 0140; | |
| 230 break; | |
| 231 | |
| 232 case 'm': /* %m means xor each of next two args with 177. */ | |
| 233 argp[0] ^= 0177; | |
| 234 argp[1] ^= 0177; | |
| 235 break; | |
| 236 | |
| 237 case 'B': /* %B means express arg as BCD char code. */ | |
| 238 argp[0] += 6 * (tem / 10); | |
| 239 break; | |
| 240 | |
| 241 case 'D': /* %D means weird Delta Data transformation. */ | |
| 242 argp[0] -= 2 * (tem % 16); | |
| 243 break; | |
| 244 } | |
| 245 } | |
| 246 else | |
| 247 /* Ordinary character in the argument string. */ | |
| 248 ordinary: | |
| 249 *op++ = c; | |
| 250 } | |
| 251 *op = 0; | |
| 252 while (doup-- > 0) | |
| 253 strcat (op, up); | |
| 254 while (doleft-- > 0) | |
| 255 strcat (op, left); | |
| 256 return outstring; | |
| 257 } |