![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to con_hi.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Synchronet] / sbbs / sbbs2|
Return to con_hi.c CVS log | Up to [Synchronet] / sbbs / sbbs2 |
1.1 root 1: #line 1 "CON_HI.C"
2:
3: /* Developed 1990-1997 by Rob Swindell; PO Box 501, Yorba Linda, CA 92885 */
4:
5: #include "sbbs.h"
6:
7: extern char question[128];
8:
9: char *mnestr;
10:
11: /****************************************************************************/
12: /* Waits for remote or local user to input a CR terminated string. 'length' */
13: /* is the maximum number of characters that getstr will allow the user to */
14: /* input into the string. 'mode' specifies upper case characters are echoed */
15: /* or wordwrap or if in message input (^A sequences allowed). ^W backspaces */
16: /* a word, ^X backspaces a line, ^Gs, BSs, TABs are processed, LFs ignored. */
17: /* ^N non-destructive BS, ^V center line. Valid keys are echoed. */
18: /****************************************************************************/
19: int getstr(char *strout, int maxlen, long mode)
20: {
21: int i,l,x,z; /* i=current position, l=length, j=printed chars */
22: /* x&z=misc */
23: uchar ch,str1[256],str2[256],ins=0,atr;
24:
25: console&=~CON_UPARROW;
26: sys_status&=~SS_ABORT;
27: if(mode&K_LINE && useron.misc&ANSI && !(mode&K_NOECHO)) {
28: attr(color[clr_inputline]);
29: for(i=0;i<maxlen;i++)
30: outchar(SP);
31: bprintf("\x1b[%dD",maxlen); }
32: if(wordwrap[0]) {
33: strcpy(str1,wordwrap);
34: wordwrap[0]=0; }
35: else str1[0]=0;
36: if(mode&K_EDIT)
37: strcat(str1,strout);
38: if(strlen(str1)>maxlen)
39: str1[maxlen]=0;
40: atr=curatr;
41: if(!(mode&K_NOECHO)) {
42: if(mode&K_AUTODEL && str1[0]) {
43: i=(color[clr_inputline]&0x77)<<4;
44: i|=(color[clr_inputline]&0x77)>>4;
45: attr(i); }
46: rputs(str1);
47: if(mode&K_EDIT && !(mode&(K_LINE|K_AUTODEL)) && useron.misc&ANSI)
48: bputs("\x1b[K"); /* destroy to eol */ }
49:
50: i=l=strlen(str1);
51: if(mode&K_AUTODEL && str1[0] && !(mode&K_NOECHO)) {
52: ch=getkey(mode|K_GETSTR);
53: attr(atr);
54: if(isprint(ch) || ch==0x7f) {
55: for(i=0;i<l;i++)
56: bputs("\b \b");
57: i=l=0; }
58: else {
59: for(i=0;i<l;i++)
60: outchar(BS);
61: rputs(str1);
62: i=l; }
63: if(ch!=SP && ch!=TAB)
64: ungetkey(ch); }
65:
66: while(!(sys_status&SS_ABORT) && (ch=getkey(mode|K_GETSTR))!=CR && online) {
67: if(sys_status&SS_ABORT)
68: break;
69: if(ch==LF) /* Ctrl-J same as CR */
70: break;
71: if(!i && mode&K_UPRLWR && (ch==SP || ch==TAB))
72: continue; /* ignore beginning white space if upper/lower */
73: if(mode&K_E71DETECT && ch==(CR|0x80) && l>1) {
74: if(strstr(str1,"��")) {
75: bputs("\r\n\r\nYou must set your terminal to NO PARITY, "
76: "8 DATA BITS, and 1 STOP BIT (N-8-1).\7\r\n");
77: return(0); } }
78: switch(ch) {
79: case 1: /* Ctrl-A for ANSI */
80: if(!(mode&K_MSG) || useron.rest&FLAG('A') || i>maxlen-3)
81: break;
82: if(ins) {
83: if(l<maxlen)
84: l++;
85: for(x=l;x>i;x--)
86: str1[x]=str1[x-1];
87: rprintf("%.*s",l-i,str1+i);
88: rprintf("\x1b[%dD",l-i);
89: if(i==maxlen-1)
90: ins=0; }
91: outchar(str1[i++]=1);
92: break;
93: case 2: /* Ctrl-B Beginning of Line */
94: if(useron.misc&ANSI && i && !(mode&K_NOECHO)) {
95: bprintf("\x1b[%dD",i);
96: i=0; }
97: break;
98: case 4: /* Ctrl-D Delete word right */
99: if(i<l) {
100: x=i;
101: while(x<l && str1[x]!=SP) {
102: outchar(SP);
103: x++; }
104: while(x<l && str1[x]==SP) {
105: outchar(SP);
106: x++; }
107: bprintf("\x1b[%dD",x-i); /* move cursor back */
108: z=i;
109: while(z<l-(x-i)) { /* move chars in string */
110: outchar(str1[z]=str1[z+(x-i)]);
111: z++; }
112: while(z<l) { /* write over extra chars */
113: outchar(SP);
114: z++; }
115: bprintf("\x1b[%dD",z-i);
116: l-=x-i; } /* l=new length */
117: break;
118: case 5: /* Ctrl-E End of line */
119: if(useron.misc&ANSI && i<l) {
120: bprintf("\x1b[%dC",l-i); /* move cursor to eol */
121: i=l; }
122: break;
123: case 6: /* Ctrl-F move cursor forewards */
124: if(i<l && (useron.misc&ANSI)) {
125: bputs("\x1b[C"); /* move cursor right one */
126: i++; }
127: break;
128: case 7:
129: if(!(mode&K_MSG))
130: break;
131: if(useron.rest&FLAG('B')) {
132: if (i+6<maxlen) {
133: if(ins) {
134: for(x=l+6;x>i;x--)
135: str1[x]=str1[x-6];
136: if(l+5<maxlen)
137: l+=6;
138: if(i==maxlen-1)
139: ins=0; }
140: str1[i++]='(';
141: str1[i++]='b';
142: str1[i++]='e';
143: str1[i++]='e';
144: str1[i++]='p';
145: str1[i++]=')';
146: if(!(mode&K_NOECHO))
147: bputs("(beep)"); }
148: if(ins)
149: redrwstr(str1,i,l,0);
150: break; }
151: if(ins) {
152: if(l<maxlen)
153: l++;
154: for(x=l;x>i;x--)
155: str1[x]=str1[x-1];
156: if(i==maxlen-1)
157: ins=0; }
158: if(i<maxlen) {
159: str1[i++]=7;
160: if(!(mode&K_NOECHO))
161: outchar(7); }
162: break;
163: case 14: /* Ctrl-N Next word */
164: if(i<l && (useron.misc&ANSI)) {
165: x=i;
166: while(str1[i]!=SP && i<l)
167: i++;
168: while(str1[i]==SP && i<l)
169: i++;
170: bprintf("\x1b[%dC",i-x); }
171: break;
172: case 0x1c: /* Ctrl-\ Previous word */
173: if(i && (useron.misc&ANSI) && !(mode&K_NOECHO)) {
174: x=i;
175: while(str1[i-1]==SP && i)
176: i--;
177: while(str1[i-1]!=SP && i)
178: i--;
179: bprintf("\x1b[%dD",x-i); }
180: break;
181: case 18: /* Ctrl-R Redraw Line */
182: if(!(mode&K_NOECHO))
183: redrwstr(str1,i,l,0);
184: break;
185: case TAB:
186: if(!(i%TABSIZE)) {
187: if(ins) {
188: if(l<maxlen)
189: l++;
190: for(x=l;x>i;x--)
191: str1[x]=str1[x-1];
192: if(i==maxlen-1)
193: ins=0; }
194: str1[i++]=SP;
195: if(!(mode&K_NOECHO))
196: outchar(SP); }
197: while(i<maxlen && i%TABSIZE) {
198: if(ins) {
199: if(l<maxlen)
200: l++;
201: for(x=l;x>i;x--)
202: str1[x]=str1[x-1];
203: if(i==maxlen-1)
204: ins=0; }
205: str1[i++]=SP;
206: if(!(mode&K_NOECHO))
207: outchar(SP); }
208: if(ins && !(mode&K_NOECHO))
209: redrwstr(str1,i,l,0);
210: break;
211: case BS:
212: if(!i)
213: break;
214: i--;
215: l--;
216: if(i!=l) { /* Deleting char in middle of line */
217: outchar(BS);
218: z=i;
219: while(z<l) { /* move the characters in the line */
220: outchar(str1[z]=str1[z+1]);
221: z++; }
222: outchar(SP); /* write over the last char */
223: bprintf("\x1b[%dD",(l-i)+1); }
224: else if(!(mode&K_NOECHO))
225: bputs("\b \b");
226: break;
227: case 22: /* Ctrl-V Center line */
228: str1[l]=0;
229: l=bstrlen(str1);
230: if(!l) break;
231: for(x=0;x<(maxlen-l)/2;x++)
232: str2[x]=SP;
233: str2[x]=0;
234: strcat(str2,str1);
235: strcpy(strout,str2);
236: l=strlen(strout);
237: if(mode&K_NOECHO)
238: return(l);
239: if(mode&K_MSG)
240: redrwstr(strout,i,l,K_MSG);
241: else {
242: while(i--)
243: bputs("\b");
244: bputs(strout);
245: if(mode&K_LINE)
246: attr(LIGHTGRAY); }
247: CRLF;
248: return(l);
249: case 23: /* Ctrl-W Delete word left */
250: if(i<l) {
251: x=i; /* x=original offset */
252: while(i && str1[i-1]==SP) {
253: outchar(BS);
254: i--; }
255: while(i && str1[i-1]!=SP) {
256: outchar(BS);
257: i--; }
258: z=i; /* i=z=new offset */
259: while(z<l-(x-i)) { /* move chars in string */
260: outchar(str1[z]=str1[z+(x-i)]);
261: z++; }
262: while(z<l) { /* write over extra chars */
263: outchar(SP);
264: z++; }
265: bprintf("\x1b[%dD",z-i); /* back to new x corridnant */
266: l-=x-i; } /* l=new length */
267: else {
268: while(i && str1[i-1]==SP) {
269: i--;
270: l--;
271: if(!(mode&K_NOECHO))
272: bputs("\b \b"); }
273: while(i && str1[i-1]!=SP) {
274: i--;
275: l--;
276: if(!(mode&K_NOECHO))
277: bputs("\b \b"); } }
278: break;
279: case 24: /* Ctrl-X Delete entire line */
280: if(mode&K_NOECHO)
281: l=0;
282: else {
283: while(i<l) {
284: outchar(SP);
285: i++; }
286: while(l) {
287: l--;
288: bputs("\b \b"); } }
289: i=0;
290: break;
291: case 25: /* Ctrl-Y Delete to end of line */
292: if(useron.misc&ANSI && !(mode&K_NOECHO)) {
293: bputs("\x1b[K");
294: l=i; }
295: break;
296: case 31: /* Ctrl-Minus Toggles Insert/Overwrite */
297: if(!(useron.misc&ANSI) || mode&K_NOECHO)
298: break;
299: if(ins) {
300: ins=0;
301: redrwstr(str1,i,l,0); }
302: else if(i<l) {
303: ins=1;
304: bprintf("\x1b[s\x1b[%dC",79-lclwx()); /* save pos */
305: z=curatr; /* and got to EOL */
306: attr(z|BLINK|HIGH);
307: outchar('�');
308: attr(z);
309: bputs("\x1b[u"); } /* restore pos */
310: break;
311: case 0x1e: /* Ctrl-^ */
312: if(!(mode&K_EDIT))
313: break;
314: if(i>l)
315: l=i;
316: str1[l]=0;
317: strcpy(strout,str1);
318: if((stripattr(strout) || ins) && !(mode&K_NOECHO))
319: redrwstr(strout,i,l,K_MSG);
320: if(mode&K_LINE && !(mode&K_NOECHO))
321: attr(LIGHTGRAY);
322: console|=CON_UPARROW;
323: return(l);
324: case 0x1d: /* Ctrl-] Reverse Cursor Movement */
325: if(i && (useron.misc&ANSI) && !(mode&K_NOECHO)) {
326: bputs("\x1b[D"); /* move cursor left one */
327: i--; }
328: break;
329: case 0x7f: /* Ctrl-BkSpc (DEL) Delete current char */
330: if(i==l)
331: break;
332: l--;
333: z=i;
334: while(z<l) { /* move the characters in the line */
335: outchar(str1[z]=str1[z+1]);
336: z++; }
337: outchar(SP); /* write over the last char */
338: bprintf("\x1b[%dD",(l-i)+1);
339: break;
340: default:
341: if(mode&K_WRAP && i==maxlen && ch>=SP && !ins) {
342: str1[i]=0;
343: if(ch==SP && !(mode&K_CHAT)) { /* don't wrap a space */
344: strcpy(strout,str1); /* as last char */
345: if(stripattr(strout) && !(mode&K_NOECHO))
346: redrwstr(strout,i,l,K_MSG);
347: if(!(mode&K_NOECHO))
348: CRLF;
349: return(i); }
350: x=i-1;
351: z=1;
352: wordwrap[0]=ch;
353: while(str1[x]!=SP && x)
354: wordwrap[z++]=str1[x--];
355: if(x<(maxlen/2)) {
356: wordwrap[1]=0; /* only wrap one character */
357: strcpy(strout,str1);
358: if(stripattr(strout) && !(mode&K_NOECHO))
359: redrwstr(strout,i,l,K_MSG);
360: if(!(mode&K_NOECHO))
361: CRLF;
362: return(i); }
363: wordwrap[z]=0;
364: if(!(mode&K_NOECHO))
365: while(z--) {
366: bputs("\b \b");
367: i--; }
368: strrev(wordwrap);
369: str1[x]=0;
370: strcpy(strout,str1);
371: if(stripattr(strout) && !(mode&K_NOECHO))
372: redrwstr(strout,i,x,mode);
373: if(!(mode&K_NOECHO))
374: CRLF;
375: return(x); }
376: if(i<maxlen && ch>=SP) {
377: if(mode&K_UPRLWR)
378: if(!i || (i && (str1[i-1]==SP || str1[i-1]=='-'
379: || str1[i-1]=='.' || str1[i-1]=='_')))
380: ch=toupper(ch);
381: else
382: ch=tolower(ch);
383: if(ins) {
384: if(l<maxlen) /* l<maxlen */
385: l++;
386: for(x=l;x>i;x--)
387: str1[x]=str1[x-1];
388: rprintf("%.*s",l-i,str1+i);
389: rprintf("\x1b[%dD",l-i);
390: if(i==maxlen-1) {
391: bputs(" \b\b");
392: ins=0; } }
393: str1[i++]=ch;
394: if(!(mode&K_NOECHO))
395: outchar(ch); } }
396: if(i>l)
397: l=i;
398: if(mode&K_CHAT && !l)
399: return(0); }
400: if(!online)
401: return(0);
402: if(i>l)
403: l=i;
404: str1[l]=0;
405: if(!(sys_status&SS_ABORT)) {
406: strcpy(strout,str1);
407: if((stripattr(strout) || ins) && !(mode&K_NOECHO))
408: redrwstr(strout,i,l,K_MSG); }
409: else
410: l=0;
411: if(mode&K_LINE && !(mode&K_NOECHO)) attr(LIGHTGRAY);
412: if(!(mode&(K_NOCRLF|K_NOECHO))) {
413: outchar(CR);
414: if(!(mode&K_MSG && sys_status&SS_ABORT))
415: outchar(LF);
416: lncntr=0; }
417: return(l);
418: }
419:
420: /****************************************************************************/
421: /* Hot keyed number input routine. */
422: /* Returns a valid number between 1 and max, 0 if no number entered, or -1 */
423: /* if the user hit 'Q' or ctrl-c */
424: /****************************************************************************/
425: long getnum(ulong max)
426: {
427: uchar ch,n=0;
428: long i=0;
429:
430: while(online) {
431: ch=getkey(K_UPPER);
432: if(ch>0x7f)
433: continue;
434: if(ch=='Q') {
435: outchar('Q');
436: if(useron.misc&COLDKEYS)
437: ch=getkey(K_UPPER);
438: if(ch==BS) {
439: bputs("\b \b");
440: continue; }
441: CRLF;
442: lncntr=0;
443: return(-1); }
444: else if(sys_status&SS_ABORT) {
445: CRLF;
446: lncntr=0;
447: return(-1); }
448: else if(ch==CR) {
449: CRLF;
450: lncntr=0;
451: return(i); }
452: else if(ch==BS && n) {
453: bputs("\b \b");
454: i/=10;
455: n--; }
456: else if(isdigit(ch) && (i*10L)+(ch&0xf)<=max && (ch!='0' || n)) {
457: i*=10L;
458: n++;
459: i+=ch&0xf;
460: outchar(ch);
461: if(i*10L>max && !(useron.misc&COLDKEYS)) {
462: CRLF;
463: lncntr=0;
464: return(i); } } }
465: return(0);
466: }
467:
468: /*****************************************************************************/
469: /* Displays or erases [WAIT] message */
470: /*****************************************************************************/
471: void waitforsysop(char on)
472: {
473: static saveatr;
474: int i,j;
475:
476: if(on) {
477: saveatr=curatr;
478: bputs(text[Wait]);
479: lclatr(LIGHTGRAY);
480: return; }
481: j=bstrlen(text[Wait]);
482: attr(saveatr);
483: for(i=0;i<j;i++)
484: bputs("\b \b");
485: }
486:
487: /****************************************************************************/
488: /* Returns 1 if a is a valid ctrl-a code, 0 if it isn't. */
489: /****************************************************************************/
490: char validattr(char a)
491: {
492:
493: switch(toupper(a)) {
494: case '-': /* clear */
495: case '_': /* clear */
496: case 'B': /* blue fg */
497: case 'C': /* cyan fg */
498: case 'G': /* green fg */
499: case 'H': /* high fg */
500: case 'I': /* blink */
501: case 'K': /* black fg */
502: case 'L': /* cls */
503: case 'M': /* magenta fg */
504: case 'N': /* normal */
505: case 'P': /* pause */
506: case 'R': /* red fg */
507: case 'W': /* white fg */
508: case 'Y': /* yellow fg */
509: case '0': /* black bg */
510: case '1': /* red bg */
511: case '2': /* green bg */
512: case '3': /* brown bg */
513: case '4': /* blue bg */
514: case '5': /* magenta bg */
515: case '6': /* cyan bg */
516: case '7': /* white bg */
517: return(1); }
518: return(0);
519: }
520:
521: /****************************************************************************/
522: /* Strips invalid Ctrl-Ax sequences from str */
523: /* Returns number of ^A's in line */
524: /****************************************************************************/
525: char stripattr(char *strin)
526: {
527: uchar str[256];
528: uchar a,c,d,e;
529:
530: e=strlen(strin);
531: for(a=c=d=0;c<e;c++) {
532: if(strin[c]==1) {
533: a++;
534: if(!validattr(strin[c+1])) {
535: c++;
536: continue; } }
537: str[d++]=strin[c]; }
538: str[d]=0;
539: strcpy(strin,str);
540: return(a);
541: }
542:
543: /****************************************************************************/
544: /* Redraws str using i as current cursor position and l as length */
545: /****************************************************************************/
546: void redrwstr(char *strin, int i, int l, char mode)
547: {
548: char str[256],c;
549:
550: sprintf(str,"%-*.*s",l,l,strin);
551: c=i;
552: while(c--)
553: outchar(BS);
554: if(mode&K_MSG)
555: bputs(str);
556: else
557: rputs(str);
558: if(useron.misc&ANSI) {
559: bputs("\x1b[K");
560: if(i<l)
561: bprintf("\x1b[%dD",l-i); }
562: else {
563: while(c<79) { /* clear to end of line */
564: outchar(SP);
565: c++; }
566: while(c>l) { /* back space to end of string */
567: outchar(BS);
568: c--; } }
569: }
570:
571: /****************************************************************************/
572: /* Outputs a string highlighting characters preceeded by a tilde */
573: /****************************************************************************/
574: void mnemonics(char *str)
575: {
576: char *ctrl_a_codes;
577: long l;
578:
579: if(!strchr(str,'~')) {
580: mnestr=str;
581: bputs(str);
582: return; }
583: ctrl_a_codes=strchr(str,1);
584: if(!ctrl_a_codes) {
585: if(str[0]=='@' && str[strlen(str)-1]=='@' && !strchr(str,SP)) {
586: mnestr=str;
587: bputs(str);
588: return; }
589: attr(color[clr_mnelow]); }
590: l=0L;
591: while(str[l]) {
592: if(str[l]=='~' && str[l+1]) {
593: if(!(useron.misc&ANSI))
594: outchar('(');
595: l++;
596: if(!ctrl_a_codes)
597: attr(color[clr_mnehigh]);
598: outchar(str[l]);
599: l++;
600: if(!(useron.misc&ANSI))
601: outchar(')');
602: if(!ctrl_a_codes)
603: attr(color[clr_mnelow]); }
604: else {
605: if(str[l]==1) { /* ctrl-a */
606: ctrl_a(str[++l]); /* skip the ctrl-a */
607: l++; } /* skip the attribute code */
608: else
609: outchar(str[l++]); } }
610: if(!ctrl_a_codes)
611: attr(color[clr_mnecmd]);
612: }
613:
614: /****************************************************************************/
615: /* Prompts user for Y or N (yes or no) and CR is interpreted as a Y */
616: /* Returns 1 for Y or 0 for N */
617: /* Called from quite a few places */
618: /****************************************************************************/
619: char yesno(char *str)
620: {
621: char ch;
622:
623: strcpy(question,str);
624: SYNC;
625: if(useron.misc&WIP) {
626: strip_ctrl(question);
627: menu("YESNO"); }
628: else
629: bprintf(text[YesNoQuestion],str);
630: while(online) {
631: if(sys_status&SS_ABORT)
632: ch=text[YN][1];
633: else
634: ch=getkey(K_UPPER|K_COLD);
635: if(ch==text[YN][0] || ch==CR) {
636: if(bputs(text[Yes]))
637: CRLF;
638: lncntr=0;
639: return(1); }
640: if(ch==text[YN][1]) {
641: if(bputs(text[No]))
642: CRLF;
643: lncntr=0;
644: return(0); } }
645: return(1);
646: }
647:
648: /****************************************************************************/
649: /* Prompts user for N or Y (no or yes) and CR is interpreted as a N */
650: /* Returns 1 for N or 0 for Y */
651: /* Called from quite a few places */
652: /****************************************************************************/
653: char noyes(char *str)
654: {
655: char ch;
656:
657: strcpy(question,str);
658: SYNC;
659: if(useron.misc&WIP) {
660: strip_ctrl(question);
661: menu("NOYES"); }
662: else
663: bprintf(text[NoYesQuestion],str);
664: while(online) {
665: if(sys_status&SS_ABORT)
666: ch=text[YN][1];
667: else
668: ch=getkey(K_UPPER|K_COLD);
669: if(ch==text[YN][1] || ch==CR) {
670: if(bputs(text[No]))
671: CRLF;
672: lncntr=0;
673: return(1); }
674: if(ch==text[YN][0]) {
675: if(bputs(text[Yes]))
676: CRLF;
677: lncntr=0;
678: return(0); } }
679: return(1);
680: }
681:
682: /****************************************************************************/
683: /* Waits for remote or local user to hit a key that is contained inside str.*/
684: /* 'str' should contain uppercase characters only. When a valid key is hit, */
685: /* it is echoed (upper case) and is the return value. */
686: /* Called from quite a few functions */
687: /****************************************************************************/
688: long getkeys(char *str, ulong max)
689: {
690: uchar ch,n=0,c;
691: ulong i=0;
692:
693: strupr(str);
694: while(online) {
695: ch=getkey(K_UPPER);
696: if(max && ch>0x7f) /* extended ascii chars are digits to isdigit() */
697: continue;
698: if(sys_status&SS_ABORT) { /* return -1 if Ctrl-C hit */
699: attr(LIGHTGRAY);
700: CRLF;
701: lncntr=0;
702: return(-1); }
703: if(ch && !n && (strchr(str,ch))) { /* return character if in string */
704: outchar(ch);
705: if(useron.misc&COLDKEYS && ch>SP) {
706: while(online && !(sys_status&SS_ABORT)) {
707: c=getkey(0);
708: if(c==CR || c==BS)
709: break; }
710: if(sys_status&SS_ABORT) {
711: CRLF;
712: return(-1); }
713: if(c==BS) {
714: bputs("\b \b");
715: continue; } }
716: attr(LIGHTGRAY);
717: CRLF;
718: lncntr=0;
719: return(ch); }
720: if(ch==CR && max) { /* return 0 if no number */
721: attr(LIGHTGRAY);
722: CRLF;
723: lncntr=0;
724: if(n)
725: return(i|0x80000000L); /* return number plus high bit */
726: return(0); }
727: if(ch==BS && n) {
728: bputs("\b \b");
729: i/=10;
730: n--; }
731: else if(max && isdigit(ch) && (i*10)+(ch&0xf)<=max && (ch!='0' || n)) {
732: i*=10;
733: n++;
734: i+=ch&0xf;
735: outchar(ch);
736: if(i*10>max && !(useron.misc&COLDKEYS)) {
737: attr(LIGHTGRAY);
738: CRLF;
739: lncntr=0;
740: return(i|0x80000000L); } } }
741: return(-1);
742: }
743:
744: void center(char *str)
745: {
746: int i,j;
747:
748: j=bstrlen(str);
749: for(i=0;i<(80-j)/2;i++)
750: outchar(SP);
751: bputs(str);
752: CRLF;
753: }
754:
755:
756: int uselect(int add, int n, char *title, char *item, char *ar)
757: {
758: static uint total,num[500];
759: char str[128];
760: int i,t;
761:
762: if(add) {
763: if(ar && !chk_ar(ar,useron))
764: return(0);
765: if(!total)
766: bprintf(text[SelectItemHdr],title);
767: num[total++]=n;
768: bprintf(text[SelectItemFmt],total,item);
769: return(0); }
770:
771: if(!total)
772: return(-1);
773:
774: for(i=0;i<total;i++)
775: if(num[i]==n)
776: break;
777: if(i==total)
778: i=0;
779: sprintf(str,text[SelectItemWhich],i+1);
780: mnemonics(str);
781: i=getnum(total);
782: t=total;
783: total=0;
784: if(i<0)
785: return(-1);
786: if(!i) { /* User hit ENTER, use default */
787: for(i=0;i<t;i++)
788: if(num[i]==n)
789: return(num[i]);
790: if(n<t)
791: return(num[n]);
792: return(-1); }
793: return(num[i-1]);
794: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.