Mercurial > repos > rhope

comparison saveload.c @ 0:76568becd6d6

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
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