Mercurial > repos > rhope
comparison saveload.c @ 0:76568becd6d6
Rhope Alpha 2a source import
author | Mike Pavone <pavone@retrodev.com> |
---|---|
date | Tue, 28 Apr 2009 23:06:07 +0000 |
parents | |
children |
comparison
equal
deleted
inserted
replaced
-1:000000000000 | 0:76568becd6d6 |
---|---|
1 #include "interp.h" | |
2 #include "structs.h" | |
3 #include <stdio.h> | |
4 #include <string.h> | |
5 #include <stdlib.h> | |
6 | |
7 /* | |
8 void save_program(char * filename) | |
9 { | |
10 worker * aworkerlist; | |
11 wire * awirelist; | |
12 FILE * savefile; | |
13 int def_num, version = 1; | |
14 savefile = fopen(filename, "wb"); | |
15 if(!savefile) | |
16 return; | |
17 //deflist[current_def].num_workers = num_workers; | |
18 //deflist[current_def].num_wires = num_wires; | |
19 fwrite(&version, 4, 1, savefile); | |
20 fwrite(&num_defs, 4, 1, savefile); | |
21 fwrite(deflist, sizeof(worker_def), num_defs, savefile); | |
22 for(def_num = 0; def_num < num_defs; ++def_num) | |
23 { | |
24 if(deflist[def_num].workerlist) | |
25 { | |
26 fwrite(&def_num, 4, 1, savefile); | |
27 //fwrite(&(deflist[def_num].num_workers), 4, 1, savefile); | |
28 fwrite(deflist[def_num].workerlist, sizeof(worker), deflist[def_num].num_workers, savefile); | |
29 //fwrite(&(deflist[def_num].num_wires), 4, 1, savefile); | |
30 fwrite(deflist[def_num].wirelist, sizeof(wire), deflist[def_num].num_wires, savefile); | |
31 } | |
32 } | |
33 def_num = -1; | |
34 fwrite(&def_num, 4, 1, savefile); | |
35 fclose(savefile); | |
36 }*/ | |
37 | |
38 program * new_program(int def_storage, int comp_storage) | |
39 { | |
40 defchunk * defs = malloc(sizeof(defchunk) + (def_storage - 1) * sizeof(worker_def)); | |
41 program * prog = malloc(sizeof(program)); | |
42 defs->num_defs = 0; | |
43 defs->deflist[0].name = NULL; | |
44 defs->defs_storage = def_storage; | |
45 defs->next = NULL; | |
46 prog->current = prog->defs = defs; | |
47 //prog->deflist = malloc(sizeof(worker_def) * def_storage); | |
48 //prog->num_defs = 0; | |
49 //prog->defs_storage = def_storage; | |
50 prog->companylist = malloc(sizeof(company) * comp_storage); | |
51 prog->num_companies = 0; | |
52 prog->companies_storage = comp_storage; | |
53 prog->refcount = 1; | |
54 VIS_InitializeCriticalSection(prog->lock); | |
55 return prog; | |
56 } | |
57 | |
58 int count_defs(defchunk * chunk) | |
59 { | |
60 int total = 0; | |
61 while(chunk) | |
62 { | |
63 total += chunk->num_defs; | |
64 chunk = chunk->next; | |
65 } | |
66 return total; | |
67 } | |
68 | |
69 void save_program(program * prog, char * filename) | |
70 { | |
71 int version = 2; | |
72 int total_bytes = 0; | |
73 int zero = 0; | |
74 int i; | |
75 int num_defs; | |
76 unsigned char size; | |
77 custom_worker * aworker; | |
78 //worker_def * deflist = prog->deflist; | |
79 defchunk * defs = prog->defs; | |
80 defchunk * current = defs; | |
81 worker_def * deflist; | |
82 FILE * savefile; | |
83 savefile = fopen(filename, "wb"); | |
84 fwrite(&version, 4, 1, savefile); | |
85 num_defs = count_defs(defs); | |
86 fwrite(&(num_defs), 4, 1, savefile); | |
87 while(current) | |
88 { | |
89 deflist = current->deflist; | |
90 for(i = 0; i < current->num_defs; ++i) | |
91 { | |
92 size = strlen(deflist[i].name); | |
93 fwrite(&size, 1, 1, savefile); | |
94 fwrite(deflist[i].name, 1, size, savefile); | |
95 total_bytes += (int)size + 1; | |
96 } | |
97 current = current->next; | |
98 } | |
99 if(total_bytes % 4 != 0)// pad to a 4 byte boundary | |
100 fwrite(&zero, 1, 4-(total_bytes % 4), savefile); | |
101 current = defs; | |
102 while(current) | |
103 { | |
104 deflist = current->deflist; | |
105 for(i = 0; i < current->num_defs; ++i) | |
106 { | |
107 if(deflist[i].type & USER_FLAG) | |
108 { | |
109 fwrite(&i, sizeof(int), 1, savefile); | |
110 fwrite(&(deflist[i].num_inputs), sizeof(short), 1, savefile); | |
111 fwrite(&(deflist[i].num_outputs), sizeof(short), 1, savefile); | |
112 fwrite(&(deflist[i].type), sizeof(short), 1, savefile); | |
113 fwrite(deflist[i].input_types, sizeof(short), deflist[i].num_inputs, savefile); | |
114 fwrite(deflist[i].output_types, sizeof(short), deflist[i].num_outputs, savefile); | |
115 total_bytes += sizeof(int) + (sizeof(short) * (3+deflist[i].num_inputs+deflist[i].num_outputs)); | |
116 if(total_bytes % 4 != 0)// pad to a 4 byte boundary | |
117 fwrite(&zero, 1, 4-(total_bytes % 4), savefile); | |
118 if((deflist[i].type & TYPE_MASK) == WORKER_TYPE) | |
119 { | |
120 aworker = deflist[i].implement_func; | |
121 fwrite(&(aworker->num_workers), sizeof(int), 1, savefile); | |
122 fwrite(aworker->workerlist, sizeof(worker), aworker->num_workers, savefile); | |
123 fwrite(&(aworker->num_wires), sizeof(int), 1, savefile); | |
124 fwrite(aworker->wirelist, sizeof(wire), aworker->num_wires, savefile); | |
125 } | |
126 } | |
127 } | |
128 current = current->next; | |
129 } | |
130 i = -1; | |
131 fwrite(&i, sizeof(int), 1, savefile); | |
132 fclose(savefile); | |
133 } | |
134 | |
135 program * load_program(char * filename) | |
136 { | |
137 custom_worker * aworker; | |
138 int version; | |
139 int i,j; | |
140 int * def_lookup; | |
141 char name[256]; | |
142 int total_bytes; | |
143 int file_defs; | |
144 unsigned char name_size; | |
145 FILE * loadfile; | |
146 char * code; | |
147 int size; | |
148 program * prog; | |
149 loadfile = fopen(filename, "rb"); | |
150 if(!loadfile) | |
151 { | |
152 puts("Error: Could not open file"); | |
153 fflush(stdout); | |
154 return NULL; | |
155 } | |
156 if(!strcmp(strrchr(filename,'.')+1, "vis")) | |
157 { | |
158 //TODO: Fixme | |
159 /*fread(&version, 4, 1, loadfile); | |
160 if(version != 2) | |
161 { | |
162 puts("Error: Can't read files of this version."); | |
163 return NULL; | |
164 } | |
165 | |
166 fread(&file_defs, 4, 1, loadfile); | |
167 def_lookup = malloc(sizeof(int) * file_defs); | |
168 total_bytes = 0; | |
169 prog = new_program(file_defs, START_COMP_STORAGE); | |
170 initworkers(prog); | |
171 for(i = 0; i < file_defs; ++i) | |
172 { | |
173 fread(&name_size, 1, 1, loadfile); | |
174 fread(name, 1, name_size, loadfile); | |
175 name[name_size] = '\0'; | |
176 total_bytes += (int)name_size + 1; | |
177 for(j = 0; j < prog->num_defs; ++j) | |
178 { | |
179 if(!strcmp(name, prog->deflist[j].name)) | |
180 { | |
181 def_lookup[i] = j; | |
182 break; | |
183 } | |
184 } | |
185 if(j >= prog->num_defs) //couldn't find it in the list | |
186 { | |
187 def_lookup[i] = prog->num_defs; | |
188 prog->deflist[prog->num_defs].name = malloc(name_size+1); | |
189 strcpy(prog->deflist[prog->num_defs].name, name); | |
190 ++prog->num_defs; | |
191 } | |
192 } | |
193 if(total_bytes % 4 != 0)// pad to a 4 byte boundary | |
194 fread(&i, 1, 4-(total_bytes % 4), loadfile); | |
195 do | |
196 { | |
197 fread(&i, sizeof(int), 1, loadfile); | |
198 if(i >= 0) | |
199 { | |
200 i = def_lookup[i]; | |
201 fread(&(prog->deflist[i].num_inputs), sizeof(short), 1, loadfile); | |
202 fread(&(prog->deflist[i].num_outputs), sizeof(short), 1, loadfile); | |
203 fread(&(prog->deflist[i].type), sizeof(short), 1, loadfile); | |
204 prog->deflist[i].input_types = malloc(sizeof(short) * (prog->deflist[i].num_inputs + prog->deflist[i].num_outputs)); | |
205 prog->deflist[i].output_types = prog->deflist[i].input_types + prog->deflist[i].num_inputs; | |
206 fread(prog->deflist[i].input_types, sizeof(short), prog->deflist[i].num_inputs, loadfile); | |
207 fread(prog->deflist[i].output_types, sizeof(short), prog->deflist[i].num_outputs, loadfile); | |
208 total_bytes += sizeof(int) + (sizeof(short) * (3+prog->deflist[i].num_inputs+prog->deflist[i].num_outputs)); | |
209 if(total_bytes % 4 != 0)// pad to a 4 byte boundary | |
210 fread(&j, 1, 4-(total_bytes % 4), loadfile); | |
211 if((prog->deflist[i].type & TYPE_MASK) == WORKER_TYPE) | |
212 { | |
213 aworker = malloc(sizeof(custom_worker)); | |
214 prog->deflist[i].implement_func = aworker; | |
215 fread(&(aworker->num_workers), sizeof(int), 1, loadfile); | |
216 aworker->workerlist = malloc(sizeof(worker) * (aworker->num_workers + 512)); | |
217 fread(aworker->workerlist, sizeof(worker), aworker->num_workers, loadfile); | |
218 fread(&(aworker->num_wires), sizeof(int), 1, loadfile); | |
219 aworker->wirelist = malloc(sizeof(wire) * (aworker->num_wires + 1024)); | |
220 fread(aworker->wirelist, sizeof(wire), aworker->num_wires, loadfile); | |
221 aworker->workers_to_wires_down = malloc(sizeof(int) * (aworker->num_wires + 1024)); | |
222 aworker->workers_to_wires_up = malloc(sizeof(int) * (aworker->num_wires + 1024)); | |
223 for(j = 0; j < aworker->num_workers; ++j) | |
224 if(aworker->workerlist[j].type == 2) | |
225 aworker->workerlist[j].value_index = def_lookup[aworker->workerlist[j].value_index]; | |
226 } | |
227 } | |
228 }while(i >= 0);*/ | |
229 } | |
230 else | |
231 { | |
232 //Read text program | |
233 fflush(stdout); | |
234 fseek(loadfile, 0, SEEK_END); | |
235 size = ftell(loadfile); | |
236 fseek(loadfile, 0, SEEK_SET); | |
237 fflush(stdout); | |
238 code = malloc(size+1); | |
239 fread(code, 1, size, loadfile); | |
240 fclose(loadfile); | |
241 // num_defs = 0; | |
242 fflush(stdout); | |
243 prog = new_program(START_DEF_STORAGE, START_COMP_STORAGE); | |
244 initpredefworkers(prog); | |
245 fflush(stdout); | |
246 parse(code, size, prog); | |
247 free(code); | |
248 | |
249 // num_workers = deflist[0].num_workers; | |
250 // num_wires = deflist[0].num_wires; | |
251 } | |
252 return prog; | |
253 } | |
254 | |
255 /* | |
256 void load_program(char * filename) | |
257 { | |
258 worker * aworkerlist; | |
259 wire * awirelist; | |
260 FILE * loadfile; | |
261 char * code; | |
262 int size; | |
263 int def_num, version; | |
264 loadfile = fopen(filename, "rb"); | |
265 if(!loadfile) | |
266 { | |
267 puts("Error: Could not open file"); | |
268 return; | |
269 } | |
270 if(!strcmp(strrchr(filename,'.')+1, "vis")) | |
271 { | |
272 //Read binary program | |
273 fread(&version, 4, 1, loadfile); | |
274 if(version != 1) | |
275 { | |
276 puts("Error: Can't read files of this version."); | |
277 return; | |
278 } | |
279 //program * new_program = malloc(sizeof(program)); | |
280 // strcpy(program->filename, filename); | |
281 fread(&num_defs, 4, 1, loadfile); | |
282 //program->defs_storage = program->num_defs + 512; | |
283 //new_program->deflist = malloc(sizeof(worker_def) * (program->defs_storaage)); | |
284 fread(deflist, sizeof(worker_def), num_defs, loadfile); | |
285 fread(&def_num, 4, 1, loadfile); | |
286 while(def_num >= 0 && !feof(loadfile)) | |
287 { | |
288 deflist[def_num].workerlist = malloc((deflist[def_num].num_workers+512)*sizeof(worker)); | |
289 fread(deflist[def_num].workerlist, sizeof(worker), deflist[def_num].num_workers, loadfile); | |
290 deflist[def_num].wirelist = malloc((deflist[def_num].num_wires+1024)*sizeof(wire)); | |
291 fread(deflist[def_num].wirelist, sizeof(wire), deflist[def_num].num_wires, loadfile); | |
292 deflist[def_num].workers_to_wires_up = malloc((deflist[def_num].num_wires+1024)*sizeof(int)); | |
293 deflist[def_num].workers_to_wires_down = malloc((deflist[def_num].num_wires+1024)*sizeof(int)); | |
294 fread(&def_num, 4, 1, loadfile); | |
295 } | |
296 fclose(loadfile); | |
297 num_workers = deflist[0].num_workers; | |
298 num_wires = deflist[0].num_wires; | |
299 initpredefworkers(); | |
300 } | |
301 else | |
302 { | |
303 //Read text program | |
304 fseek(loadfile, 0, SEEK_END); | |
305 size = ftell(loadfile); | |
306 fseek(loadfile, 0, SEEK_SET); | |
307 code = malloc(size+1); | |
308 fread(code, 1, size, loadfile); | |
309 num_defs = 0; | |
310 initpredefworkers(); | |
311 parse(code, size); | |
312 num_workers = deflist[0].num_workers; | |
313 num_wires = deflist[0].num_wires; | |
314 } | |
315 }*/ | |
316 | |
317 |