|
7
|
1 /* vi:set ts=8 sts=4 sw=4: */
|
|
|
2 /*
|
|
|
3 * The following software is (C) 1984 Peter da Silva, the Mad Australian, in
|
|
|
4 * the public domain. It may be re-distributed for any purpose with the
|
|
|
5 * inclusion of this notice.
|
|
|
6 */
|
|
|
7
|
|
|
8 /* Modified by Bram Moolenaar for use with VIM - Vi Improved. */
|
|
|
9 /* A few bugs removed by Olaf 'Rhialto' Seibert. */
|
|
|
10
|
|
|
11 /* TERMLIB: Terminal independant database. */
|
|
|
12
|
|
|
13 #include "vim.h"
|
|
|
14 #include "termlib.pro"
|
|
|
15
|
|
|
16 #if !defined(AMIGA) && !defined(VMS) && !defined(MACOS) && !defined(RISCOS)
|
|
|
17 # include <sgtty.h>
|
|
|
18 #endif
|
|
|
19
|
|
|
20 static int getent __ARGS((char *, char *, FILE *, int));
|
|
|
21 static int nextent __ARGS((char *, FILE *, int));
|
|
|
22 static int _match __ARGS((char *, char *));
|
|
|
23 static char *_addfmt __ARGS((char *, char *, int));
|
|
|
24 static char *_find __ARGS((char *, char *));
|
|
|
25
|
|
|
26 /*
|
|
|
27 * Global variables for termlib
|
|
|
28 */
|
|
|
29
|
|
|
30 char *tent; /* Pointer to terminal entry, set by tgetent */
|
|
|
31 char PC = 0; /* Pad character, default NULL */
|
|
|
32 char *UP = 0, *BC = 0; /* Pointers to UP and BC strings from database */
|
|
|
33 short ospeed; /* Baud rate (1-16, 1=300, 16=19200), as in stty */
|
|
|
34
|
|
|
35 /*
|
|
|
36 * Module: tgetent
|
|
|
37 *
|
|
|
38 * Purpose: Get termcap entry for <term> into buffer at <tbuf>.
|
|
|
39 *
|
|
|
40 * Calling conventions: char tbuf[TBUFSZ+], term=canonical name for terminal.
|
|
|
41 *
|
|
|
42 * Returned values: 1 = success, -1 = can't open file,
|
|
|
43 * 0 = can't find terminal.
|
|
|
44 *
|
|
|
45 * Notes:
|
|
|
46 * - Should probably supply static buffer.
|
|
|
47 * - Uses environment variables "TERM" and "TERMCAP". If TERM = term (that is,
|
|
|
48 * if the argument matches the environment) then it looks at TERMCAP.
|
|
|
49 * - If TERMCAP begins with a slash, then it assumes this is the file to
|
|
|
50 * search rather than /etc/termcap.
|
|
|
51 * - If TERMCAP does not begin with a slash, and it matches TERM, then this is
|
|
|
52 * used as the entry.
|
|
|
53 * - This could be simplified considerably for non-UNIX systems.
|
|
|
54 */
|
|
|
55
|
|
|
56 #ifndef TERMCAPFILE
|
|
|
57 # ifdef AMIGA
|
|
|
58 # define TERMCAPFILE "s:termcap"
|
|
|
59 # else
|
|
|
60 # ifdef VMS
|
|
|
61 # define TERMCAPFILE "VIMRUNTIME:termcap"
|
|
|
62 # else
|
|
|
63 # define TERMCAPFILE "/etc/termcap"
|
|
|
64 # endif
|
|
|
65 # endif
|
|
|
66 #endif
|
|
|
67
|
|
|
68 int
|
|
|
69 tgetent(tbuf, term)
|
|
|
70 char *tbuf; /* Buffer to hold termcap entry, TBUFSZ bytes max */
|
|
|
71 char *term; /* Name of terminal */
|
|
|
72 {
|
|
|
73 char tcbuf[32]; /* Temp buffer to handle */
|
|
|
74 char *tcptr = tcbuf; /* extended entries */
|
|
|
75 char *tcap = TERMCAPFILE; /* Default termcap file */
|
|
|
76 char *tmp;
|
|
|
77 FILE *termcap;
|
|
|
78 int retval = 0;
|
|
|
79 int len;
|
|
|
80
|
|
|
81 if ((tmp = (char *)mch_getenv((char_u *)"TERMCAP")) != NULL)
|
|
|
82 {
|
|
|
83 if (*tmp == '/') /* TERMCAP = name of termcap file */
|
|
|
84 {
|
|
|
85 tcap = tmp ;
|
|
|
86 #if defined(AMIGA)
|
|
|
87 /* Convert /usr/share/lib/termcap to usr:share/lib/termcap */
|
|
|
88 tcap++;
|
|
|
89 tmp = strchr(tcap, '/');
|
|
|
90 if (tmp)
|
|
|
91 *tmp = ':';
|
|
|
92 #endif
|
|
|
93 }
|
|
|
94 else /* TERMCAP = termcap entry itself */
|
|
|
95 {
|
|
|
96 int tlen = strlen(term);
|
|
|
97
|
|
|
98 while (*tmp && *tmp != ':') /* Check if TERM matches */
|
|
|
99 {
|
|
|
100 char *nexttmp;
|
|
|
101
|
|
|
102 while (*tmp == '|')
|
|
|
103 tmp++;
|
|
|
104 nexttmp = _find(tmp, ":|"); /* Rhialto */
|
|
|
105 if (tmp+tlen == nexttmp && _match(tmp, term) == tlen)
|
|
|
106 {
|
|
|
107 strcpy(tbuf, tmp);
|
|
|
108 tent = tbuf;
|
|
|
109 return 1;
|
|
|
110 }
|
|
|
111 else
|
|
|
112 tmp = nexttmp;
|
|
|
113 }
|
|
|
114 }
|
|
|
115 }
|
|
|
116 if (!(termcap = mch_fopen(tcap, "r")))
|
|
|
117 {
|
|
|
118 strcpy(tbuf, tcap);
|
|
|
119 return -1;
|
|
|
120 }
|
|
|
121
|
|
|
122 len = 0;
|
|
|
123 while (getent(tbuf + len, term, termcap, TBUFSZ - len))
|
|
|
124 {
|
|
|
125 tcptr = tcbuf; /* Rhialto */
|
|
|
126 if ((term = tgetstr("tc", &tcptr))) /* extended entry */
|
|
|
127 {
|
|
|
128 rewind(termcap);
|
|
|
129 len = strlen(tbuf);
|
|
|
130 }
|
|
|
131 else
|
|
|
132 {
|
|
|
133 retval = 1;
|
|
|
134 tent = tbuf; /* reset it back to the beginning */
|
|
|
135 break;
|
|
|
136 }
|
|
|
137 }
|
|
|
138 fclose(termcap);
|
|
|
139 return retval;
|
|
|
140 }
|
|
|
141
|
|
|
142 static int
|
|
|
143 getent(tbuf, term, termcap, buflen)
|
|
|
144 char *tbuf, *term;
|
|
|
145 FILE *termcap;
|
|
|
146 int buflen;
|
|
|
147 {
|
|
|
148 char *tptr;
|
|
|
149 int tlen = strlen(term);
|
|
|
150
|
|
|
151 while (nextent(tbuf, termcap, buflen)) /* For each possible entry */
|
|
|
152 {
|
|
|
153 tptr = tbuf;
|
|
|
154 while (*tptr && *tptr != ':') /* : terminates name field */
|
|
|
155 {
|
|
|
156 char *nexttptr;
|
|
|
157
|
|
|
158 while (*tptr == '|') /* | seperates names */
|
|
|
159 tptr++;
|
|
|
160 nexttptr = _find(tptr, ":|"); /* Rhialto */
|
|
|
161 if (tptr + tlen == nexttptr &&
|
|
|
162 _match(tptr, term) == tlen) /* FOUND! */
|
|
|
163 {
|
|
|
164 tent = tbuf;
|
|
|
165 return 1;
|
|
|
166 }
|
|
|
167 else /* Look for next name */
|
|
|
168 tptr = nexttptr;
|
|
|
169 }
|
|
|
170 }
|
|
|
171 return 0;
|
|
|
172 }
|
|
|
173
|
|
|
174 static int
|
|
|
175 nextent(tbuf, termcap, buflen) /* Read 1 entry from TERMCAP file */
|
|
|
176 char *tbuf;
|
|
|
177 FILE *termcap;
|
|
|
178 int buflen;
|
|
|
179 {
|
|
|
180 char *lbuf = tbuf; /* lbuf=line buffer */
|
|
|
181 /* read lines straight into buffer */
|
|
|
182
|
|
|
183 while (lbuf < tbuf+buflen && /* There's room and */
|
|
|
184 fgets(lbuf, (int)(tbuf+buflen-lbuf), termcap)) /* another line */
|
|
|
185 {
|
|
|
186 int llen = strlen(lbuf);
|
|
|
187
|
|
|
188 if (*lbuf == '#') /* eat comments */
|
|
|
189 continue;
|
|
|
190 if (lbuf[-1] == ':' && /* and whitespace */
|
|
|
191 lbuf[0] == '\t' &&
|
|
|
192 lbuf[1] == ':')
|
|
|
193 {
|
|
|
194 strcpy(lbuf, lbuf+2);
|
|
|
195 llen -= 2;
|
|
|
196 }
|
|
|
197 if (lbuf[llen-2] == '\\') /* and continuations */
|
|
|
198 lbuf += llen-2;
|
|
|
199 else
|
|
|
200 {
|
|
|
201 lbuf[llen-1]=0; /* no continuation, return */
|
|
|
202 return 1;
|
|
|
203 }
|
|
|
204 }
|
|
|
205
|
|
|
206 return 0; /* ran into end of file */
|
|
|
207 }
|
|
|
208
|
|
|
209 /*
|
|
|
210 * Module: tgetflag
|
|
|
211 *
|
|
|
212 * Purpose: returns flag true or false as to the existence of a given entry.
|
|
|
213 * used with 'bs', 'am', etc...
|
|
|
214 *
|
|
|
215 * Calling conventions: id is the 2 character capability id.
|
|
|
216 *
|
|
|
217 * Returned values: 1 for success, 0 for failure.
|
|
|
218 */
|
|
|
219
|
|
|
220 int
|
|
|
221 tgetflag(id)
|
|
|
222 char *id;
|
|
|
223 {
|
|
|
224 char buf[256], *ptr = buf;
|
|
|
225
|
|
|
226 return tgetstr(id, &ptr) ? 1 : 0;
|
|
|
227 }
|
|
|
228
|
|
|
229 /*
|
|
|
230 * Module: tgetnum
|
|
|
231 *
|
|
|
232 * Purpose: get numeric value such as 'li' or 'co' from termcap.
|
|
|
233 *
|
|
|
234 * Calling conventions: id = 2 character id.
|
|
|
235 *
|
|
|
236 * Returned values: -1 for failure, else numerical value.
|
|
|
237 */
|
|
|
238
|
|
|
239 int
|
|
|
240 tgetnum(id)
|
|
|
241 char *id;
|
|
|
242 {
|
|
|
243 char *ptr, buf[256];
|
|
|
244 ptr = buf;
|
|
|
245
|
|
|
246 if (tgetstr(id, &ptr))
|
|
|
247 return atoi(buf);
|
|
|
248 else
|
|
|
249 return 0;
|
|
|
250 }
|
|
|
251
|
|
|
252 /*
|
|
|
253 * Module: tgetstr
|
|
|
254 *
|
|
|
255 * Purpose: get terminal capability string from database.
|
|
|
256 *
|
|
|
257 * Calling conventions: id is the two character capability id.
|
|
|
258 * (*buf) points into a hold buffer for the
|
|
|
259 * id. the capability is copied into the buffer
|
|
|
260 * and (*buf) is advanced to point to the next
|
|
|
261 * free byte in the buffer.
|
|
|
262 *
|
|
|
263 * Returned values: 0 = no such entry, otherwise returns original
|
|
|
264 * (*buf) (now a pointer to the string).
|
|
|
265 *
|
|
|
266 * Notes
|
|
|
267 * It also decodes certain escape sequences in the buffer.
|
|
|
268 * they should be obvious from the code:
|
|
|
269 * \E = escape.
|
|
|
270 * \n, \r, \t, \f, \b match the 'c' escapes.
|
|
|
271 * ^x matches control-x (^@...^_).
|
|
|
272 * \nnn matches nnn octal.
|
|
|
273 * \x, where x is anything else, matches x. I differ
|
|
|
274 * from the standard library here, in that I allow ^: to match
|
|
|
275 * :.
|
|
|
276 *
|
|
|
277 */
|
|
|
278
|
|
|
279 char *
|
|
|
280 tgetstr(id, buf)
|
|
|
281 char *id, **buf;
|
|
|
282 {
|
|
|
283 int len = strlen(id);
|
|
|
284 char *tmp=tent;
|
|
|
285 char *hold;
|
|
|
286 int i;
|
|
|
287
|
|
|
288 do {
|
|
|
289 tmp = _find(tmp, ":"); /* For each field */
|
|
|
290 while (*tmp == ':') /* skip empty fields */
|
|
|
291 tmp++;
|
|
|
292 if (!*tmp)
|
|
|
293 break;
|
|
|
294
|
|
|
295 if (_match(id, tmp) == len) {
|
|
|
296 tmp += len; /* find '=' '@' or '#' */
|
|
|
297 if (*tmp == '@') /* :xx@: entry for tc */
|
|
|
298 return 0; /* deleted entry */
|
|
|
299 hold= *buf;
|
|
|
300 while (*++tmp && *tmp != ':') { /* not at end of field */
|
|
|
301 switch(*tmp) {
|
|
|
302 case '\\': /* Expand escapes here */
|
|
|
303 switch(*++tmp) {
|
|
|
304 case 0: /* ignore backslashes */
|
|
|
305 tmp--; /* at end of entry */
|
|
|
306 break; /* shouldn't happen */
|
|
|
307 case 'e':
|
|
|
308 case 'E': /* ESC */
|
|
|
309 *(*buf)++ = ESC;
|
|
|
310 break;
|
|
|
311 case 'n': /* \n */
|
|
|
312 *(*buf)++ = '\n';
|
|
|
313 break;
|
|
|
314 case 'r': /* \r */
|
|
|
315 *(*buf)++ = '\r';
|
|
|
316 break;
|
|
|
317 case 't': /* \t */
|
|
|
318 *(*buf)++ = '\t';
|
|
|
319 break;
|
|
|
320 case 'b': /* \b */
|
|
|
321 *(*buf)++ = '\b';
|
|
|
322 break;
|
|
|
323 case 'f': /* \f */
|
|
|
324 *(*buf)++ = '\f';
|
|
|
325 break;
|
|
|
326 case '0': /* \nnn */
|
|
|
327 case '1':
|
|
|
328 case '2':
|
|
|
329 case '3':
|
|
|
330 case '4':
|
|
|
331 case '5':
|
|
|
332 case '6':
|
|
|
333 case '7':
|
|
|
334 case '8':
|
|
|
335 case '9':
|
|
|
336 **buf = 0;
|
|
|
337 /* get up to three digits */
|
|
|
338 for (i = 0; i < 3 && VIM_ISDIGIT(*tmp); ++i)
|
|
|
339 **buf = **buf * 8 + *tmp++ - '0';
|
|
|
340 (*buf)++;
|
|
|
341 tmp--;
|
|
|
342 break;
|
|
|
343 default: /* \x, for all other x */
|
|
|
344 *(*buf)++= *tmp;
|
|
|
345 }
|
|
|
346 break;
|
|
|
347 case '^': /* control characters */
|
|
|
348 ++tmp;
|
|
|
349 *(*buf)++ = Ctrl_chr(*tmp);
|
|
|
350 break;
|
|
|
351 default:
|
|
|
352 *(*buf)++ = *tmp;
|
|
|
353 }
|
|
|
354 }
|
|
|
355 *(*buf)++ = 0;
|
|
|
356 return hold;
|
|
|
357 }
|
|
|
358 } while (*tmp);
|
|
|
359
|
|
|
360 return 0;
|
|
|
361 }
|
|
|
362
|
|
|
363 /*
|
|
|
364 * Module: tgoto
|
|
|
365 *
|
|
|
366 * Purpose: decode cm cursor motion string.
|
|
|
367 *
|
|
|
368 * Calling conventions: cm is cursor motion string. line, col, are the
|
|
|
369 * desired destination.
|
|
|
370 *
|
|
|
371 * Returned values: a string pointing to the decoded string, or "OOPS" if it
|
|
|
372 * cannot be decoded.
|
|
|
373 *
|
|
|
374 * Notes
|
|
|
375 * The accepted escapes are:
|
|
|
376 * %d as in printf, 0 origin.
|
|
|
377 * %2, %3 like %02d, %03d in printf.
|
|
|
378 * %. like %c
|
|
|
379 * %+x adds <x> to value, then %.
|
|
|
380 * %>xy if value>x, adds y. No output.
|
|
|
381 * %i increments line& col, no output.
|
|
|
382 * %r reverses order of line&col. No output.
|
|
|
383 * %% prints as a single %.
|
|
|
384 * %n exclusive or row & col with 0140.
|
|
|
385 * %B BCD, no output.
|
|
|
386 * %D reverse coding (x-2*(x%16)), no output.
|
|
|
387 */
|
|
|
388
|
|
|
389 char *
|
|
|
390 tgoto(cm, col, line)
|
|
|
391 char *cm; /* cm string, from termcap */
|
|
|
392 int col, /* column, x position */
|
|
|
393 line; /* line, y position */
|
|
|
394 {
|
|
|
395 char gx, gy, /* x, y */
|
|
|
396 *ptr, /* pointer in 'cm' */
|
|
|
397 reverse = 0, /* reverse flag */
|
|
|
398 *bufp, /* pointer in returned string */
|
|
|
399 addup = 0, /* add upline */
|
|
|
400 addbak = 0, /* add backup */
|
|
|
401 c;
|
|
|
402 static char buffer[32];
|
|
|
403
|
|
|
404 if (!cm)
|
|
|
405 return "OOPS"; /* Kludge, but standard */
|
|
|
406
|
|
|
407 bufp = buffer;
|
|
|
408 ptr = cm;
|
|
|
409
|
|
|
410 while (*ptr) {
|
|
|
411 if ((c = *ptr++) != '%') { /* normal char */
|
|
|
412 *bufp++ = c;
|
|
|
413 } else { /* % escape */
|
|
|
414 switch(c = *ptr++) {
|
|
|
415 case 'd': /* decimal */
|
|
|
416 bufp = _addfmt(bufp, "%d", line);
|
|
|
417 line = col;
|
|
|
418 break;
|
|
|
419 case '2': /* 2 digit decimal */
|
|
|
420 bufp = _addfmt(bufp, "%02d", line);
|
|
|
421 line = col;
|
|
|
422 break;
|
|
|
423 case '3': /* 3 digit decimal */
|
|
|
424 bufp = _addfmt(bufp, "%03d", line);
|
|
|
425 line = col;
|
|
|
426 break;
|
|
|
427 case '>': /* %>xy: if >x, add y */
|
|
|
428 gx = *ptr++;
|
|
|
429 gy = *ptr++;
|
|
|
430 if (col>gx) col += gy;
|
|
|
431 if (line>gx) line += gy;
|
|
|
432 break;
|
|
|
433 case '+': /* %+c: add c */
|
|
|
434 line += *ptr++;
|
|
|
435 case '.': /* print x/y */
|
|
|
436 if (line == '\t' || /* these are */
|
|
|
437 line == '\n' || /* chars that */
|
|
|
438 line == '\004' || /* UNIX hates */
|
|
|
439 line == '\0') {
|
|
|
440 line++; /* so go to next pos */
|
|
|
441 if (reverse == (line == col))
|
|
|
442 addup=1; /* and mark UP */
|
|
|
443 else
|
|
|
444 addbak=1; /* or BC */
|
|
|
445 }
|
|
|
446 *bufp++=line;
|
|
|
447 line = col;
|
|
|
448 break;
|
|
|
449 case 'r': /* r: reverse */
|
|
|
450 gx = line;
|
|
|
451 line = col;
|
|
|
452 col = gx;
|
|
|
453 reverse = 1;
|
|
|
454 break;
|
|
|
455 case 'i': /* increment (1-origin screen) */
|
|
|
456 col++;
|
|
|
457 line++;
|
|
|
458 break;
|
|
|
459 case '%': /* %%=% literally */
|
|
|
460 *bufp++='%';
|
|
|
461 break;
|
|
|
462 case 'n': /* magic DM2500 code */
|
|
|
463 line ^= 0140;
|
|
|
464 col ^= 0140;
|
|
|
465 break;
|
|
|
466 case 'B': /* bcd encoding */
|
|
|
467 line = line/10<<4+line%10;
|
|
|
468 col = col/10<<4+col%10;
|
|
|
469 break;
|
|
|
470 case 'D': /* magic Delta Data code */
|
|
|
471 line = line-2*(line&15);
|
|
|
472 col = col-2*(col&15);
|
|
|
473 break;
|
|
|
474 default: /* Unknown escape */
|
|
|
475 return "OOPS";
|
|
|
476 }
|
|
|
477 }
|
|
|
478 }
|
|
|
479
|
|
|
480 if (addup) /* add upline */
|
|
|
481 if (UP) {
|
|
|
482 ptr=UP;
|
|
|
483 while (VIM_ISDIGIT(*ptr) || *ptr == '.')
|
|
|
484 ptr++;
|
|
|
485 if (*ptr == '*')
|
|
|
486 ptr++;
|
|
|
487 while (*ptr)
|
|
|
488 *bufp++ = *ptr++;
|
|
|
489 }
|
|
|
490
|
|
|
491 if (addbak) /* add backspace */
|
|
|
492 if (BC) {
|
|
|
493 ptr=BC;
|
|
|
494 while (VIM_ISDIGIT(*ptr) || *ptr == '.')
|
|
|
495 ptr++;
|
|
|
496 if (*ptr == '*')
|
|
|
497 ptr++;
|
|
|
498 while (*ptr)
|
|
|
499 *bufp++ = *ptr++;
|
|
|
500 }
|
|
|
501 else
|
|
|
502 *bufp++='\b';
|
|
|
503
|
|
|
504 *bufp = 0;
|
|
|
505
|
|
|
506 return(buffer);
|
|
|
507 }
|
|
|
508
|
|
|
509 /*
|
|
|
510 * Module: tputs
|
|
|
511 *
|
|
|
512 * Purpose: decode padding information
|
|
|
513 *
|
|
|
514 * Calling conventions: cp = string to be padded, affcnt = # of items affected
|
|
|
515 * (lines, characters, whatever), outc = routine to output 1 character.
|
|
|
516 *
|
|
|
517 * Returned values: none
|
|
|
518 *
|
|
|
519 * Notes
|
|
|
520 * cp has padding information ahead of it, in the form
|
|
|
521 * nnnTEXT or nnn*TEXT. nnn is the number of milliseconds to delay,
|
|
|
522 * and may be a decimal (nnn.mmm). If the asterisk is given, then
|
|
|
523 * the delay is multiplied by afcnt. The delay is produced by outputting
|
|
|
524 * a number of nulls (or other padding char) after printing the
|
|
|
525 * TEXT.
|
|
|
526 *
|
|
|
527 */
|
|
|
528
|
|
|
529 long _bauds[16]={
|
|
|
530 0, 50, 75, 110,
|
|
|
531 134, 150, 200, 300,
|
|
|
532 600, 1200, 1800, 2400,
|
|
|
533 4800, 9600, 19200, 19200 };
|
|
|
534
|
|
|
535 int
|
|
|
536 tputs(cp, affcnt, outc)
|
|
|
537 char *cp; /* string to print */
|
|
|
538 int affcnt; /* Number of lines affected */
|
|
|
539 void (*outc) __ARGS((unsigned int));/* routine to output 1 character */
|
|
|
540 {
|
|
|
541 long frac, /* 10^(#digits after decimal point) */
|
|
|
542 counter, /* digits */
|
|
|
543 atol __ARGS((const char *));
|
|
|
544
|
|
|
545 if (VIM_ISDIGIT(*cp)) {
|
|
|
546 counter = 0;
|
|
|
547 frac = 1000;
|
|
|
548 while (VIM_ISDIGIT(*cp))
|
|
|
549 counter = counter * 10L + (long)(*cp++ - '0');
|
|
|
550 if (*cp == '.')
|
|
|
551 while (VIM_ISDIGIT(*++cp)) {
|
|
|
552 counter = counter * 10L + (long)(*cp++ - '0');
|
|
|
553 frac = frac * 10;
|
|
|
554 }
|
|
|
555 if (*cp!='*') { /* multiply by affected lines */
|
|
|
556 if (affcnt>1) affcnt = 1;
|
|
|
557 }
|
|
|
558 else
|
|
|
559 cp++;
|
|
|
560
|
|
|
561 /* Calculate number of characters for padding counter/frac ms delay */
|
|
|
562 if (ospeed)
|
|
|
563 counter = (counter * _bauds[ospeed] * (long)affcnt) / frac;
|
|
|
564
|
|
|
565 while (*cp) /* output string */
|
|
|
566 (*outc)(*cp++);
|
|
|
567 if (ospeed)
|
|
|
568 while (counter--) /* followed by pad characters */
|
|
|
569 (*outc)(PC);
|
|
|
570 }
|
|
|
571 else
|
|
|
572 while (*cp)
|
|
|
573 (*outc)(*cp++);
|
|
|
574 return 0;
|
|
|
575 }
|
|
|
576
|
|
|
577 /*
|
|
|
578 * Module: tutil.c
|
|
|
579 *
|
|
|
580 * Purpose: Utility routines for TERMLIB functions.
|
|
|
581 *
|
|
|
582 */
|
|
|
583 static int
|
|
|
584 _match(s1, s2) /* returns length of text common to s1 and s2 */
|
|
|
585 char *s1, *s2;
|
|
|
586 {
|
|
|
587 int i = 0;
|
|
|
588
|
|
|
589 while (s1[i] && s1[i] == s2[i])
|
|
|
590 i++;
|
|
|
591
|
|
|
592 return i;
|
|
|
593 }
|
|
|
594
|
|
|
595 /*
|
|
|
596 * finds next c in s that's a member of set, returns pointer
|
|
|
597 */
|
|
|
598 static char *
|
|
|
599 _find(s, set)
|
|
|
600 char *s, *set;
|
|
|
601 {
|
|
|
602 for(; *s; s++)
|
|
|
603 {
|
|
|
604 char *ptr = set;
|
|
|
605
|
|
|
606 while (*ptr && *s != *ptr)
|
|
|
607 ptr++;
|
|
|
608
|
|
|
609 if (*ptr)
|
|
|
610 return s;
|
|
|
611 }
|
|
|
612
|
|
|
613 return s;
|
|
|
614 }
|
|
|
615
|
|
|
616 /*
|
|
|
617 * add val to buf according to format fmt
|
|
|
618 */
|
|
|
619 static char *
|
|
|
620 _addfmt(buf, fmt, val)
|
|
|
621 char *buf, *fmt;
|
|
|
622 int val;
|
|
|
623 {
|
|
|
624 sprintf(buf, fmt, val);
|
|
|
625 while (*buf)
|
|
|
626 buf++;
|
|
|
627 return buf;
|
|
|
628 }
|
