|
0
|
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
|
