![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to argcount.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDTahoe / new / jove|
Return to argcount.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / new / jove |
1.1 root 1: /***************************************************************************
2: * This program is Copyright (C) 1986, 1987, 1988 by Jonathan Payne. JOVE *
3: * is provided to you without charge, and with no warranty. You may give *
4: * away copies of JOVE, including sources, provided that this notice is *
5: * included in all the files. *
6: ***************************************************************************/
7:
8: #include "jove.h"
9: #include <ctype.h>
10:
11: #ifdef MAC
12: # undef private
13: # define private
14: #endif
15:
16: #ifdef LINT_ARGS
17: private void
18: gather_numeric_argument(int),
19: quad_numeric_arg(void);
20: #else
21: private void
22: gather_numeric_argument(),
23: quad_numeric_arg();
24: #endif
25:
26: #ifdef MAC
27: # undef private
28: # define private static
29: #endif
30:
31: private int arg_supplied_p,
32: arg_count;
33:
34: int
35: arg_type()
36: {
37: return arg_supplied_p;
38: }
39:
40: void
41: set_is_an_arg(there_is)
42: {
43: arg_supplied_p = there_is;
44: }
45:
46: void
47: set_arg_value(n)
48: {
49: arg_supplied_p = YES;
50: arg_count = n;
51: }
52:
53: void
54: negate_arg_value()
55: {
56: arg_count = -arg_count;
57: }
58:
59: void
60: clr_arg_value()
61: {
62: arg_supplied_p = NO;
63: arg_count = 1;
64: }
65:
66: /* return whether there is currently a numeric argument */
67:
68: int
69: is_an_arg()
70: {
71: return (arg_supplied_p != NO);
72: }
73:
74: /* return the numeric argument */
75:
76: int
77: arg_value()
78: {
79: return arg_count;
80: }
81:
82: /* called by C-U to gather a numeric argument, either C-U's or digits,
83: but not both */
84:
85: void
86: TimesFour()
87: {
88: quad_numeric_arg();
89: }
90:
91: /* This initializes the numeric argument to 1 and starts multiplying
92: by 4 (the magic number Stallman came up with). It is an error to
93: invoke quad_numeric_arg() interactively (via TimesFour()), because
94: it uses the LastKeyStruck variable to know what character signals
95: to multiply again (in the loop). */
96: private void
97: quad_numeric_arg()
98: {
99: int oldc = LastKeyStruck,
100: newc,
101: narg_count,
102: slow;
103:
104: slow = 0;
105: arg_supplied_p = YES;
106: arg_count = 1;
107: this_cmd = ARG_CMD;
108: do {
109: if ((narg_count = arg_count * 4) != 0)
110: arg_count = narg_count;
111: if (!slow)
112: newc = waitchar(&slow);
113: else
114: newc = getch();
115: if (isdigit(newc) || newc == '-') {
116: arg_supplied_p = NO;
117: gather_numeric_argument(newc);
118: return;
119: }
120: if (slow)
121: message(key_strokes);
122: } while (newc == oldc);
123: Ungetc(newc);
124: }
125:
126: private void
127: gather_numeric_argument(c)
128: {
129: int sign = 0;
130: static int digited;
131: int slow = 0;
132:
133: if (!isdigit(c) && c != '-')
134: complain((char *) 0);
135: if (arg_supplied_p == NO) { /* if we just got here */
136: arg_count = 0; /* start over */
137: digited = NO;
138: } else if (arg_supplied_p == YES_NODIGIT) {
139: sign = (arg_count < 0) ? -1 : 1;
140: arg_count = 0;
141: }
142:
143: if (!sign)
144: sign = (arg_count < 0) ? -1 : 1;
145: if (sign == -1)
146: arg_count = -arg_count;
147: if (c == '-') {
148: sign = -sign;
149: goto goread;
150: }
151: for (;;) {
152: if (slow)
153: message(key_strokes);
154: if (isdigit(c)) {
155: arg_count = (arg_count * 10) + (c - '0');
156: digited = YES;
157: } else {
158: if (digited)
159: arg_supplied_p = YES;
160: else {
161: arg_count = 1;
162: if (arg_supplied_p == NO)
163: arg_supplied_p = YES_NODIGIT;
164: }
165: arg_count *= sign;
166: this_cmd = ARG_CMD;
167: Ungetc(c);
168: return;
169: }
170: goread: if (!slow)
171: c = waitchar(&slow);
172: else {
173: add_mess(NullStr);
174: c = getch();
175: }
176: }
177: }
178:
179: void
180: Digit()
181: {
182: gather_numeric_argument(LastKeyStruck);
183: }
184:
185: void
186: Digit0()
187: {
188: gather_numeric_argument('0');
189: }
190:
191: void
192: Digit1()
193: {
194: gather_numeric_argument('1');
195: }
196:
197: void
198: Digit2()
199: {
200: gather_numeric_argument('2');
201: }
202:
203: void
204: Digit3()
205: {
206: gather_numeric_argument('3');
207: }
208:
209: void
210: Digit4()
211: {
212: gather_numeric_argument('4');
213: }
214:
215: void
216: Digit5()
217: {
218: gather_numeric_argument('5');
219: }
220:
221: void
222: Digit6()
223: {
224: gather_numeric_argument('6');
225: }
226:
227: void
228: Digit7()
229: {
230: gather_numeric_argument('7');
231: }
232:
233: void
234: Digit8()
235: {
236: gather_numeric_argument('8');
237: }
238:
239: void
240: Digit9()
241: {
242: gather_numeric_argument('9');
243: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.