![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to play.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / mstools / samples / rpc / dict|
Return to play.c CVS log | Up to [WindowsNT SDKs] / mstools / samples / rpc / dict |
1.1 root 1: /*************************************************************/
2: /** **/
3: /** Microsoft RPC Examples **/
4: /** Dictionary Application **/
1.1.1.2 root 5: /** Copyright(c) Microsoft Corp. 1992 **/
1.1 root 6: /** **/
7: /*************************************************************/
8:
9: /*
10: *************************************************************************
11: * *
1.1.1.4 ! root 12: * Local dictionary :play" example *
1.1 root 13: * *
14: * Description: *
15: * This file contains a simple interactive loop of calls to the *
16: * dictionary. The interface is identical to the remote dictionary *
17: * program described in the readme file. *
1.1.1.4 ! root 18: * *
1.1 root 19: *************************************************************************
20: */
21:
22: #include <stdlib.h>
1.1.1.4 ! root 23: #include <stdio.h>
1.1 root 24: #include <ctype.h>
1.1.1.2 root 25:
1.1 root 26: #include "dict0.h"
27: #include "play.h"
28: #include "util0.h"
29:
30: #define TAB_STOPS 3
31:
1.1.1.2 root 32:
1.1 root 33: void Usage()
34: {
35: printf("Usage : play \n\n");
36: exit(1);
37: }
38:
39: /*************************************************************************/
40: /*** Remote Dictionary Test Loop ***/
41: /*************************************************************************/
42:
43: void
44: Usage_Msg()
45: {
1.1.1.2 root 46: printf("\nUsage: \nType a single character, followed by an optional key as follows:\n\n");
47: printf(" i <key> :: Insert <key> into dictionary\n");
48: printf(" d <key> :: Delete <key> from dictionary\n");
49: printf(" f <key> :: Find <key> in dictionary\n");
50: printf(" n :: Next of local current item in dictionary\n");
51: printf(" p :: Previous of local current item in dictionary\n");
52: printf(" h :: Head (first item) of dictionary\n");
53: printf(" t :: Tail (last item) of dictionary\n");
54: printf(" ? :: Print this message\n");
55: printf(" q :: Quit\n\n");
56: printf("where <key> is <integer> <string>\n");
1.1 root 57: }
58:
59: /*************************************************************************/
60: /*** Minimal Dictionary Operations: ***/
61: /*** ***/
62: /*** Dictionary *Dict_New(Cmp_rec*, Splay*, print_rec*) ***/
63: /*** ***/
64: /*** Dict_Status Dict_Find(Dictionary*, Item*) ***/
65: /*** Dict_Status Dict_Next(Dictionary*, Item*) ***/
66: /*** Dict_Status Dict_Prev(Dictionary*, Item*) ***/
67: /*** Dict_Status Dict_Insert(Dictionary*, Item*) ***/
68: /*** Dict_Status Dict_Delete(Dictionary*, Item**) ***/
69: /*** ***/
70: /*** Item* DICT_CURR_ITEM(Dict*) ***/
71: /*************************************************************************/
72:
73: void
74: TestLoop( Dictionary * pdict )
75: {
76: char currName[80];
77: char name[80];
78: char op = 0;
79: char buffer[80];
80:
81: Record r, currRecord;
82: Record *pcurrRecord = &currRecord;
83: Record *pr = &r;
84:
85: Dict_Status status;
86: short i;
87:
88: pcurrRecord->name = currName;
89: pr->name = name;
90:
91: Usage_Msg();
92:
93: while ( op != 'q' ) {
94:
1.1.1.2 root 95: printf("\nnext op (i d x f n p h t ? q): ");
1.1 root 96: gets(buffer);
97: op = buffer[0];
98:
99: if (op == 'i' || op == 'd' || op == 'f' ||
100: op == '+' || op == '-' || op == 'I')
101: sscanf(buffer+1, "%d %s", &pr->key, pr->name);
102:
103: switch (op) {
104: case 'h':
105: // get Head of list (first record);
106:
1.1.1.4 ! root 107: status = Dict_Next(pdict, NULL);
! 108: ItemCopy(DICT_CURR_ITEM(pdict), pcurrRecord);
! 109: ItemCopy(DICT_CURR_ITEM(pdict), pr);
1.1 root 110: break;
111:
112: case 't':
113: // get Tail of list (last record)
114:
1.1.1.4 ! root 115: status = Dict_Prev(pdict, NULL);
! 116: ItemCopy(DICT_CURR_ITEM(pdict), pcurrRecord);
! 117: ItemCopy(DICT_CURR_ITEM(pdict), pr);
1.1 root 118: break;
119:
120: case 'n':
121: // get Next record
122:
1.1.1.4 ! root 123: status = Dict_Next(pdict, pcurrRecord);
! 124: ItemCopy(DICT_CURR_ITEM(pdict), pcurrRecord);
1.1 root 125: break;
126:
127: case 'p':
128: // get Previous record
129:
1.1.1.4 ! root 130: status = Dict_Prev(pdict, pcurrRecord);
! 131: ItemCopy(DICT_CURR_ITEM(pdict), pcurrRecord);
1.1 root 132: break;
133:
134: case 'N':
135: // get Next record
136:
1.1.1.4 ! root 137: status = Dict_Next(pdict, pr);
! 138: ItemCopy(DICT_CURR_ITEM(pdict), pr);
1.1 root 139: break;
140:
141: case 'P':
142: // get Previous record
143:
1.1.1.4 ! root 144: status = Dict_Prev(pdict, pr);
! 145: ItemCopy(DICT_CURR_ITEM(pdict), pr);
1.1 root 146: break;
147:
148: case 'r':
1.1.1.4 ! root 149: ItemCopy(DICT_CURR_ITEM(pdict), pcurrRecord);
1.1 root 150: break;
151:
152:
153: case '+':
154: // get Next record
155:
1.1.1.4 ! root 156: status = Dict_Next(pdict, pr);
1.1 root 157: break;
158:
159: case '-':
160: // get Previous record
161:
1.1.1.4 ! root 162: status = Dict_Prev(pdict, pr);
! 163: break;
! 164:
! 165: case 'f':
! 166: // Find <key>
! 167:
! 168: status = Dict_Find(pdict, pr);
1.1 root 169: break;
170:
171: case 'i':
172: // Insert <key>
173:
1.1.1.4 ! root 174: status = Dict_Insert(pdict,
! 175: makeRecord(pr->key, pr->name) );
1.1 root 176: break;
177:
178: case 'I':
179: // Insert (<num'>,<name>) for all num': 3 < num' < num
180:
1.1.1.4 ! root 181: for (i = 3; i < pr->key; i++) {
! 182: status = Dict_Insert(pdict,
! 183: makeRecord(i, pr->name) );
! 184: }
1.1 root 185: break;
186:
187: case 'd':
188: // Delete <key>
189:
190: if (pdict != NULL) {
1.1.1.2 root 191: status = Dict_Delete(pdict, (void **)&pr);
1.1 root 192: freeRecord(pr);
193: pr = &r;
194: }
195: break;
196:
197: case 'x':
198: // Delete DICT_CURR_ITEM
199:
200: if ((pdict != NULL) && (pdict->root != NULL)) {
201: pr = DICT_CURR_ITEM(pdict);
1.1.1.2 root 202: status = Dict_Delete(pdict, (void **) &pr);
1.1 root 203: freeRecord(pr);
204: pr = &r;
205: }
206: break;
207:
208: case 'X':
209: // Empty the whole dictionary
210:
211: RecordTreeNodeFree((RecordTreeNode*)pdict->root);
212: pdict->root = NULL;
213: pr = &r;
214: break;
215:
216: case '?':
217: Usage_Msg();
218: break;
219: }
1.1.1.4 ! root 220:
! 221: if (op != '?' && op != 'q')
! 222: Dict_Print(pdict, TAB_STOPS);
1.1 root 223: }
224: }
225:
226: Dict_Status
1.1.1.4 ! root 227: Dict_New_Dict(OUT Dictionary ** ppdict)
1.1 root 228: {
229: static Dictionary * pdict;
230:
231: pdict = Dict_New(comp, tdSplay, printRecord);
232: Init_dict(pdict);
233:
234: *ppdict = pdict;
235: return(DICT_SUCCESS);
236: }
237:
238: void
239: Init_dict(Dictionary * dp)
240: {
241: Record* rp;
242:
1.1.1.2 root 243: rp = makeRecord((short)0, "jack_smith"); Dict_Insert(dp, rp);
244: rp = makeRecord((short)0, "john_doe"); Dict_Insert(dp, rp);
245: rp = makeRecord((short)1, "jean_doe"); Dict_Insert(dp, rp);
246: rp = makeRecord((short)0, "joana_smith"); Dict_Insert(dp, rp);
247: rp = makeRecord((short)1, "michael_jones"); Dict_Insert(dp, rp);
248: rp = makeRecord((short)0, "mike_jacobs"); Dict_Insert(dp, rp);
249: rp = makeRecord((short)2, "bill_jackson"); Dict_Insert(dp, rp);
250: rp = makeRecord((short)0, "jane_doe"); Dict_Insert(dp, rp);
251: rp = makeRecord((short)0, "dianne_jackson"); Dict_Insert(dp, rp);
252: rp = makeRecord((short)1, "james_doe"); Dict_Insert(dp, rp);
253: rp = makeRecord((short)1, "steve_johnson"); Dict_Insert(dp, rp);
254: rp = makeRecord((short)2, "debbie_jones"); Dict_Insert(dp, rp);
255: rp = makeRecord((short)0, "jacob_jacobson"); Dict_Insert(dp, rp);
1.1 root 256:
257: Dict_Print(dp, TAB_STOPS);
258: }
259:
260: /*************************************************************************/
261: /*** Main Loop ***/
262: /*************************************************************************/
263:
264: void
265: main_dict ()
266: {
267: Dictionary * pdict;
268: Dictionary ** ppdict = &pdict;
269:
1.1.1.4 ! root 270: printf("getting a new dict\n");
! 271: Dict_New_Dict(ppdict);
! 272: printf("gotten a new dict in main_dict\n");
1.1 root 273: TestLoop(pdict);
274: }
275:
1.1.1.3 root 276: void _CRTAPI1
1.1.1.2 root 277: main(int argc, char *argv[])
1.1 root 278: {
1.1.1.4 ! root 279: main_dict();
1.1 root 280: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.