Mercurial > hg > early-roguelike

comparison srogue/daemon.c @ 217:94a0d9dd5ce1

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Super-Rogue: convert to ANSI-style function declarations. This fixes most of the build warnings.
author John "Elwin" Edwards
date Sun, 31 Jan 2016 13:45:07 -0500
parents d6b7c3fb37ea
children b67b99f6c92b
comparison
equal deleted inserted replaced
216:b24545357d2e 217:94a0d9dd5ce1
32 /* 32 /*
33 * d_insert: 33 * d_insert:
34 * Insert a function in the daemon list. 34 * Insert a function in the daemon list.
35 */ 35 */
36 struct delayed_action * 36 struct delayed_action *
37 d_insert(func, arg, type, time) 37 d_insert(int (*func)(), int arg, int type, int time)
38 int arg, type, time, (*func)();
39 { 38 {
40 reg struct delayed_action *dev; 39 reg struct delayed_action *dev;
41 40
42 if (demoncnt < MAXDAEMONS) { 41 if (demoncnt < MAXDAEMONS) {
43 dev = &d_list[demoncnt]; 42 dev = &d_list[demoncnt];
49 return dev; 48 return dev;
50 } 49 }
51 return NULL; 50 return NULL;
52 } 51 }
53 52
54 d_delete(wire) 53 void
55 struct delayed_action *wire; 54 d_delete(struct delayed_action *wire)
56 { 55 {
57 reg struct delayed_action *d1, *d2; 56 reg struct delayed_action *d1, *d2;
58 57
59 for (d1 = d_list; d1 < &d_list[demoncnt]; d1++) { 58 for (d1 = d_list; d1 < &d_list[demoncnt]; d1++) {
60 if (wire == d1) { 59 if (wire == d1) {
71 /* 70 /*
72 * find_slot: 71 * find_slot:
73 * Find a particular slot in the table 72 * Find a particular slot in the table
74 */ 73 */
75 struct delayed_action * 74 struct delayed_action *
76 find_slot(func) 75 find_slot(int (*func)())
77 int (*func)();
78 { 76 {
79 reg struct delayed_action *dev; 77 reg struct delayed_action *dev;
80 78
81 for (dev = d_list; dev < &d_list[demoncnt]; dev++) 79 for (dev = d_list; dev < &d_list[demoncnt]; dev++)
82 if (dev->d_type != EMPTY && func == dev->d_func) 80 if (dev->d_type != EMPTY && func == dev->d_func)
86 84
87 /* 85 /*
88 * start_daemon: 86 * start_daemon:
89 * Start a daemon, takes a function. 87 * Start a daemon, takes a function.
90 */ 88 */
91 start_daemon(func, arg, type) 89 void
92 int arg, type, (*func)(); 90 start_daemon(int (*func)(), int arg, int type)
93 { 91 {
94 d_insert(func, arg, type, DAEMON); 92 d_insert(func, arg, type, DAEMON);
95 } 93 }
96 94
97 /* 95 /*
98 * do_daemons: 96 * do_daemons:
99 * Run all the daemons that are active with the current 97 * Run all the daemons that are active with the current
100 * flag, passing the argument to the function. 98 * flag, passing the argument to the function.
101 */ 99 */
102 do_daemons(flag) 100 void
103 int flag; 101 do_daemons(int flag)
104 { 102 {
105 reg struct delayed_action *dev; 103 reg struct delayed_action *dev;
106 104
107 for (dev = d_list; dev < &d_list[demoncnt]; dev++) 105 for (dev = d_list; dev < &d_list[demoncnt]; dev++)
108 if (dev->d_type == flag && dev->d_time == DAEMON) 106 if (dev->d_type == flag && dev->d_time == DAEMON)
111 109
112 /* 110 /*
113 * fuse: 111 * fuse:
114 * Start a fuse to go off in a certain number of turns 112 * Start a fuse to go off in a certain number of turns
115 */ 113 */
116 fuse(func, arg, time) 114 void
117 int (*func)(), arg, time; 115 fuse(int (*func)(), int arg, int time)
118 { 116 {
119 d_insert(func, arg, AFTER, time); 117 d_insert(func, arg, AFTER, time);
120 } 118 }
121 119
122 /* 120 /*
123 * lengthen: 121 * lengthen:
124 * Increase the time until a fuse goes off 122 * Increase the time until a fuse goes off
125 */ 123 */
126 lengthen(func, xtime) 124 void
127 int (*func)(), xtime; 125 lengthen(int (*func)(), int xtime)
128 { 126 {
129 reg struct delayed_action *wire; 127 reg struct delayed_action *wire;
130 128
131 for (wire = d_list; wire < &d_list[demoncnt]; wire++) 129 for (wire = d_list; wire < &d_list[demoncnt]; wire++)
132 if (wire->d_type != EMPTY && func == wire->d_func) 130 if (wire->d_type != EMPTY && func == wire->d_func)
135 133
136 /* 134 /*
137 * extinguish: 135 * extinguish:
138 * Put out a fuse. Find all such fuses and kill them. 136 * Put out a fuse. Find all such fuses and kill them.
139 */ 137 */
140 extinguish(func) 138 void
141 int (*func)(); 139 extinguish(int (*func)())
142 { 140 {
143 reg struct delayed_action *dev; 141 reg struct delayed_action *dev;
144 142
145 for (dev = d_list; dev < &d_list[demoncnt]; dev++) 143 for (dev = d_list; dev < &d_list[demoncnt]; dev++)
146 if (dev->d_type != EMPTY && func == dev->d_func) 144 if (dev->d_type != EMPTY && func == dev->d_func)
149 147
150 /* 148 /*
151 * do_fuses: 149 * do_fuses:
152 * Decrement counters and start needed fuses 150 * Decrement counters and start needed fuses
153 */ 151 */
154 do_fuses() 152 void
153 do_fuses(void)
155 { 154 {
156 reg struct delayed_action *dev; 155 reg struct delayed_action *dev;
157 156
158 for (dev = d_list; dev < &d_list[demoncnt]; dev++) { 157 for (dev = d_list; dev < &d_list[demoncnt]; dev++) {
159 if (dev->d_type == AFTER && dev->d_time > DAEMON) { 158 if (dev->d_type == AFTER && dev->d_time > DAEMON) {
168 167
169 /* 168 /*
170 * activity: 169 * activity:
171 * Show wizard number of demaons and memory blocks used 170 * Show wizard number of demaons and memory blocks used
172 */ 171 */
173 activity() 172 void
173 activity(void)
174 { 174 {
175 msg("Daemons = %d : Memory Items = %d : Memory Used = %d", 175 msg("Daemons = %d : Memory Items = %d : Memory Used = %d",
176 demoncnt,total,md_memused()); 176 demoncnt,total,md_memused());
177 } 177 }