1 #ifdef _cplusplus
2 extern "C" {
3 #endif
4 #include "dynashadow.h"
5 #include "dynafunc.h"
6
7
8 # line 19 "dynashadow.dy"
write_dc_functions(DYNFILE * dfp,GenericMatrix * gm)9 void write_dc_functions(DYNFILE * dfp,GenericMatrix * gm)
10 {
11
12 write_shadow_dc_macros(dfp,gm);
13
14 alloc_small_func_GenericMatrix(dfp,gm);
15
16 make_small_calculate_func(dfp,gm);
17
18 one_shot_AlnRangeSet_func(dfp,gm);
19
20 write_AlnRangeSet_build_func(dfp,gm);
21
22 write_AlnRange_build_func(dfp,gm);
23
24
25 /* write_dc_PackAln_build_func(dfp,gm); */
26
27 write_hidden_read_func(dfp,gm);
28
29 write_hidden_max_func(dfp,gm);
30
31 write_special_strip_read_func(dfp,gm);
32
33 write_special_strip_max_func(dfp,gm);
34
35 write_matrix_to_special_max_func(dfp,gm);
36
37 write_hidden_calc_func(dfp,gm);
38
39 write_hidden_init_func(dfp,gm);
40
41 write_full_dc_func(dfp,gm);
42
43 write_single_dc_pass_func(dfp,gm);
44
45 write_push_dc_func(dfp,gm);
46
47 write_follow_on_dc_func(dfp,gm);
48
49 write_up_to_dc_func(dfp,gm);
50
51 write_init_dc_func(dfp,gm);
52
53 /* write_shadow_dc_alloc(dfp,gm); */
54
55 /* write_start_end_macros(dfp,gm); */
56
57 /* write_shadow_start_end_alloc(dfp,gm); */
58
59 /* write_start_end_build(dfp,gm);*/
60
61 write_start_end_find_end(dfp,gm);
62
63 optimised_shadow_GenericMatrix(dfp,gm);
64
65 /* heavy_optimised_shadow_GenericMatrix(dfp,gm);*/
66
67 write_start_end_init(dfp,gm);
68
69 }
70
71
72 /* Function: alloc_small_func_GenericMatrix(dfp,gm)
73 *
74 * Descrip: makes the allocate_Small_xxx function.
75 * This calls allocate_xxx_only function
76 * (made by /write_safe_alloc_function)
77 * and then allocates basematrix stuff as well.
78 *
79 *
80 * Arg: dfp [UNKN ] dynamite file pointer [DYNFILE *]
81 * Arg: gm [READ ] generic matrix structure [const GenericMatrix *]
82 *
83 */
84 # line 91 "dynashadow.dy"
alloc_small_func_GenericMatrix(DYNFILE * dfp,const GenericMatrix * gm)85 void alloc_small_func_GenericMatrix(DYNFILE * dfp,const GenericMatrix * gm)
86 {
87 char * arg_str;
88 char * chain_str;
89 FuncInfo * fi;
90 fi = FuncInfo_named_from_varstr(FI_CALLABLE,"allocate_Small_%s",gm->name);
91
92
93 /*** prepare function information ***/
94
95
96 add_line_to_Ftext(fi->ft,"This function allocates the %s structure",gm->name);
97 add_line_to_Ftext(fi->ft,"and the basematrix area for a small memory implementations");
98 add_line_to_Ftext(fi->ft,"It calls /allocate_%s_only",gm->name);
99
100 arg_str = get_argstr_GenericMatrix(gm);
101 add_args_GenericMatrix_FuncInfo(fi,gm);
102
103
104 start_function_FuncInfo(fi,dfp,"%s * allocate_Small_%s(%s)",gm->name,gm->name,arg_str);
105
106 /*** clean up ***/
107 ckfree(arg_str);
108
109
110
111 /*** into function body ***/
112
113
114 expr(dfp,"%s * out;",gm->name);
115
116 add_break(dfp);
117 chain_str = get_chainstr_GenericMatrix(gm);
118 expr(dfp,"out = allocate_%s_only(%s);",gm->name,chain_str);
119 ckfree(chain_str);
120
121 expr(dfp,"if( out == NULL )");
122 hang_expr(dfp,"return NULL;");
123
124 expr(dfp,"out->basematrix = BaseMatrix_alloc_matrix_and_specials(%d,(out->leni + %d) * %d,%d,out->lenj+%d)",(gm->window_j+1)*8,gm->window_i,gm->len,gm->spec_len*8,gm->window_j);
125
126 expr(dfp,"if(out == NULL) ");
127 startbrace(dfp);
128 expr(dfp,"warn(\"Small shadow matrix %s cannot be allocated, (asking for %d by %%d main cells)\",out->leni+%d);",gm->name,gm->window_j+1,gm->window_i+1);
129 expr(dfp,"free_%s(out)",gm->name);
130 expr(dfp,"return NULL;");
131 closebrace(dfp);
132
133 expr(dfp,"out->basematrix->type = BASEMATRIX_TYPE_SHADOW;");
134
135 expr(dfp,"return out");
136
137 close_function(dfp);
138
139 add_break(dfp);
140
141 }
142
143 /* Function: make_small_calculate_func(dfp,gm)
144 *
145 * Descrip: make the calculate function for
146 * small PackAln system
147 *
148 *
149 * Arg: dfp [UNKN ] Undocumented argument [DYNFILE *]
150 * Arg: gm [UNKN ] Undocumented argument [GenericMatrix *]
151 *
152 */
153 # line 153 "dynashadow.dy"
make_small_calculate_func(DYNFILE * dfp,GenericMatrix * gm)154 void make_small_calculate_func(DYNFILE * dfp,GenericMatrix * gm)
155 {
156 FuncInfo * fi;
157 register int s;
158 int ss;
159
160 /*** yawn. There are better ways to do this! ***/
161
162 for(s=0;s<gm->spec_len;s++)
163 if( gm->special[s]->is_end == TRUE )
164 break;
165
166 for(ss=0;ss<gm->spec_len;ss++)
167 if( gm->special[ss]->is_start == TRUE)
168 break;
169
170
171
172 fi = FuncInfo_named_from_varstr(FI_CALLABLE,"PackAln_calculate_Small_%s",gm->name);
173 add_line_to_Ftext(fi->ft,"This function calculates an alignment for %s structure in linear space",gm->name);
174 add_line_to_Ftext(fi->ft,"If you want only the start/end points");
175 add_line_to_Ftext(fi->ft,"use /AlnRangeSet_calculate_Small_%s ",gm->name);
176 add_break_to_Ftext(fi->ft);
177 add_line_to_Ftext(fi->ft,"The function basically");
178 add_line_to_Ftext(fi->ft," finds start/end points ");
179 add_line_to_Ftext(fi->ft," foreach start/end point ");
180 add_line_to_Ftext(fi->ft," calls /full_dc_%s ",gm->name);
181
182 start_function_FuncInfo(fi,dfp,"PackAln * PackAln_calculate_Small_%s(%s * mat,DPEnvelope * dpenv)",gm->name,gm->name);
183
184 /*** function body ***/
185
186 expr(dfp,"int endj;");
187 expr(dfp,"int score;");
188 expr(dfp,"PackAln * out;");
189 expr(dfp,"PackAlnUnit * pau;");
190 expr(dfp,"int starti;");
191 expr(dfp,"int startj;");
192 expr(dfp,"int startstate;");
193 expr(dfp,"int stopi;");
194 expr(dfp,"int stopj;");
195 expr(dfp,"int stopstate;");
196 expr(dfp,"int temp;");
197 expr(dfp,"int donej;");
198 add_end_comment(dfp,"This is for reporting, will be passed as a & arg in");
199 expr(dfp,"int totalj;");
200 add_end_comment(dfp,"This also is for reporting, but as is not changed, can be passed by value");
201
202 add_break(dfp);
203
204 expr(dfp,"if( mat->basematrix->type != BASEMATRIX_TYPE_SHADOW )");
205 startbrace(dfp);
206 warn_expr(dfp,"Could not calculate packaln small for %s due to wrong type of matrix",gm->name);
207 expr(dfp,"return NULL;");
208 closebrace(dfp);
209
210 add_break(dfp);
211
212 expr(dfp,"out = PackAln_alloc_std();");
213
214
215 add_break(dfp);
216
217 /** got to figure out start/end first **/
218
219 expr(dfp,"start_reporting(\"Find start end points: \");");
220 expr(dfp,"dc_optimised_start_end_calc_%s(mat,dpenv);",gm->name);
221
222 expr(dfp,"score = start_end_find_end_%s(mat,&endj);",gm->name);
223 expr(dfp,"out->score = score;");
224 expr(dfp,"stopstate = %s;\n",gm->special[s]->name);
225
226
227 /*** ok, life is different if we have special to specials. ***/
228
229 if( gm->specialtospecial == FALSE) {
230 add_block_comment(dfp,"No special to specials: one matrix alignment: simply remove and get");
231 expr(dfp,"starti = %s_DC_SHADOW_SPECIAL_SP(mat,0,endj,%s,0);",gm->name,gm->special[s]->name);
232 expr(dfp,"startj = %s_DC_SHADOW_SPECIAL_SP(mat,0,endj,%s,1);",gm->name,gm->special[s]->name);
233 expr(dfp,"startstate = %s_DC_SHADOW_SPECIAL_SP(mat,0,endj,%s,2);",gm->name,gm->special[s]->name);
234 expr(dfp,"stopi = %s_DC_SHADOW_SPECIAL_SP(mat,0,endj,%s,3);",gm->name,gm->special[s]->name);
235 expr(dfp,"stopj = %s_DC_SHADOW_SPECIAL_SP(mat,0,endj,%s,4);",gm->name,gm->special[s]->name);
236 expr(dfp,"stopstate = %s_DC_SHADOW_SPECIAL_SP(mat,0,endj,%s,5);",gm->name,gm->special[s]->name);
237 expr(dfp,"temp = %s_DC_SHADOW_SPECIAL_SP(mat,0,endj,%s,6);",gm->name,gm->special[s]->name);
238 expr(dfp,"log_full_error(REPORT,0,\"[%%d,%%d][%%d,%%d] Score %%d\",starti,startj,stopi,stopj,score);");
239 expr(dfp,"stop_reporting();");
240
241 expr(dfp,"start_reporting(\"Recovering alignment: \");");
242
243 add_break(dfp);
244 add_block_comment(dfp,"Figuring how much j we have to align for reporting purposes");
245 expr(dfp,"donej = 0;");
246 expr(dfp,"totalj = stopj - startj;");
247
248 expr(dfp,"full_dc_%s(mat,starti,startj,startstate,stopi,stopj,stopstate,out,&donej,totalj,dpenv);",gm->name);
249 add_break(dfp);
250 add_block_comment(dfp,"Although we have no specials, need to get start. Better to check than assume");
251 add_break(dfp);
252
253 expr(dfp,"max_matrix_to_special_%s(mat,starti,startj,startstate,temp,&stopi,&stopj,&stopstate,&temp,NULL);",gm->name);
254 expr(dfp,"if( stopi == %s_READ_OFF_ERROR || stopstate != %s )",gm->name,gm->special[ss]->name);
255 startbrace(dfp);
256 warn_expr(dfp,"Problem in reading off special state system, hit a non start state (or an internal error) in a single alignment mode");
257 expr(dfp,"invert_PackAln(out);");
258 expr(dfp,"recalculate_PackAln_%s(out,mat);",gm->name);
259 expr(dfp,"return out;");
260 closebrace(dfp);
261
262 add_break(dfp);
263
264 /*** Need to add PackUnit alloc etc... ***/
265 add_block_comment(dfp,"Ok. Put away start start...");
266 expr(dfp,"pau = PackAlnUnit_alloc()");
267 expr(dfp,"pau->i = stopi;");
268 expr(dfp,"pau->j = stopj;");
269 expr(dfp,"pau->state = stopstate + %d;",gm->len);
270 expr(dfp,"add_PackAln(out,pau)");
271
272 add_break(dfp);
273
274
275
276 expr(dfp,"log_full_error(REPORT,0,\"Alignment recovered\");");
277 expr(dfp,"stop_reporting();");
278 }
279 else {
280 add_block_comment(dfp,"Special to specials: have to eat up in strip and then drop back to full_dc for intervening bits");
281 expr(dfp,"log_full_error(REPORT,0,\"End at %%d Score %%d\",endj,score);");
282 expr(dfp,"stop_reporting();");
283
284 expr(dfp,"for(;;)");
285 startbrace_tag(dfp,"while there are more special bits to recover");
286 expr(dfp,"start_reporting(\"Special cell aln end %%d:\",endj)");
287 expr(dfp,"if( read_special_strip_%s(mat,0,endj,stopstate,&endj,&startstate,out) == FALSE )",gm->name);
288 startbrace(dfp);
289 warn_expr(dfp,"Problem in reading off special state system... going to return partial alignment");
290 expr(dfp,"break;");
291 closebrace(dfp);
292 expr(dfp,"if( startstate == %s || endj <= 0)",gm->special[ss]->name);
293 startbrace(dfp);
294 expr(dfp,"log_full_error(REPORT,0,\"Recovered complete alignment\");");
295 expr(dfp,"stop_reporting();");
296 expr(dfp,"break;");
297 closebrace(dfp);
298
299 add_break(dfp);
300 expr(dfp,"log_full_error(REPORT,0,\"Finished to %%d\",endj);");
301 expr(dfp,"stop_reporting();");
302 add_break(dfp);
303 add_block_comment(dfp,"Ok... have to eat up another piece of matrix <sigh>");
304 expr(dfp,"temp = startstate;");
305 expr(dfp,"starti = %s_DC_SHADOW_SPECIAL_SP(mat,0,endj,temp,0);",gm->name);
306 expr(dfp,"startj = %s_DC_SHADOW_SPECIAL_SP(mat,0,endj,temp,1);",gm->name);
307 expr(dfp,"startstate = %s_DC_SHADOW_SPECIAL_SP(mat,0,endj,temp,2);",gm->name);
308 expr(dfp,"stopi = %s_DC_SHADOW_SPECIAL_SP(mat,0,endj,temp,3);",gm->name);
309 expr(dfp,"stopj = %s_DC_SHADOW_SPECIAL_SP(mat,0,endj,temp,4);",gm->name);
310 expr(dfp,"stopstate = %s_DC_SHADOW_SPECIAL_SP(mat,0,endj,temp,5);",gm->name);
311 add_break(dfp);
312 add_block_comment(dfp,"Get out the score of this block. V. important!");
313 expr(dfp,"temp = %s_DC_SHADOW_SPECIAL_SP(mat,0,endj,temp,6);",gm->name);
314
315 expr(dfp,"totalj = stopj - startj;");
316 expr(dfp,"donej = 0;");
317 expr(dfp,"start_reporting(\"Main matrix aln [%%d,%%d]:\",startj,stopj)");
318 expr(dfp,"if(full_dc_%s(mat,starti,startj,startstate,stopi,stopj,stopstate,out,&donej,totalj,dpenv) == FALSE)",gm->name);
319 startbrace(dfp);
320 expr(dfp,"warn(\"In the alignment %s [%%d,%%d][%%d,%%d], got a problem. Please report bug ... giving you back a partial alignment\",starti,startj,stopi,stopj);",gm->name);
321 expr(dfp,"return out;");
322 closebrace(dfp);
323 add_break(dfp);
324
325 add_block_comment(dfp,"now have to figure out which special we came from... yikes");
326
327 expr(dfp,"max_matrix_to_special_%s(mat,starti,startj,startstate,temp,&stopi,&stopj,&stopstate,&temp,NULL);",gm->name);
328 expr(dfp,"if( stopi == %s_READ_OFF_ERROR)",gm->name);
329 startbrace(dfp);
330 expr(dfp,"warn(\"In %s read off ending at %%d ... got a bad matrix to special read off... returning partial alignment\",startj);",gm->name);
331 expr(dfp,"invert_PackAln(out);");
332 expr(dfp,"recalculate_PackAln_%s(out,mat);",gm->name);
333 expr(dfp,"return out;");
334 closebrace(dfp);
335
336 add_block_comment(dfp,"if at start, break, otherwise, back to eat another strip");
337
338
339
340
341 expr(dfp,"if( stopstate == %s)",gm->special[ss]->name);
342 startbrace(dfp);
343 expr(dfp,"log_full_error(REPORT,0,\"Recovered complete alignment \");");
344 expr(dfp,"stop_reporting()");
345 expr(dfp,"break;");
346 closebrace(dfp);
347 expr(dfp,"log_full_error(REPORT,0,\"Finished alignment to %%d \",startj);");
348 expr(dfp,"stop_reporting();");
349 expr(dfp,"endj = stopj;");
350 add_block_comment(dfp,"stopstate is correct as it is");
351 closebrace(dfp);
352
353 }
354
355 /*** clean up ***/
356
357 expr(dfp,"invert_PackAln(out);");
358 expr(dfp,"recalculate_PackAln_%s(out,mat);",gm->name);
359
360 expr(dfp,"return out;");
361 add_break(dfp);
362 close_function(dfp);
363 add_break(dfp);
364 }
365
366
367 /* Function: one_shot_AlnRangeSet_func(dfp,gm)
368 *
369 * Descrip: makes AlnRangeSet from small memory
370 *
371 *
372 * Arg: dfp [UNKN ] Undocumented argument [DYNFILE *]
373 * Arg: gm [UNKN ] Undocumented argument [GenericMatrix *]
374 *
375 */
376 # line 369 "dynashadow.dy"
one_shot_AlnRangeSet_func(DYNFILE * dfp,GenericMatrix * gm)377 void one_shot_AlnRangeSet_func(DYNFILE * dfp,GenericMatrix * gm)
378 {
379 FuncInfo * fi;
380
381 fi = FuncInfo_named_from_varstr(FI_CALLABLE,"AlnRangeSet_calculate_Small_%s",gm->name);
382 add_line_to_Ftext(fi->ft,"This function calculates an alignment for %s structure in linear space",gm->name);
383 add_line_to_Ftext(fi->ft,"If you want the full alignment, use /PackAln_calculate_Small_%s ",gm->name);
384 add_line_to_Ftext(fi->ft,"If you have already got the full alignment, but want the range set, use /AlnRangeSet_from_PackAln_%s",gm->name);
385 add_line_to_Ftext(fi->ft,"If you have got the small matrix but not the alignment, use /AlnRangeSet_from_%s ",gm->name);
386
387 start_function_FuncInfo(fi,dfp,"AlnRangeSet * AlnRangeSet_calculate_Small_%s(%s * mat)",gm->name,gm->name);
388
389
390 /*** function body ***/
391 expr(dfp,"AlnRangeSet * out;");
392
393
394 add_break(dfp);
395
396 expr(dfp,"start_reporting(\"Find start end points: \");");
397 expr(dfp,"dc_optimised_start_end_calc_%s(mat,NULL);",gm->name);
398 expr(dfp,"log_full_error(REPORT,0,\"Calculated\");");
399
400 add_break(dfp);
401
402 expr(dfp,"out = AlnRangeSet_from_%s(mat);",gm->name);
403
404 expr(dfp,"return out;");
405 close_function(dfp);
406 add_break(dfp);
407 }
408
409
410 # line 402 "dynashadow.dy"
write_AlnRangeSet_build_func(DYNFILE * dfp,GenericMatrix * gm)411 void write_AlnRangeSet_build_func(DYNFILE * dfp,GenericMatrix * gm)
412 {
413 register int s;
414 FuncInfo * fi;
415
416 fi = FuncInfo_named_from_varstr(FI_CALLABLE,"AlnRangeSet_from_%s",gm->name);
417 add_line_to_Ftext(fi->ft,"This function reads off a start/end structure");
418 add_line_to_Ftext(fi->ft,"for %s structure in linear space",gm->name);
419 add_line_to_Ftext(fi->ft,"If you want the full alignment use");
420 add_line_to_Ftext(fi->ft,"/PackAln_calculate_Small_%s ",gm->name);
421 add_line_to_Ftext(fi->ft,"If you have not calculated the matrix use");
422 add_line_to_Ftext(fi->ft,"/AlnRange_calculate_Small_%s",gm->name);
423
424
425
426 for(s=0;s<gm->spec_len;s++)
427 if( gm->special[s]->is_end == TRUE )
428 break;
429
430 start_function_FuncInfo(fi,dfp,"AlnRangeSet * AlnRangeSet_from_%s(%s * mat)",gm->name,gm->name);
431 expr(dfp,"AlnRangeSet * out;");
432 expr(dfp,"AlnRange * temp;");
433 expr(dfp,"int jpos;");
434 expr(dfp,"int state;");
435
436
437
438 add_break(dfp);
439 expr(dfp,"if( mat->basematrix->type != BASEMATRIX_TYPE_SHADOW)");
440 startbrace(dfp);
441 warn_expr(dfp,"Bad error! - non shadow matrix type in AlnRangeSet_from_%s",gm->name);
442 expr(dfp,"return NULL;");
443 closebrace(dfp);
444 add_break(dfp);
445
446 expr(dfp,"out = AlnRangeSet_alloc_std();");
447
448
449 add_block_comment(dfp,"Find the end position");
450
451 expr(dfp,"out->score = start_end_find_end_%s(mat,&jpos);",gm->name);
452 expr(dfp,"state = %s;",gm->special[s]->name);
453
454 add_break(dfp);
455
456 expr(dfp,"while( (temp = AlnRange_build_%s(mat,jpos,state,&jpos,&state)) != NULL)",gm->name);
457 hang_expr(dfp,"add_AlnRangeSet(out,temp);");
458
459 expr(dfp,"return out;");
460
461 close_function(dfp);
462 add_break(dfp);
463 }
464
465 # line 456 "dynashadow.dy"
write_AlnRange_build_func(DYNFILE * dfp,GenericMatrix * gm)466 void write_AlnRange_build_func(DYNFILE * dfp,GenericMatrix * gm)
467 {
468 register int s;
469 FuncInfo * fi;
470
471 fi = FuncInfo_named_from_varstr(FI_INTERNAL,"AlnRange_build_%s",gm->name);
472 add_line_to_Ftext(fi->ft,"This function calculates a single start/end set in linear space",gm->name);
473 add_line_to_Ftext(fi->ft,"Really a sub-routine for /AlnRangeSet_from_PackAln_%s",gm->name);
474
475
476
477
478 for(s=0;s<gm->spec_len;s++)
479 if( gm->special[s]->is_start == TRUE )
480 break;
481
482 if( s == gm->spec_len ) {
483 warn("Ok... problem... the special length has no start. Unhappy!");
484 }
485
486 start_function_FuncInfo(fi,dfp,"AlnRange * AlnRange_build_%s(%s * mat,int stopj,int stopspecstate,int * startj,int * startspecstate)",gm->name,gm->name);
487 expr(dfp,"AlnRange * out;");
488 expr(dfp,"int jpos;");
489 expr(dfp,"int state;");
490
491
492 add_break(dfp);
493 expr(dfp,"if( mat->basematrix->type != BASEMATRIX_TYPE_SHADOW)");
494 startbrace(dfp);
495 warn_expr(dfp,"Bad error! - non shadow matrix type in AlnRangeSet_from_%s",gm->name);
496 expr(dfp,"return NULL;");
497 closebrace(dfp);
498 add_break(dfp);
499
500 add_block_comment(dfp,"Assumme that we have specials (we should!). Read back along the specials till we have the finish point");
501
502 expr(dfp,"if( read_special_strip_%s(mat,0,stopj,stopspecstate,&jpos,&state,NULL) == FALSE)",gm->name);
503 startbrace(dfp);
504 expr(dfp,"warn(\"In AlnRanger_build_%s alignment ending at %%d, unable to read back specials. Will (evenutally) return a partial range set... BEWARE!\",stopj);",gm->name);
505 expr(dfp,"return NULL;");
506 closebrace(dfp);
507
508 expr(dfp,"if( state == %s || jpos <= 0)",gm->special[s]->name);
509 hang_expr(dfp,"return NULL;");
510
511
512 add_break(dfp);
513 expr(dfp,"out = AlnRange_alloc();");
514 add_break(dfp);
515 expr(dfp,"out->starti = %s_DC_SHADOW_SPECIAL_SP(mat,0,jpos,state,0);",gm->name);
516 expr(dfp,"out->startj = %s_DC_SHADOW_SPECIAL_SP(mat,0,jpos,state,1);",gm->name);
517 expr(dfp,"out->startstate = %s_DC_SHADOW_SPECIAL_SP(mat,0,jpos,state,2);",gm->name);
518 expr(dfp,"out->stopi = %s_DC_SHADOW_SPECIAL_SP(mat,0,jpos,state,3);",gm->name);
519 expr(dfp,"out->stopj = %s_DC_SHADOW_SPECIAL_SP(mat,0,jpos,state,4);",gm->name);
520 expr(dfp,"out->stopstate = %s_DC_SHADOW_SPECIAL_SP(mat,0,jpos,state,5);",gm->name);
521 expr(dfp,"out->startscore = %s_DC_SHADOW_SPECIAL_SP(mat,0,jpos,state,6);",gm->name);
522 expr(dfp,"out->stopscore = %s_DC_SHADOW_SPECIAL(mat,0,jpos,state);",gm->name);
523 add_break(dfp);
524 add_block_comment(dfp,"Now, we have to figure out where this state came from in the specials");
525 expr(dfp,"max_matrix_to_special_%s(mat,out->starti,out->startj,out->startstate,out->startscore,&jpos,startj,startspecstate,&state,NULL);",gm->name);
526 expr(dfp,"if( jpos == %s_READ_OFF_ERROR)",gm->name);
527 startbrace(dfp);
528 expr(dfp,"warn(\"In AlnRange_build_%s alignment ending at %%d, with aln range between %%d-%%d in j, unable to find source special, returning this range, but this could get tricky!\",stopj,out->startj,out->stopj);",gm->name);
529 expr(dfp,"return out;");
530 closebrace(dfp);
531
532 add_break(dfp);
533
534 add_block_comment(dfp,"Put in the correct score for startstate, from the special");
535 expr(dfp,"out->startscore = %s_DC_SHADOW_SPECIAL(mat,0,*startj,*startspecstate);",gm->name);
536
537 add_block_comment(dfp,"The correct j coords have been put into startj, startspecstate... so just return out");
538 expr(dfp,"return out;");
539
540 close_function(dfp);
541
542 add_break(dfp);
543 }
544
545 /* Function: write_dc_PackAln_build_func(dfp,gm)
546 *
547 * Descrip: This functions is now defunct
548 *
549 *
550 * Arg: dfp [UNKN ] Undocumented argument [DYNFILE *]
551 * Arg: gm [UNKN ] Undocumented argument [GenericMatrix *]
552 *
553 */
554 # line 538 "dynashadow.dy"
write_dc_PackAln_build_func(DYNFILE * dfp,GenericMatrix * gm)555 void write_dc_PackAln_build_func(DYNFILE * dfp,GenericMatrix * gm)
556 {
557 register int i;
558 register int s;
559 int ss;
560 char buffer[MAXLINE];
561
562 /*** yawn. There are better ways to do this! ***/
563
564 for(s=0;s<gm->spec_len;s++)
565 if( gm->special[s]->is_end == TRUE )
566 break;
567
568 for(ss=0;ss<gm->spec_len;ss++)
569 if( gm->special[ss]->is_start == TRUE)
570 break;
571
572 sprintf(buffer,"PackAln * PackAln_dc_build_%s(%s %s, %s %s ",gm->name,
573 gm->query->element_type,gm->query->name,
574 gm->target->element_type,gm->target->name);
575
576 for(i=0;i<gm->res_len;i++) {
577 strcat(buffer,", ");
578 strcat(buffer,gm->resource[i]->element_type);
579 if( gm->resource[i]->isfunc == TRUE ) { continue; }
580 strcat(buffer," ");
581 strcat(buffer,gm->resource[i]->name);
582 }
583
584
585
586 strcat(buffer,")");
587
588
589 start_function(dfp,buffer);
590 expr(dfp,"int endj;");
591 expr(dfp,"%s * mat;",gm->name);
592 expr(dfp,"int score;");
593 expr(dfp,"PackAln * out;");
594 expr(dfp,"int starti;");
595 expr(dfp,"int startj;");
596 expr(dfp,"int startstate;");
597 expr(dfp,"int stopi;");
598 expr(dfp,"int stopj;");
599 expr(dfp,"int stopstate;");
600 expr(dfp,"int temp;");
601 expr(dfp,"int donej;");
602 add_end_comment(dfp,"This is for reporting, will be passed as a & arg in");
603 expr(dfp,"int totalj;");
604 add_end_comment(dfp,"This also is for reporting, but as is not changed, can be passed by value");
605
606 add_break(dfp);
607
608 expr(dfp,"out = PackAln_alloc_std();");
609 expr(dfp,"mat = shadow_dc_alloc_%s(%s->%s,%s->%s);",gm->name,gm->query->name,gm->query_len,gm->target->name,gm->target_len);
610 expr(dfp,"if(mat == NULL)");
611 startbrace(dfp);
612 warn_expr(dfp,"Unable to build test dc linear matrix for %s, unable to allocate memory",gm->name);
613 expr(dfp,"return NULL;");
614 closebrace(dfp);
615
616 add_break(dfp);
617
618 expr(dfp,"mat->%s = %s;",gm->query->name,gm->query->name);
619 expr(dfp,"mat->%s = %s;",gm->target->name,gm->target->name);
620 for(i=0;i<gm->res_len;i++)
621 expr(dfp,"mat->%s = %s;",gm->resource[i]->name,gm->resource[i]->name);
622
623
624 add_break(dfp);
625
626 /** got to figure out start/end first **/
627
628 expr(dfp,"start_reporting(\"Find start end points: \");");
629 expr(dfp,"dc_optimised_start_end_calc_%s(mat);",gm->name);
630
631 expr(dfp,"score = start_end_find_end_%s(mat,&endj);",gm->name);
632 expr(dfp,"out->score = score;");
633 expr(dfp,"stopstate = %s;\n",gm->special[s]->name);
634
635
636 /*** ok, life is different if we have special to specials. ***/
637
638 if( gm->specialtospecial == FALSE) {
639 add_block_comment(dfp,"No special to specials: one matrix alignment: simply remove and get");
640 expr(dfp,"starti = %s_DC_SHADOW_SPECIAL_SP(mat,0,endj,%s,0);",gm->name,gm->special[s]->name);
641 expr(dfp,"startj = %s_DC_SHADOW_SPECIAL_SP(mat,0,endj,%s,1);",gm->name,gm->special[s]->name);
642 expr(dfp,"startstate = %s_DC_SHADOW_SPECIAL_SP(mat,0,endj,%s,2);",gm->name,gm->special[s]->name);
643 expr(dfp,"stopi = %s_DC_SHADOW_SPECIAL_SP(mat,0,endj,%s,3);",gm->name,gm->special[s]->name);
644 expr(dfp,"stopj = %s_DC_SHADOW_SPECIAL_SP(mat,0,endj,%s,4);",gm->name,gm->special[s]->name);
645 expr(dfp,"stopstate = %s_DC_SHADOW_SPECIAL_SP(mat,0,endj,%s,5);",gm->name,gm->special[s]->name);
646 expr(dfp,"log_full_error(REPORT,0,\"[%%d,%%d][%%d,%%d] Score %%d\",starti,startj,stopi,stopj,score);");
647 expr(dfp,"stop_reporting();");
648
649 expr(dfp,"start_reporting(\"Recovering alignment: \");");
650
651 add_break(dfp);
652 add_block_comment(dfp,"Figuring how much j we have to align for reporting purposes");
653 expr(dfp,"donej = 0;");
654 expr(dfp,"totalj = stopj - startj;");
655
656 expr(dfp,"full_dc_%s(mat,starti,startj,startstate,stopi,stopj,stopstate,out,&donej,totalj,dpenv);",gm->name);
657 expr(dfp,"log_full_error(REPORT,0,\"Alignment recovered\");");
658 expr(dfp,"stop_reporting();");
659 }
660 else {
661 add_block_comment(dfp,"Special to specials: have to eat up in strip and then drop back to full_dc for intervening bits");
662 expr(dfp,"log_full_error(REPORT,0,\"End at %%d Score %%d\",endj,score);");
663 expr(dfp,"stop_reporting();");
664
665 expr(dfp,"for(;;)");
666 startbrace_tag(dfp,"while there are more special bits to recover");
667 expr(dfp,"start_reporting(\"Special cell aln end %%d:\",endj)");
668 expr(dfp,"if( read_special_strip_%s(mat,0,endj,stopstate,&endj,&startstate,out) == FALSE )",gm->name);
669 startbrace(dfp);
670 warn_expr(dfp,"Problem in reading off special state system... going to return partial alignment");
671 expr(dfp,"break;");
672 closebrace(dfp);
673 expr(dfp,"if( startstate == %s || endj <= 0)",gm->special[ss]->name);
674 startbrace(dfp);
675 expr(dfp,"log_full_error(REPORT,0,\"Recovered complete alignment\");");
676 expr(dfp,"stop_reporting();");
677 expr(dfp,"break;");
678 closebrace(dfp);
679
680 add_break(dfp);
681 expr(dfp,"log_full_error(REPORT,0,\"Finished to %%d\",endj);");
682 expr(dfp,"stop_reporting();");
683 add_break(dfp);
684 add_block_comment(dfp,"Ok... have to eat up another piece of matrix <sigh>");
685 expr(dfp,"temp = startstate;");
686 expr(dfp,"starti = %s_DC_SHADOW_SPECIAL_SP(mat,0,endj,temp,0);",gm->name);
687 expr(dfp,"startj = %s_DC_SHADOW_SPECIAL_SP(mat,0,endj,temp,1);",gm->name);
688 expr(dfp,"startstate = %s_DC_SHADOW_SPECIAL_SP(mat,0,endj,temp,2);",gm->name);
689 expr(dfp,"stopi = %s_DC_SHADOW_SPECIAL_SP(mat,0,endj,temp,3);",gm->name);
690 expr(dfp,"stopj = %s_DC_SHADOW_SPECIAL_SP(mat,0,endj,temp,4);",gm->name);
691 expr(dfp,"stopstate = %s_DC_SHADOW_SPECIAL_SP(mat,0,endj,temp,5);",gm->name);
692 add_break(dfp);
693 add_block_comment(dfp,"Get out the score of this block. V. important!");
694 expr(dfp,"temp = %s_DC_SHADOW_SPECIAL_SP(mat,0,endj,temp,6);",gm->name);
695
696 expr(dfp,"totalj = stopj - startj;");
697 expr(dfp,"donej = 0;");
698 expr(dfp,"start_reporting(\"Main matrix aln [%%d,%%d]:\",startj,stopj)");
699 expr(dfp,"if(full_dc_%s(mat,starti,startj,startstate,stopi,stopj,stopstate,out,&donej,totalj,dpenv) == FALSE)",gm->name);
700 startbrace(dfp);
701 expr(dfp,"warn(\"In the alignment %s [%%d,%%d][%%d,%%d], got a problem. Please report bug ... giving you back a partial alignment\",starti,startj,stopi,stopj);",gm->name);
702 expr(dfp,"return out;");
703 closebrace(dfp);
704 add_break(dfp);
705
706 add_block_comment(dfp,"now have to figure out which special we came from... yikes");
707
708 expr(dfp,"max_matrix_to_special_%s(mat,starti,startj,startstate,temp,&stopi,&stopj,&stopstate,&temp,NULL);",gm->name);
709 expr(dfp,"if( stopi == %s_READ_OFF_ERROR);",gm->name);
710 startbrace(dfp);
711 expr(dfp,"warn(\"In %s read off ending at %%d ... got a bad matrix to special read off... returning partial alignment\",startj);",gm->name);
712 expr(dfp,"invert_PackAln(out);");
713 expr(dfp,"return out;");
714 closebrace(dfp);
715
716 add_block_comment(dfp,"if at start, break, otherwise, back to eat another strip");
717
718
719
720
721 expr(dfp,"if( stopstate == %s)",gm->special[ss]->name);
722 startbrace(dfp);
723 expr(dfp,"log_full_error(REPORT,0,\"Recovered complete alignment \");");
724 expr(dfp,"stop_reporting()");
725 expr(dfp,"break;");
726 closebrace(dfp);
727 expr(dfp,"log_full_error(REPORT,0,\"Finished alignment to %%d \",startj);");
728 expr(dfp,"stop_reporting();");
729 expr(dfp,"endj = stopj;");
730 add_block_comment(dfp,"stopstate is correct as it is");
731 closebrace(dfp);
732
733 }
734
735
736
737
738
739
740 expr(dfp,"invert_PackAln(out);");
741
742 expr(dfp,"free_%s(mat);",gm->name);
743 expr(dfp,"return out;");
744 add_break(dfp);
745 close_function(dfp);
746 add_break(dfp);
747 }
748
749 /* Function: write_full_dc_func(dfp,gm)
750 *
751 * Descrip: writes the main divide and conquor routine
752 *
753 *
754 * Arg: dfp [UNKN ] Undocumented argument [DYNFILE *]
755 * Arg: gm [UNKN ] Undocumented argument [GenericMatrix *]
756 *
757 */
758 # line 735 "dynashadow.dy"
write_full_dc_func(DYNFILE * dfp,GenericMatrix * gm)759 void write_full_dc_func(DYNFILE * dfp,GenericMatrix * gm)
760 {
761 ArgInfo * ai;
762 FuncInfo * fi;
763
764 fi = FuncInfo_named_from_varstr(FI_INTERNAL,"full_dc_%s",gm->name);
765 add_line_to_Ftext(fi->ft,"The main divide-and-conquor routine. Basically, call /PackAln_calculate_small_%s",gm->name);
766 add_line_to_Ftext(fi->ft,"Not this function, which is pretty hard core. ");
767 add_line_to_Ftext(fi->ft,"Function is given start/end points (in main matrix) for alignment");
768 add_line_to_Ftext(fi->ft,"It does some checks, decides whether start/end in j is small enough for explicit calc");
769 add_line_to_Ftext(fi->ft," - if yes, calculates it, reads off into PackAln (out), adds the j distance to donej and returns TRUE");
770 add_line_to_Ftext(fi->ft," - if no, uses /do_dc_single_pass_%s to get mid-point",gm->name);
771 add_line_to_Ftext(fi->ft," saves midpoint, and calls itself to do right portion then left portion");
772 add_line_to_Ftext(fi->ft,"right then left ensures PackAln is added the 'right' way, ie, back-to-front");
773 add_line_to_Ftext(fi->ft,"returns FALSE on any error, with a warning");
774
775 ai = ArgInfo_in_FuncInfo_from_varstr(fi,"mat");
776 ai->desc=stringalloc("Matrix with small memory implementation");
777
778 ai = ArgInfo_in_FuncInfo_from_varstr(fi,"starti");
779 ai->desc=stringalloc("Start position in i");
780 ai = ArgInfo_in_FuncInfo_from_varstr(fi,"startj");
781 ai->desc=stringalloc("Start position in j");
782 ai = ArgInfo_in_FuncInfo_from_varstr(fi,"startstate");
783 ai->desc=stringalloc("Start position state number");
784
785 ai = ArgInfo_in_FuncInfo_from_varstr(fi,"stopi");
786 ai->desc=stringalloc("Stop position in i");
787 ai = ArgInfo_in_FuncInfo_from_varstr(fi,"stopj");
788 ai->desc=stringalloc("Stop position in j");
789 ai = ArgInfo_in_FuncInfo_from_varstr(fi,"stopstate");
790 ai->desc=stringalloc("Stop position state number");
791
792 ai = ArgInfo_in_FuncInfo_from_varstr(fi,"out");
793 ai->desc=stringalloc("PackAln structure to put alignment into");
794
795 ai = ArgInfo_in_FuncInfo_from_varstr(fi,"donej");
796 ai->desc=stringalloc("pointer to a number with the amount of alignment done");
797
798 ai = ArgInfo_in_FuncInfo_from_varstr(fi,"totalj");
799 ai->desc=stringalloc("total amount of alignment to do (in j coordinates)");
800
801
802 start_function_FuncInfo(fi,dfp,"boolean full_dc_%s(%s * mat,int starti,int startj,int startstate,int stopi,int stopj,int stopstate,PackAln * out,int * donej,int totalj,DPEnvelope * dpenv)",gm->name,gm->name);
803 expr(dfp,"int lstarti;");
804 expr(dfp,"int lstartj;");
805 expr(dfp,"int lstate;");
806
807
808 add_break(dfp);
809 expr(dfp,"if( mat->basematrix->type != BASEMATRIX_TYPE_SHADOW)");
810 startbrace(dfp);
811 warn_expr(dfp,"*Very* bad error! - non shadow matrix type in full_dc_%s",gm->name);
812 expr(dfp,"return FALSE;");
813 closebrace(dfp);
814 add_break(dfp);
815
816 expr(dfp,"if( starti == -1 || startj == -1 || startstate == -1 || stopi == -1 || stopstate == -1)");
817 startbrace(dfp);
818 expr(dfp,"warn(\"In full dc program, passed bad indices, indices passed were %%d:%%d[%%d] to %%d:%%d[%%d]\\n\",starti,startj,startstate,stopi,stopj,stopstate);");
819 expr(dfp,"return FALSE");
820 closebrace(dfp);
821
822 add_break(dfp);
823
824 /***
825 expr(dfp,"fprintf(stdout,\"Calling with %%d,%%d[%%d] to %%d,%%d[%%d]\\n\",starti,startj,startstate,stopi,stopj,stopstate);");
826 ***/
827
828 expr(dfp,"if( stopj - startj < %d)",gm->window_j*5);
829 startbrace(dfp);
830 /**
831 expr(dfp,"fprintf(stdout,\"Got to stopping point at %%d:%%d %%d:%%d\\n\",starti,startj,stopi,stopj);");
832 **/
833 expr(dfp,"log_full_error(REPORT,0,\"[%%d,%%d][%%d,%%d] Explicit read off\",starti,startj,stopi,stopj);");
834
835 add_end_comment(dfp,"Build hidden explicit matrix");
836
837 expr(dfp,"calculate_hidden_%s(mat,starti,startj,startstate,stopi,stopj,stopstate,dpenv)",gm->name);
838 expr(dfp,"*donej += (stopj - startj);");
839 add_end_comment(dfp,"Now read it off into out");
840 expr(dfp,"if( read_hidden_%s(mat,starti,startj,startstate,stopi,stopj,stopstate,out) == FALSE)",gm->name);
841 startbrace(dfp);
842 expr(dfp,"warn(\"In full dc, at %%d:%%d,%%d:%%d got a bad hidden explicit read off... \",starti,startj,stopi,stopj);");
843 expr(dfp,"return FALSE");
844 closebrace(dfp);
845 expr(dfp,"return TRUE;");
846 closebrace(dfp);
847 add_break(dfp);
848
849 add_end_comment(dfp,"In actual divide and conquor");
850
851
852 expr(dfp,"if( do_dc_single_pass_%s(mat,starti,startj,startstate,stopi,stopj,stopstate,dpenv,(int)(*donej*100)/totalj) == FALSE)",gm->name);
853 startbrace(dfp);
854 expr(dfp,"warn(\"In divide and conquor for %s, at bound %%d:%%d to %%d:%%d, unable to calculate midpoint. Problem!\",starti,startj,stopi,stopj);",gm->name);
855 expr(dfp,"return FALSE;");
856 closebrace(dfp);
857
858 /***
859 expr(dfp,"for(i=0;i<6;i++)");
860 startbrace(dfp);
861 expr(dfp,"printf(\"[%%d:%%d,%%d:%%d] %%d: %%d\\n\",starti,startj,stopi,stopj,i,%s_DC_SHADOW_MATRIX_SP(mat,stopi,stopj,stopstate,i));",gm->name);
862 closebrace(dfp);
863 ***/
864
865 add_break(dfp);
866
867 add_end_comment(dfp,"Ok... now we have to call on each side of the matrix");
868 add_end_comment(dfp,"We have to retrieve left hand side positions, as they will be vapped by the time we call LHS");
869 expr(dfp,"lstarti= %s_DC_SHADOW_MATRIX_SP(mat,stopi,stopj,stopstate,0)",gm->name);
870 expr(dfp,"lstartj= %s_DC_SHADOW_MATRIX_SP(mat,stopi,stopj,stopstate,1)",gm->name);
871 expr(dfp,"lstate = %s_DC_SHADOW_MATRIX_SP(mat,stopi,stopj,stopstate,2)",gm->name);
872
873 add_break(dfp);
874 add_end_comment(dfp,"Call on right hand side: this lets us do the correct read off");
875 expr(dfp,"if( full_dc_%s(mat,%s_DC_SHADOW_MATRIX_SP(mat,stopi,stopj,stopstate,3),%s_DC_SHADOW_MATRIX_SP(mat,stopi,stopj,stopstate,4),%s_DC_SHADOW_MATRIX_SP(mat,stopi,stopj,stopstate,5),stopi,stopj,stopstate,out,donej,totalj,dpenv) == FALSE)",gm->name,gm->name,gm->name,gm->name);
876 startbrace(dfp);
877 add_end_comment(dfp,"Warning already issued, simply chained back up to top");
878 expr(dfp,"return FALSE");
879 closebrace(dfp);
880
881 add_end_comment(dfp,"Call on left hand side");
882
883 expr(dfp,"if( full_dc_%s(mat,starti,startj,startstate,lstarti,lstartj,lstate,out,donej,totalj,dpenv) == FALSE)",gm->name);
884 startbrace(dfp);
885 add_end_comment(dfp,"Warning already issued, simply chained back up to top");
886 expr(dfp,"return FALSE");
887 closebrace(dfp);
888
889 add_break(dfp);
890
891 expr(dfp,"return TRUE");
892
893 close_function(dfp);
894 add_break(dfp);
895 }
896
897 # line 873 "dynashadow.dy"
write_single_dc_pass_func(DYNFILE * dfp,GenericMatrix * gm)898 void write_single_dc_pass_func(DYNFILE * dfp,GenericMatrix * gm)
899 {
900 FuncInfo * fi;
901 fi = FuncInfo_named_from_varstr(FI_INTERNAL,"do_dc_single_pass_%s",gm->name);
902
903 start_function_FuncInfo(fi,dfp,"boolean do_dc_single_pass_%s(%s * mat,int starti,int startj,int startstate,int stopi,int stopj,int stopstate,DPEnvelope * dpenv,int perc_done)",gm->name,gm->name);
904 expr(dfp,"int halfj;");
905
906
907 expr(dfp,"halfj = startj + ((stopj - startj)/2);");
908 /**
909 expr(dfp,"fprintf(stdout,\"Pass with %%d,%%d[%%d] %%d,%%d[%%d] halfj %%d\\n\",starti,startj,startstate,stopi,stopj,stopstate,halfj);");
910 **/
911
912 add_break(dfp);
913
914
915 expr(dfp,"init_dc_%s(mat);",gm->name);
916 add_break(dfp);
917 expr(dfp,"%s_DC_SHADOW_MATRIX(mat,starti,startj,startstate) = 0;",gm->name);
918 expr(dfp,"run_up_dc_%s(mat,starti,stopi,startj,halfj-1,dpenv,perc_done)",gm->name);
919 expr(dfp,"push_dc_at_merge_%s(mat,starti,stopi,halfj,&halfj,dpenv)",gm->name);
920 expr(dfp,"follow_on_dc_%s(mat,starti,stopi,halfj,stopj,dpenv,perc_done)",gm->name);
921 expr(dfp,"return TRUE;");
922 close_function(dfp);
923 add_break(dfp);
924 }
925
926
927 # line 902 "dynashadow.dy"
write_push_dc_func(DYNFILE * dfp,GenericMatrix * gm)928 void write_push_dc_func(DYNFILE * dfp,GenericMatrix * gm)
929 {
930 int s;
931 int r;
932 int i;
933 FuncInfo * fi;
934 fi = FuncInfo_named_from_varstr(FI_INTERNAL,"push_dc_at_merge_%s",gm->name);
935
936 start_function_FuncInfo(fi,dfp,"void push_dc_at_merge_%s(%s * mat,int starti,int stopi,int startj,int * stopj,DPEnvelope * dpenv)",gm->name,gm->name);
937 expr(dfp,"register int i;");
938 expr(dfp,"register int j;");
939 expr(dfp,"register int k;");
940 expr(dfp,"register int count;");
941 expr(dfp,"register int mergej;");
942 add_end_comment(dfp,"Sources below this j will be stamped by triples");
943 expr(dfp,"register int score;");
944 expr(dfp,"register int temp;");
945
946 add_break(dfp);
947
948 expr(dfp,"mergej = startj -1");
949 expr(dfp,"for(count=0,j=startj;count<%d;count++,j++)",gm->window_j);
950 startbrace(dfp);
951 expr(dfp,"for(i=starti;i<=stopi;i++)");
952 startbrace(dfp);
953
954
955 expr(dfp,"if( dpenv != NULL && is_in_DPEnvelope(dpenv,i,j) == FALSE )");
956 startbrace_tag(dfp,"Is not in envelope");
957
958 for(i=0;i<gm->len;i++) {
959 expr(dfp,"%s_DC_SHADOW_MATRIX(mat,i,j,%s) = NEGI",gm->name,gm->state[i]->name);
960 expr(dfp,"%s_DC_SHADOW_MATRIX_SP(mat,i,j,%s,0) = (-100);",gm->name,gm->state[i]->name);
961 expr(dfp,"%s_DC_SHADOW_MATRIX_SP(mat,i,j,%s,1) = (-100);",gm->name,gm->state[i]->name);
962 }
963 expr(dfp,"continue;");
964 closebrace(dfp);
965
966
967 for(s=0;s<gm->len;s++) {
968 auto CellState * state;
969 state = gm->state[s];
970
971 add_break(dfp);
972 add_block_comment(dfp,"For state %s, pushing when j - offj <= mergej",state->name);
973
974 expr(dfp,"score = %s_DC_SHADOW_%s(mat,i-%d,j-%d,%s) + %s",gm->name,state->source[0]->isspecial == TRUE ? "SPECIAL" : "MATRIX",
975 state->source[0]->offi,state->source[0]->offj,state->source[0]->state_source,state->source[0]->calc_expr);
976 expr(dfp,"if( j - %d <= mergej)",state->source[0]->offj);
977 startbrace(dfp);
978 expr(dfp,"%s_DC_SHADOW_MATRIX_SP(mat,i,j,%s,0) = i-%d;",gm->name,state->name,state->source[0]->offi);
979 expr(dfp,"%s_DC_SHADOW_MATRIX_SP(mat,i,j,%s,1) = j-%d;",gm->name,state->name,state->source[0]->offj);
980 expr(dfp,"%s_DC_SHADOW_MATRIX_SP(mat,i,j,%s,2) = %s;",gm->name,state->name,state->source[0]->state_source);
981 expr(dfp,"%s_DC_SHADOW_MATRIX_SP(mat,i,j,%s,3) = i;",gm->name,state->name,state->source[0]->offi);
982 expr(dfp,"%s_DC_SHADOW_MATRIX_SP(mat,i,j,%s,4) = j;",gm->name,state->name,state->source[0]->offj);
983 expr(dfp,"%s_DC_SHADOW_MATRIX_SP(mat,i,j,%s,5) = %s;",gm->name,state->name,state->name);
984 closebrace(dfp);
985 expr(dfp,"else");
986 startbrace(dfp);
987 expr(dfp,"for(k=0;k<7;k++)");
988 hang_expr(dfp,"%s_DC_SHADOW_MATRIX_SP(mat,i,j,%s,k) = %s_DC_SHADOW_%s_SP(mat,i - %d,j - %d,%s,k);",gm->name,
989 state->name,gm->name,state->source[0]->isspecial == TRUE ? "SPECIAL" : "MATRIX",
990 state->source[0]->offi,state->source[0]->offj,state->source[0]->state_source);
991 closebrace(dfp);
992
993
994
995 for(r=1;r<state->len;r++) {
996 if( state->source[r]->isspecial == TRUE )
997 continue;
998
999 add_break(dfp);
1000
1001 expr(dfp,"temp = %s_DC_SHADOW_%s(mat,i-%d,j-%d,%s) + %s",gm->name,state->source[r]->isspecial == TRUE ? "SPECIAL" : "MATRIX",
1002 state->source[r]->offi,state->source[r]->offj,state->source[r]->state_source,state->source[r]->calc_expr);
1003
1004 expr(dfp,"if( temp > score)");
1005 startbrace(dfp);
1006 expr(dfp,"score = temp;");
1007 add_break(dfp);
1008 expr(dfp,"if( j - %d <= mergej)",state->source[r]->offj);
1009 startbrace(dfp);
1010
1011 expr(dfp,"%s_DC_SHADOW_MATRIX_SP(mat,i,j,%s,0) = i-%d;",gm->name,state->name,state->source[r]->offi);
1012 expr(dfp,"%s_DC_SHADOW_MATRIX_SP(mat,i,j,%s,1) = j-%d;",gm->name,state->name,state->source[r]->offj);
1013 expr(dfp,"%s_DC_SHADOW_MATRIX_SP(mat,i,j,%s,2) = %s;",gm->name,state->name,state->source[r]->state_source);
1014 expr(dfp,"%s_DC_SHADOW_MATRIX_SP(mat,i,j,%s,3) = i;",gm->name,state->name,state->source[r]->offi);
1015 expr(dfp,"%s_DC_SHADOW_MATRIX_SP(mat,i,j,%s,4) = j;",gm->name,state->name,state->source[r]->offj);
1016 expr(dfp,"%s_DC_SHADOW_MATRIX_SP(mat,i,j,%s,5) = %s;",gm->name,state->name,state->name);
1017 closebrace(dfp);
1018 expr(dfp,"else");
1019 startbrace(dfp);
1020 expr(dfp,"for(k=0;k<7;k++)");
1021 hang_expr(dfp,"%s_DC_SHADOW_MATRIX_SP(mat,i,j,%s,k) = %s_DC_SHADOW_%s_SP(mat,i - %d,j - %d,%s,k);",gm->name,
1022 state->name,gm->name,state->source[r]->isspecial == TRUE ? "SPECIAL" : "MATRIX",
1023 state->source[r]->offi,state->source[r]->offj,state->source[r]->state_source);
1024 closebrace(dfp);
1025 closebrace(dfp);
1026 }
1027
1028 /** ok, put in source independent score (if any!) **/
1029
1030 add_block_comment(dfp,"Add any movement independant score");
1031
1032 if( state->calc_expr != NULL )
1033 expr(dfp,"score += %s",state->calc_expr);
1034
1035 expr(dfp,"%s_DC_SHADOW_MATRIX(mat,i,j,%s) = score",gm->name,state->name);
1036
1037
1038 /*** I don't need to look at specials ***/
1039
1040 /***
1041
1042 for(r=0;r<gm->spec_len;r++) {
1043 auto CellState * spec;
1044 spec = gm->special[r];
1045
1046 for(t=0;t<spec->len;t++) {
1047 if( strcmp(spec->source[t]->state_source,state->name) == 0 ) {
1048
1049 add_break(dfp);
1050 add_block_comment(dfp,"state %s is a source for special %s... better update",state->name,spec->name);
1051
1052 expr(dfp,"temp = score + (%s) + (%s) ",spec->source[t]->calc_expr,spec->calc_expr == NULL ? "0" : spec->calc_expr);
1053 expr(dfp,"if( temp > %s_DC_SHADOW_SPECIAL(mat,i,j,%s) )",gm->name,spec->name);
1054 startbrace(dfp);
1055 expr(dfp,"%s_DC_SHADOW_SPECIAL(mat,i,j,%s) = temp",gm->name,spec->name);
1056 expr(dfp,"for(k=0;k<7;k++)");
1057 hang_expr(dfp,"%s_DC_SHADOW_SPECIAL_SP(mat,i,j,%s,k) = %s_DC_SHADOW_MATRIX_SP(mat,i,j,%s,k);",gm->name,
1058 spec->name,gm->name,state->name);
1059 closebrace(dfp);
1060 } end of if this is a special source
1061 }end of t over all sources for this special
1062 }end of r over all specials
1063
1064 ***/
1065
1066
1067
1068 add_block_comment(dfp,"Finished with state %s",state->name);
1069
1070 } /* end of s over state */
1071
1072 closebrace(dfp); /* close i */
1073 closebrace(dfp); /* close j */
1074
1075 add_block_comment(dfp,"Put back j into * stop j so that calling function gets it correct");
1076
1077 expr(dfp,"if( stopj == NULL)");
1078 hang_expr(dfp,"warn(\"Bad news... NULL stopj pointer in push dc function. This means that calling function does not know how many cells I have done!\");");
1079 expr(dfp,"else");
1080 hang_expr(dfp,"*stopj = j");
1081
1082 add_break(dfp);
1083
1084 expr(dfp,"return");
1085 close_function(dfp);
1086 add_break(dfp);
1087 }
1088
1089 # line 1063 "dynashadow.dy"
write_init_dc_func(DYNFILE * dfp,GenericMatrix * gm)1090 void write_init_dc_func(DYNFILE * dfp,GenericMatrix * gm)
1091 {
1092 int s;
1093 FuncInfo * fi;
1094 fi = FuncInfo_named_from_varstr(FI_INTERNAL,"init_dc_%s",gm->name);
1095
1096 start_function_FuncInfo(fi,dfp,"void init_dc_%s(%s * mat)",gm->name,gm->name);
1097 expr(dfp,"register int i;");
1098 expr(dfp,"register int j;");
1099 expr(dfp,"register int k;");
1100
1101 add_break(dfp);
1102 expr(dfp,"for(j=0;j<%d;j++)",gm->window_j+2);
1103 startbrace(dfp);
1104 expr(dfp,"for(i=(-%d);i<mat->%s->%s;i++)",gm->window_i,gm->query->name,gm->query_len);
1105 startbrace(dfp);
1106 for(s=0;s<gm->len;s++) {
1107 expr(dfp,"%s_DC_SHADOW_MATRIX(mat,i,j,%s) = %s;",gm->name,gm->state[s]->name,gm->state[s]->def_score);
1108 }
1109 expr(dfp,"for(k=0;k<7;k++)");
1110 startbrace(dfp);
1111 for(s=0;s<gm->len;s++) {
1112 expr(dfp,"%s_DC_SHADOW_MATRIX_SP(mat,i,j,%s,k) = (-1);",gm->name,gm->state[s]->name);
1113 }
1114 closebrace(dfp);
1115 closebrace(dfp);
1116 closebrace(dfp);
1117
1118 add_break(dfp);
1119
1120 expr(dfp,"return");
1121 close_function(dfp);
1122 add_break(dfp);
1123 }
1124
1125
1126 # line 1099 "dynashadow.dy"
write_up_to_dc_func(DYNFILE * dfp,GenericMatrix * gm)1127 void write_up_to_dc_func(DYNFILE * dfp,GenericMatrix * gm)
1128 {
1129 FuncInfo * fi;
1130 int i;
1131 fi = FuncInfo_named_from_varstr(FI_INTERNAL,"run_up_dc_%s",gm->name);
1132
1133 start_function_FuncInfo(fi,dfp,"void run_up_dc_%s(%s * mat,int starti,int stopi,int startj,int stopj,DPEnvelope * dpenv,int perc_done)",gm->name,gm->name);
1134 expr(dfp,"register int i;");
1135 expr(dfp,"register int j;");
1136 expr(dfp,"register int score;");
1137 expr(dfp,"register int temp;");
1138 expr(dfp,"long int total;");
1139 expr(dfp,"long int num;");
1140
1141 add_break(dfp);
1142 expr(dfp,"total = (stopi - starti+1) * (stopj - startj+1);");
1143 expr(dfp,"if( total <= 0 )");
1144 hang_expr(dfp,"total = 1;");
1145 expr(dfp,"num = 0");
1146 add_break(dfp);
1147
1148
1149 expr(dfp,"for(j=startj;j<=stopj;j++)");
1150 startbrace_tag(dfp,"for each valid j column");
1151 expr(dfp,"for(i=starti;i<=stopi;i++)");
1152 startbrace_tag(dfp,"this is strip");
1153 expr(dfp,"if( j == startj && i == starti)");
1154 hang_expr(dfp,"continue;");
1155 expr(dfp,"num++;");
1156
1157 expr(dfp,"if( dpenv != NULL && is_in_DPEnvelope(dpenv,i,j) == FALSE )");
1158 startbrace_tag(dfp,"Is not in envelope");
1159
1160 for(i=0;i<gm->len;i++) {
1161 expr(dfp,"%s_DC_SHADOW_MATRIX(mat,i,j,%s) = NEGI",gm->name,gm->state[i]->name);
1162 }
1163 expr(dfp,"continue;");
1164 closebrace(dfp);
1165
1166 expr(dfp,"if( num %% 1000 == 0 )");
1167 hang_expr(dfp,"log_full_error(REPORT,0,\"[%%d%%%%%%%% done]Before mid-j %%5d Cells done %%d%%%%%%%%\",perc_done,stopj,(num*100)/total)");
1168
1169 /** don't use specials, as we are guarenteed an alignment outisde them **/
1170
1171 write_score_block(dfp,gm,"DC_SHADOW_MATRIX","mat","DC_SHADOW_SPECIAL",FALSE);
1172 closebrace(dfp);
1173 closebrace(dfp);
1174
1175 add_break(dfp);
1176
1177 close_function(dfp);
1178
1179 }
1180
1181
1182 # line 1154 "dynashadow.dy"
write_follow_on_dc_func(DYNFILE * dfp,GenericMatrix * gm)1183 void write_follow_on_dc_func(DYNFILE * dfp,GenericMatrix * gm)
1184 {
1185 int i;
1186 FuncInfo * fi;
1187 fi = FuncInfo_named_from_varstr(FI_INTERNAL,"follow_on_dc_%s",gm->name);
1188
1189 start_function_FuncInfo(fi,dfp,"void follow_on_dc_%s(%s * mat,int starti,int stopi,int startj,int stopj,DPEnvelope * dpenv,int perc_done)",gm->name,gm->name);
1190 expr(dfp,"int i;");
1191 expr(dfp,"int j;");
1192 expr(dfp,"int k;");
1193 expr(dfp,"int score;");
1194 expr(dfp,"int temp;");
1195 expr(dfp,"int localshadow[7];");
1196 expr(dfp,"long int total;");
1197 expr(dfp,"long int num;");
1198
1199 add_break(dfp);
1200 expr(dfp,"total = (stopi - starti+1) * (stopj - startj+1);");
1201 expr(dfp,"num = 0");
1202 add_break(dfp);
1203
1204 expr(dfp,"for(j=startj;j<=stopj;j++)");
1205 startbrace_tag(dfp,"for each valid j column");
1206 expr(dfp,"for(i=starti;i<=stopi;i++)");
1207 startbrace_tag(dfp,"this is strip");
1208 expr(dfp,"num++;");
1209
1210 expr(dfp,"if( dpenv != NULL && is_in_DPEnvelope(dpenv,i,j) == FALSE )");
1211 startbrace_tag(dfp,"Is not in envelope");
1212 for(i=0;i<gm->len;i++) {
1213 expr(dfp,"%s_DC_SHADOW_MATRIX(mat,i,j,%s) = NEGI",gm->name,gm->state[i]->name);
1214 }
1215 expr(dfp,"continue;");
1216 closebrace(dfp);
1217
1218 expr(dfp,"if( num %% 1000 == 0 )");
1219 hang_expr(dfp,"log_full_error(REPORT,0,\"[%%d%%%%%%%% done]After mid-j %%5d Cells done %%d%%%%%%%%\",perc_done,startj,(num*100)/total)");
1220
1221
1222 write_main_shadow_block(dfp,gm,"DC_SHADOW_MATRIX","mat","DC_SHADOW_SPECIAL","DC_SHADOW_MATRIX_SP","DC_SHADOW_SPECIAL_SP",7,FALSE,FALSE,0,FALSE);
1223 closebrace(dfp);
1224
1225 /** no specials, as we are guarenteed to be outside them **/
1226
1227 closebrace(dfp);
1228
1229 add_break(dfp);
1230
1231 close_function(dfp);
1232
1233 }
1234
1235 # line 1206 "dynashadow.dy"
write_special_strip_read_func(DYNFILE * dfp,GenericMatrix * gm)1236 void write_special_strip_read_func(DYNFILE * dfp,GenericMatrix * gm)
1237 {
1238 int ss;
1239 FuncInfo * fi;
1240
1241
1242 for(ss=0;ss<gm->spec_len;ss++)
1243 if( gm->special[ss]->is_start == TRUE)
1244 break;
1245
1246 fi = FuncInfo_named_from_varstr(FI_INTERNAL,"read_special_strip_%s",gm->name);
1247
1248 start_function_FuncInfo(fi,dfp,"boolean read_special_strip_%s(%s * mat,int stopi,int stopj,int stopstate,int * startj,int * startstate,PackAln * out)",gm->name,gm->name);
1249 expr(dfp,"int i;");
1250 expr(dfp,"int j;");
1251 expr(dfp,"int state;");
1252 expr(dfp,"int cellscore;");
1253 expr(dfp,"int isspecial;");
1254 expr(dfp,"PackAlnUnit * pau;");
1255
1256 add_break(dfp);
1257
1258 add_block_comment(dfp,"stop position is on the path");
1259
1260 expr(dfp,"i = stopi;");
1261 expr(dfp,"j = stopj;");
1262 expr(dfp,"state= stopstate;");
1263 expr(dfp,"isspecial = TRUE;");
1264
1265 add_break(dfp);
1266
1267 add_block_comment(dfp,"Loop until state has the same j as its stop in shadow pointers");
1268 add_block_comment(dfp,"This will be the state is came out from, OR it has hit !start");
1269 add_block_comment(dfp,"We may not want to get the alignment, in which case out will be NULL");
1270
1271 expr(dfp,"while( j > %s_DC_SHADOW_SPECIAL_SP(mat,i,j,state,4) && state != %s)",gm->name,gm->special[ss]->name);
1272 startbrace_tag(dfp,"while more specials to eat up");
1273 add_block_comment(dfp,"Put away current state, if we should");
1274 expr(dfp,"if(out != NULL)");
1275 startbrace(dfp);
1276 expr(dfp,"pau = PackAlnUnit_alloc();");
1277 add_end_comment(dfp,"Should deal with memory overflow");
1278 expr(dfp,"pau->i = i;");
1279 expr(dfp,"pau->j = j;");
1280 expr(dfp,"pau->state = state + %d;",gm->len);
1281 expr(dfp,"add_PackAln(out,pau);");
1282 closebrace(dfp);
1283 add_break(dfp);
1284
1285 expr(dfp,"max_special_strip_%s(mat,i,j,state,isspecial,&i,&j,&state,&isspecial,&cellscore);",gm->name);
1286 expr(dfp,"if( i == %s_READ_OFF_ERROR)",gm->name);
1287 startbrace(dfp);
1288 warn_expr(dfp,"In special strip read %s, got a bad read off error. Sorry!",gm->name);
1289 expr(dfp,"return FALSE;");
1290 closebrace(dfp);
1291 closebrace(dfp);
1292
1293 add_break(dfp);
1294 add_block_comment(dfp,"check to see we have not gone too far!");
1295
1296 expr(dfp,"if( state != %s && j < %s_DC_SHADOW_SPECIAL_SP(mat,i,j,state,4))",gm->special[ss]->name,gm->name);
1297 startbrace(dfp);
1298 expr(dfp,"warn(\"In special strip read %s, at special [%%d] state [%%d] overshot!\",j,state);",gm->name);
1299 expr(dfp,"return FALSE;");
1300 closebrace(dfp);
1301 add_block_comment(dfp,"Put away last state");
1302 expr(dfp,"if(out != NULL)");
1303 startbrace(dfp);
1304 expr(dfp,"pau = PackAlnUnit_alloc();");
1305 add_end_comment(dfp,"Should deal with memory overflow");
1306 expr(dfp,"pau->i = i;");
1307 expr(dfp,"pau->j = j;");
1308 expr(dfp,"pau->state = state + %d;",gm->len);
1309 expr(dfp,"add_PackAln(out,pau);");
1310 closebrace(dfp);
1311 add_break(dfp);
1312
1313 add_block_comment(dfp,"Put away where we are in startj and startstate");
1314 expr(dfp,"*startj = j;");
1315 expr(dfp,"*startstate = state;");
1316
1317 expr(dfp,"return TRUE;");
1318 close_function(dfp);
1319
1320 add_break(dfp);
1321 }
1322
1323
1324 # line 1294 "dynashadow.dy"
write_hidden_read_func(DYNFILE * dfp,GenericMatrix * gm)1325 void write_hidden_read_func(DYNFILE * dfp,GenericMatrix * gm)
1326 {
1327 FuncInfo * fi;
1328 fi = FuncInfo_named_from_varstr(FI_INTERNAL,"read_hidden_%s",gm->name);
1329
1330 start_function_FuncInfo(fi,dfp,"boolean read_hidden_%s(%s * mat,int starti,int startj,int startstate,int stopi,int stopj,int stopstate,PackAln * out)",gm->name,gm->name);
1331 expr(dfp,"int i;");
1332 expr(dfp,"int j;");
1333 expr(dfp,"int state;");
1334 expr(dfp,"int cellscore;");
1335 expr(dfp,"int isspecial;");
1336 add_block_comment(dfp,"We don't need hiddenj here, 'cause matrix access handled by max funcs");
1337 expr(dfp,"PackAlnUnit * pau;");
1338
1339 add_break(dfp);
1340
1341 add_block_comment(dfp,"stop position is on the path");
1342
1343 expr(dfp,"i = stopi;");
1344 expr(dfp,"j = stopj;");
1345 expr(dfp,"state= stopstate;");
1346 expr(dfp,"isspecial = FALSE;");
1347
1348 add_break(dfp);
1349
1350 expr(dfp,"while( i >= starti && j >= startj)");
1351 startbrace(dfp);
1352 add_block_comment(dfp,"Put away current i,j,state");
1353 expr(dfp,"pau = PackAlnUnit_alloc();");
1354 add_end_comment(dfp,"Should deal with memory overflow");
1355 expr(dfp,"pau->i = i;");
1356 expr(dfp,"pau->j = j;");
1357 expr(dfp,"pau->state = state;");
1358 /** expr(dfp,"fprintf(stdout,\"\\tPau unit %%d,%%d,%%d\\n\",i,j,state);"); **/
1359 expr(dfp,"add_PackAln(out,pau);");
1360 add_break(dfp);
1361 expr(dfp,"max_hidden_%s(mat,startj,i,j,state,isspecial,&i,&j,&state,&isspecial,&cellscore);",gm->name);
1362 add_break(dfp);
1363 expr(dfp,"if( i == %s_READ_OFF_ERROR)",gm->name);
1364 startbrace(dfp);
1365 expr(dfp,"warn(\"In %s hidden read off, between %%d:%%d,%%d:%%d - at got bad read off. Problem!\",starti,startj,stopi,stopj);",gm->name);
1366 expr(dfp,"return FALSE;");
1367 closebrace(dfp);
1368 add_break(dfp);
1369 expr(dfp,"if( i == starti && j == startj && state == startstate)");
1370 startbrace(dfp);
1371
1372 add_end_comment(dfp,"Put away final state (start of this block)");
1373
1374 expr(dfp,"pau = PackAlnUnit_alloc();");
1375 add_end_comment(dfp,"Should deal with memory overflow");
1376 expr(dfp,"pau->i = i;");
1377 expr(dfp,"pau->j = j;");
1378 expr(dfp,"pau->state = state;");
1379 expr(dfp,"add_PackAln(out,pau);");
1380
1381 hang_expr(dfp,"return TRUE;");
1382 closebrace(dfp);
1383
1384 expr(dfp,"if( i == starti && j == startj)");
1385 startbrace(dfp);
1386 expr(dfp,"warn(\"In %s hidden read off, between %%d:%%d,%%d:%%d - hit start cell, but not in start state. Can't be good!.\",starti,startj,stopi,stopj);",gm->name);
1387 expr(dfp,"return FALSE;");
1388 closebrace(dfp);
1389
1390 closebrace(dfp); /* back to while */
1391
1392
1393 expr(dfp,"warn(\"In %s hidden read off, between %%d:%%d,%%d:%%d - gone past start cell (now in %%d,%%d,%%d), can't be good news!.\",starti,startj,stopi,stopj,i,j,state);",gm->name);
1394 expr(dfp,"return FALSE;");
1395
1396 close_function(dfp);
1397 add_break(dfp);
1398 }
1399
1400
1401
1402
1403
1404 # line 1373 "dynashadow.dy"
write_hidden_calc_func(DYNFILE * dfp,GenericMatrix * gm)1405 void write_hidden_calc_func(DYNFILE * dfp,GenericMatrix * gm)
1406 {
1407 FuncInfo * fi;
1408 int i;
1409 fi = FuncInfo_named_from_varstr(FI_INTERNAL,"calculate_hidden_%s",gm->name);
1410
1411 start_function_FuncInfo(fi,dfp,"void calculate_hidden_%s(%s * mat,int starti,int startj,int startstate,int stopi,int stopj,int stopstate,DPEnvelope * dpenv)",gm->name,gm->name);
1412 expr(dfp,"register int i;");
1413 expr(dfp,"register int j;");
1414 expr(dfp,"register int score;");
1415 expr(dfp,"register int temp;");
1416 expr(dfp,"register int hiddenj;");
1417
1418 add_break(dfp);
1419 expr(dfp,"hiddenj = startj;");
1420
1421 add_break(dfp);
1422 expr(dfp,"init_hidden_%s(mat,starti,startj,stopi,stopj)",gm->name);
1423 add_break(dfp);
1424
1425 expr(dfp,"%s_HIDDEN_MATRIX(mat,starti,startj,startstate) = 0;",gm->name);
1426 add_break(dfp);
1427 expr(dfp,"for(j=startj;j<=stopj;j++)");
1428 startbrace(dfp);
1429 expr(dfp,"for(i=starti;i<=stopi;i++)");
1430 startbrace(dfp);
1431 add_block_comment(dfp,"Should *not* do very first cell as this is the one set to zero in one state!");
1432 expr(dfp,"if( i == starti && j == startj )");
1433 hang_expr(dfp,"continue;");
1434
1435 expr(dfp,"if( dpenv != NULL && is_in_DPEnvelope(dpenv,i,j) == FALSE )");
1436 startbrace_tag(dfp,"Is not in envelope");
1437
1438 for(i=0;i<gm->len;i++) {
1439 expr(dfp,"%s_HIDDEN_MATRIX(mat,i,j,%s) = NEGI",gm->name,gm->state[i]->name);
1440 }
1441 expr(dfp,"continue;");
1442 closebrace(dfp);
1443
1444 write_score_block(dfp,gm,"HIDDEN_MATRIX","mat","HIDDEN_SPECIAL",FALSE);
1445
1446 closebrace(dfp);
1447 closebrace(dfp);
1448
1449 add_break(dfp);
1450
1451 expr(dfp,"return;");
1452
1453 close_function(dfp);
1454 add_break(dfp);
1455 }
1456
1457
1458 # line 1426 "dynashadow.dy"
write_hidden_init_func(DYNFILE * dfp,GenericMatrix * gm)1459 void write_hidden_init_func(DYNFILE * dfp,GenericMatrix * gm)
1460 {
1461 register int s;
1462 FuncInfo * fi;
1463 fi = FuncInfo_named_from_varstr(FI_INTERNAL,"init_hidden_%s",gm->name);
1464
1465 start_function_FuncInfo(fi,dfp,"void init_hidden_%s(%s * mat,int starti,int startj,int stopi,int stopj)",gm->name,gm->name);
1466 expr(dfp,"register int i;");
1467 expr(dfp,"register int j;");
1468 expr(dfp,"register int hiddenj;");
1469
1470 add_break(dfp);
1471 expr(dfp,"hiddenj = startj;");
1472
1473 expr(dfp,"for(j=(startj-%d);j<=stopj;j++)",gm->window_j);
1474 startbrace(dfp);
1475 expr(dfp,"for(i=(starti-%d);i<=stopi;i++)",gm->window_i);
1476 startbrace(dfp);
1477
1478 for(s=0;s<gm->len;s++) {
1479 expr(dfp,"%s_HIDDEN_MATRIX(mat,i,j,%s) = %s;\n",gm->name,gm->state[s]->name,gm->state[s]->def_score);
1480 }
1481
1482 closebrace(dfp);
1483 closebrace(dfp);
1484
1485 add_break(dfp);
1486
1487 expr(dfp,"return");
1488 close_function(dfp);
1489 add_break(dfp);
1490 }
1491
1492
1493 # line 1460 "dynashadow.dy"
write_hidden_max_func(DYNFILE * dfp,GenericMatrix * gm)1494 void write_hidden_max_func(DYNFILE * dfp,GenericMatrix * gm)
1495 {
1496 FuncInfo * fi;
1497 fi = FuncInfo_named_from_varstr(FI_INTERNAL,"max_hidden_%s",gm->name);
1498
1499 start_function_FuncInfo(fi,dfp,"int max_hidden_%s(%s * mat,int hiddenj,int i,int j,int state,boolean isspecial,int * reti,int * retj,int * retstate,boolean * retspecial,int * cellscore)",gm->name,gm->name);
1500
1501 expr(dfp,"register int temp;");
1502 expr(dfp,"register int cscore;");
1503
1504 add_break(dfp);
1505
1506 expr(dfp,"*reti = (*retj) = (*retstate) = %s_READ_OFF_ERROR;",gm->name);
1507
1508 add_break(dfp);
1509
1510 expr(dfp,"if( i < 0 || j < 0 || i > mat->%s->%s || j > mat->%s->%s)",gm->query->name,
1511 gm->query_len,gm->target->name,gm->target_len);
1512 startbrace(dfp);
1513 expr(dfp,"warn(\"In %s matrix special read off - out of bounds on matrix [i,j is %%d,%%d state %%d in standard matrix]\",i,j,state);",gm->name);
1514 expr(dfp,"return -1;");
1515 closebrace(dfp);
1516
1517 write_max_calc_block(dfp,gm,"HIDDEN_MATRIX","HIDDEN_SPECIAL",FALSE,FALSE);
1518
1519 close_function(dfp);
1520
1521 add_break(dfp);
1522 return;
1523
1524 }
1525
1526 # line 1492 "dynashadow.dy"
write_matrix_to_special_max_func(DYNFILE * dfp,GenericMatrix * gm)1527 void write_matrix_to_special_max_func(DYNFILE * dfp,GenericMatrix * gm)
1528 {
1529 register int i;
1530 register int j;
1531 FuncInfo * fi;
1532
1533 char * special_tag = "DC_SHADOW_SPECIAL";
1534 char * matrix_tag = "DC_SHADOW_MATRIX";
1535
1536 fi = FuncInfo_named_from_varstr(FI_INTERNAL,"max_matrix_to_special_%s",gm->name);
1537
1538 start_function_FuncInfo(fi,dfp,"int max_matrix_to_special_%s(%s * mat,int i,int j,int state,int cscore,int * reti,int * retj,int * retstate,boolean * retspecial,int * cellscore)",gm->name,gm->name);
1539
1540 expr(dfp,"int temp");
1541
1542
1543 expr(dfp,"*reti = (*retj) = (*retstate) = %s_READ_OFF_ERROR;",gm->name);
1544
1545
1546 add_break(dfp);
1547
1548 expr(dfp,"if( j < 0 || j > mat->lenj)",gm->target->name,gm->target_len);
1549 startbrace(dfp);
1550 expr(dfp,"warn(\"In %s matrix to special read off - out of bounds on matrix [j is %%d in special]\",j);",gm->name);
1551 expr(dfp,"return -1;");
1552 closebrace(dfp);
1553
1554 add_break(dfp);
1555
1556 expr(dfp,"switch(state)");
1557
1558 startbrace_tag(dfp,"Switch state ");
1559 for(i=0;i<gm->len;i++) {
1560 auto CellState * cell;
1561 cell = gm->state[i];
1562 expr(dfp,"case %s : ",cell->name);
1563 startcase(dfp);
1564 for(j=cell->len-1;j>=0;j--) {
1565 if( cell->source[j]->isspecial == FALSE) {
1566 add_block_comment(dfp,"Source %s is not a special, should not get here!",cell->source[j]->state_source);
1567 continue;
1568 }
1569
1570 expr(dfp,"temp = cscore - (%s) - (%s)",cell->source[j]->calc_expr,
1571 cell->calc_expr == NULL ? "0" : cell->calc_expr);
1572
1573 if( cell->source[j]->isspecial == TRUE)
1574 expr(dfp,"if( temp == %s_%s(mat,i - %d,j - %d,%s) )",gm->name,special_tag,cell->source[j]->offi,
1575 cell->source[j]->offj,cell->source[j]->state_source);
1576 else expr(dfp,"if( temp == %s_%s(mat,i - %d,j - %d,%s) )",gm->name,matrix_tag,cell->source[j]->offi,
1577 cell->source[j]->offj,cell->source[j]->state_source);
1578
1579 startbrace(dfp);
1580 expr(dfp,"*reti = i - %d;",cell->source[j]->offi);
1581 expr(dfp,"*retj = j - %d;",cell->source[j]->offj);
1582 expr(dfp,"*retstate = %s;",cell->source[j]->state_source);
1583 if( cell->source[j]->isspecial == TRUE)
1584 expr(dfp,"*retspecial = TRUE;");
1585 else expr(dfp,"*retspecial = FALSE;");
1586
1587 /*** if they want the score, calc the difference in the number and give it back ***/
1588 expr(dfp,"if( cellscore != NULL)");
1589 startbrace(dfp);
1590
1591
1592 expr(dfp,"*cellscore = cscore - %s_%s(mat,i-%d,j-%d,%s)",gm->name,
1593 cell->source[j]->isspecial == TRUE ? special_tag : matrix_tag,cell->source[j]->offi,
1594 cell->source[j]->offj,cell->source[j]->state_source);
1595 closebrace(dfp);
1596
1597
1598 expr(dfp,"return %s_%s(mat,i - %d,j - %d,%s) ",gm->name,matrix_tag,cell->source[j]->offi,
1599 cell->source[j]->offj,cell->source[j]->state_source);
1600 closebrace(dfp);
1601 }
1602 expr(dfp,"warn(\"Major problem (!) - in %s matrix to special read off, position %%d,%%d state %%d no source found!\",i,j,state);",gm->name);
1603 expr(dfp,"return (-1);");
1604 closecase(dfp);
1605 }
1606 expr(dfp,"default:");
1607 startcase(dfp);
1608 expr(dfp,"warn(\"Major problem (!) - in %s read off, position %%d,%%d state %%d no source found!\",i,j,state);",gm->name);
1609 expr(dfp,"return (-1);");
1610 closecase(dfp);
1611
1612
1613 closebrace(dfp);
1614
1615 add_break(dfp);
1616 close_function(dfp);
1617 add_break(dfp);
1618 }
1619
1620
1621 # line 1586 "dynashadow.dy"
write_special_strip_max_func(DYNFILE * dfp,GenericMatrix * gm)1622 void write_special_strip_max_func(DYNFILE * dfp,GenericMatrix * gm)
1623 {
1624 register int i;
1625 register int j;
1626 char * matrix_tag = "DC_SHADOW_MATRIX";
1627 char * special_tag = "DC_SHADOW_SPECIAL";
1628
1629 FuncInfo * fi;
1630
1631 fi = FuncInfo_named_from_varstr(FI_INTERNAL,"max_special_strip_%s",gm->name);
1632 add_line_to_Ftext(fi->ft,"A pretty intense internal function. Deals with read-off only in specials");
1633
1634
1635
1636
1637 start_function_FuncInfo(fi,dfp,"int max_special_strip_%s(%s * mat,int i,int j,int state,boolean isspecial,int * reti,int * retj,int * retstate,boolean * retspecial,int * cellscore)",gm->name,gm->name);
1638
1639 expr(dfp,"int temp;");
1640 expr(dfp,"int cscore;");
1641
1642 add_break(dfp);
1643
1644
1645
1646 expr(dfp,"*reti = (*retj) = (*retstate) = %s_READ_OFF_ERROR;",gm->name);
1647
1648
1649 expr(dfp,"if( isspecial == FALSE )");
1650 startbrace(dfp);
1651 warn_expr(dfp,"In special strip max function for %s, got a non special start point. Problem! (bad!)",gm->name);
1652 expr(dfp,"return (-1);");
1653 closebrace(dfp);
1654
1655
1656 add_break(dfp);
1657
1658 expr(dfp,"if( j < 0 || j > mat->%s->%s)",gm->target->name,gm->target_len);
1659 startbrace(dfp);
1660 expr(dfp,"warn(\"In %s matrix special read off - out of bounds on matrix [j is %%d in special]\",j);",gm->name);
1661 expr(dfp,"return -1;");
1662 closebrace(dfp);
1663
1664 add_break(dfp);
1665
1666 expr(dfp,"cscore = %s_%s(mat,i,j,state);",gm->name,special_tag);
1667
1668
1669 expr(dfp,"switch(state)");
1670 startbrace_tag(dfp,"switch on special states");
1671
1672 for(i=0;i<gm->spec_len;i++) {
1673 auto CellState * cell;
1674 cell = gm->special[i];
1675 expr(dfp,"case %s : ",cell->name);
1676 startcase(dfp);
1677
1678
1679 /*** ok, we are only interested in specials to specials,
1680 otherwise we should not be here ***/
1681
1682
1683
1684 for(j=cell->len-1;j>=0;j--) {
1685
1686 if( cell->source[j]->isspecial == FALSE ) {
1687 add_block_comment(dfp,"Source %s is not a special",cell->source[j]->state_source);
1688 continue;
1689
1690 }
1691
1692
1693 else {
1694 add_block_comment(dfp,"source %s is a special",cell->source[j]->state_source);
1695
1696 expr(dfp,"temp = cscore - (%s) - (%s)",cell->source[j]->calc_expr,
1697 cell->calc_expr == NULL ? "0" : cell->calc_expr);
1698
1699
1700 expr(dfp,"if( temp == %s_%s(mat,i - %d,j - %d,%s) )",gm->name,special_tag,cell->source[j]->offi,
1701 cell->source[j]->offj,cell->source[j]->state_source);
1702
1703
1704 startbrace(dfp);
1705 expr(dfp,"*reti = i - %d;",cell->source[j]->offi);
1706 expr(dfp,"*retj = j - %d;",cell->source[j]->offj);
1707 expr(dfp,"*retstate = %s;",cell->source[j]->state_source);
1708
1709 if( cell->source[j]->isspecial == TRUE)
1710 expr(dfp,"*retspecial = TRUE;");
1711 else expr(dfp,"*retspecial = FALSE;");
1712
1713 /*** if they want the score, calc the difference in the number and give it back ***/
1714 expr(dfp,"if( cellscore != NULL)");
1715 startbrace(dfp);
1716 expr(dfp,"*cellscore = cscore - %s_%s(mat,i-%d,j-%d,%s)",gm->name,special_tag,cell->source[j]->offi,
1717 cell->source[j]->offj,cell->source[j]->state_source);
1718 closebrace(dfp);
1719
1720 expr(dfp,"return %s_%s(mat,i - %d,j - %d,%s) ",gm->name,matrix_tag,cell->source[j]->offi,
1721 cell->source[j]->offj,cell->source[j]->state_source);
1722 closebrace(dfp);
1723
1724 }
1725 }
1726 closecase(dfp);
1727 }
1728
1729 expr(dfp,"default:");
1730 startcase(dfp);
1731 expr(dfp,"warn(\"Major problem (!) - in %s special strip read off, position %%d,%%d state %%d no source found dropped into default on source switch!\",i,j,state);",gm->name);
1732 expr(dfp,"return (-1);");
1733 closecase(dfp);
1734
1735 closebrace(dfp);
1736
1737 close_function(dfp);
1738
1739 add_break(dfp);
1740 }
1741
1742
1743
1744 # line 1708 "dynashadow.dy"
write_shadow_dc_macros(DYNFILE * dfp,GenericMatrix * gm)1745 void write_shadow_dc_macros(DYNFILE * dfp,GenericMatrix * gm)
1746 {
1747 int steve_space;
1748
1749 macro(dfp,"#define %s_HIDDEN_MATRIX(thismatrix,i,j,state) (thismatrix->basematrix->matrix[(j-hiddenj+%d)][(i+%d)*%d+state])",gm->name,gm->window_j,gm->window_i,gm->len);
1750
1751 macro(dfp,"#define %s_DC_SHADOW_MATRIX(thismatrix,i,j,state) (thismatrix->basematrix->matrix[((j+%d)*8) %% %d][(i+%d)*%d+state])",gm->name,gm->window_j+1,(gm->window_j+1)*8,gm->window_i,gm->len);
1752
1753 macro(dfp,"#define %s_HIDDEN_SPECIAL(thismatrix,i,j,state) (thismatrix->basematrix->specmatrix[state][(j+%d)])",gm->name,gm->window_j);
1754
1755 macro(dfp,"#define %s_DC_SHADOW_SPECIAL(thismatrix,i,j,state) (thismatrix->basematrix->specmatrix[state*8][(j+%d)])",gm->name,gm->window_j);
1756 macro(dfp,"#define %s_DC_SHADOW_MATRIX_SP(thismatrix,i,j,state,shadow) (thismatrix->basematrix->matrix[((((j+%d)*8)+(shadow+1)) %% %d)][(i+%d)*%d + state])",gm->name,gm->window_j+1,(gm->window_j+1)*8,gm->window_i,gm->len);
1757 macro(dfp,"#define %s_DC_SHADOW_SPECIAL_SP(thismatrix,i,j,state,shadow) (thismatrix->basematrix->specmatrix[state*8 +shadow+1][(j+%d)])",gm->name,gm->window_j);
1758
1759 /* we need 8 shadow pointers per matrix cell; one for the score 7 for different shadow implementations*/
1760 steve_space = gm->len * 8;
1761
1762 macro(dfp,"#define %s_DC_OPT_SHADOW_MATRIX(thismatrix,i,j,state) (score_pointers[(((j+%d)%% %d) * (leni+1) * %d) + ((i+%d) * %d) + (state)])",gm->name,gm->window_j,gm->window_j,gm->len,gm->window_i,gm->len);
1763
1764 /* the +1 is because + 0 is the score */
1765 macro(dfp,"#define %s_DC_OPT_SHADOW_MATRIX_SP(thismatrix,i,j,state,shadow) (shadow_pointers[(((j+%d)%% %d) * (leni+1) * %d) + ((i+%d) * %d) + (state * %d) + shadow+1])",gm->name,gm->window_j,gm->window_j,steve_space,gm->window_i,steve_space,8);
1766
1767
1768 /* currently for the optimised shadow we use the same special matrix layout */
1769 macro(dfp,"#define %s_DC_OPT_SHADOW_SPECIAL(thismatrix,i,j,state) (thismatrix->basematrix->specmatrix[state*8][(j+%d)])",gm->name,gm->window_j);
1770 macro(dfp,"#define %s_DC_OPT_SHADOW_SPECIAL_SP(thismatrix,i,j,state,shadow) (thismatrix->basematrix->specmatrix[state*8 +shadow+1][(j+%d)])",gm->name,gm->window_j);
1771
1772
1773 }
1774
1775
1776 /* Function: write_shadow_dc_alloc(dfp,gm)
1777 *
1778 * Descrip: Defunct (I think)
1779 *
1780 *
1781 * Arg: dfp [UNKN ] Undocumented argument [DYNFILE *]
1782 * Arg: gm [UNKN ] Undocumented argument [GenericMatrix *]
1783 *
1784 */
1785 # line 1742 "dynashadow.dy"
write_shadow_dc_alloc(DYNFILE * dfp,GenericMatrix * gm)1786 void write_shadow_dc_alloc(DYNFILE * dfp,GenericMatrix * gm)
1787 {
1788 FuncInfo * fi;
1789 fi = FuncInfo_named_from_varstr(FI_INTERNAL,"do_dc_sin_%s",gm->name);
1790
1791 start_function(dfp,"%s * shadow_dc_alloc_%s(int leni,int lenj)",gm->name,gm->name);
1792 expr(dfp,"register int i;");
1793 expr(dfp,"register %s * out",gm->name);
1794
1795 add_break(dfp);
1796 add_block_comment(dfp,"Have to have enough memory to hold i,j,state triple *3 for each state");
1797 add_block_comment(dfp,"This memory will also be used for the explicit memory use at end of r");
1798 add_break(dfp);
1799 add_block_comment(dfp,"This means we need (window_j+1)*8 top line pointers by cell number * leni");
1800 add_break(dfp);
1801
1802 expr(dfp,"out = %s_alloc()",gm->name);
1803 expr(dfp,"if(out == NULL)");
1804 hang_expr(dfp,"return NULL;");
1805 add_end_comment(dfp,"warning already issued");
1806
1807 add_break(dfp);
1808
1809 expr(dfp,"out->basematrix = BaseMatrix_alloc_matrix_and_specials(%d,(leni + %d) * %d,%d,lenj+%d)",(gm->window_j+1)*8,gm->window_i,gm->len,gm->spec_len*8,gm->window_j);
1810 expr(dfp,"if(out->basematrix == NULL)");
1811 startbrace(dfp);
1812 expr(dfp,"warn(\"In shadow_dc_alloc_%s unable to allocate basematrix with main matrix %d by %%d ints\",(leni+%d)*%d);",gm->name,(gm->window_j+1)*8,gm->window_i,gm->len);
1813 expr(dfp,"free_%s(out)",gm->name);
1814 expr(dfp,"return NULL;");
1815 closebrace(dfp);
1816
1817 add_break(dfp);
1818
1819 expr(dfp,"return out;");
1820
1821 close_function(dfp);
1822 add_break(dfp);
1823 }
1824
1825
1826
1827
1828 /***
1829 Start End Stuff
1830 ***/
1831
1832
1833 # line 1789 "dynashadow.dy"
write_start_end_init(DYNFILE * dfp,GenericMatrix * gm)1834 void write_start_end_init(DYNFILE * dfp,GenericMatrix * gm)
1835 {
1836 register int s;
1837 register int i;
1838 FuncInfo * fi;
1839
1840 for(i=0;i<gm->spec_len;i++)
1841 if( gm->special[i]->is_start == TRUE)
1842 break;
1843
1844 if( i >= gm->spec_len ) {
1845 log_full_error(WARNING,0,"Cannot build start/end init function due to lack of start state");
1846 return;
1847 }
1848
1849 fi = FuncInfo_named_from_varstr(FI_INTERNAL,"init_start_end_linear_%s",gm->name);
1850
1851 start_function_FuncInfo(fi,dfp,"void init_start_end_linear_%s(%s * mat)",gm->name,gm->name);
1852 expr(dfp,"register int i;");
1853 expr(dfp,"register int j;");
1854
1855
1856 expr(dfp,"for(j=0;j<%d;j++)",gm->window_j+2);
1857 startbrace(dfp);
1858 expr(dfp,"for(i=(-%d);i<mat->%s->%s;i++)",gm->window_i,gm->query->name,gm->query_len);
1859 startbrace(dfp);
1860 for(s=0;s<gm->len;s++) {
1861 expr(dfp,"%s_DC_SHADOW_MATRIX(mat,i,j,%s) = %s;",gm->name,gm->state[s]->name,gm->state[s]->def_score);
1862 expr(dfp,"%s_DC_SHADOW_MATRIX_SP(mat,i,j,%s,0) = (-1);",gm->name,gm->state[s]->name);
1863 }
1864 closebrace(dfp);
1865 closebrace(dfp);
1866
1867 add_break(dfp);
1868
1869 expr(dfp,"for(j=(-%d);j<mat->%s->%s;j++)",gm->window_j,gm->target->name,gm->target_len);
1870 startbrace(dfp);
1871 for(s=0;s<gm->spec_len;s++) {
1872 expr(dfp,"%s_DC_SHADOW_SPECIAL(mat,0,j,%s) = %s;",gm->name,gm->special[s]->name,gm->special[s]->def_score);
1873 if( s == i ) /** is start **/
1874 expr(dfp,"%s_DC_SHADOW_SPECIAL_SP(mat,0,j,%s,0) = j;",gm->name,gm->special[s]->name);
1875 else
1876 expr(dfp,"%s_DC_SHADOW_SPECIAL_SP(mat,0,j,%s,0) = (-1);",gm->name,gm->special[s]->name);
1877 }
1878 closebrace(dfp);
1879
1880 add_break(dfp);
1881 expr(dfp,"return");
1882 close_function(dfp);
1883 add_break(dfp);
1884 }
1885
1886
1887 # line 1842 "dynashadow.dy"
write_start_end_find_end(DYNFILE * dfp,GenericMatrix * gm)1888 void write_start_end_find_end(DYNFILE * dfp,GenericMatrix * gm)
1889 {
1890
1891 register int i;
1892
1893 ArgInfo * ai;
1894 FuncInfo * fi;
1895
1896 fi = FuncInfo_named_from_varstr(FI_INTERNAL,"start_end_find_end_%s",gm->name);
1897 add_line_to_Ftext(fi->ft,"First function used to find end of the best path in the special state !end");
1898
1899 ai = ArgInfo_in_FuncInfo_from_varstr(fi,"mat");
1900 ai->desc = stringalloc("Matrix in small mode");
1901
1902 ai = ArgInfo_in_FuncInfo_from_varstr(fi,"endj");
1903 ai->desc = stringalloc("position of end in j (meaningless in i)");
1904 ai->argtype = ARGTYPE_WRITE;
1905
1906 for(i=0;i<gm->spec_len;i++)
1907 if( gm->special[i]->is_end == TRUE)
1908 break;
1909
1910 if( i >= gm->spec_len ) {
1911 log_full_error(WARNING,0,"Cannot build start/end find end function due to lack of end state. YIKES!");
1912 return;
1913 }
1914
1915
1916 start_function_FuncInfo(fi,dfp,"int start_end_find_end_%s(%s * mat,int * endj)",gm->name,gm->name);
1917
1918 expr(dfp,"register int j");
1919 expr(dfp,"register int max;");
1920 expr(dfp,"register int maxj");
1921
1922 add_break(dfp);
1923
1924 expr(dfp,"max = %s_DC_SHADOW_SPECIAL(mat,0,mat->%s->%s-1,%s);",gm->name,gm->target->name,gm->target_len,gm->special[i]->name);
1925 expr(dfp,"maxj = mat->%s->%s-1",gm->target->name,gm->target_len);
1926 expr(dfp,"for(j= mat->%s->%s-2 ;j >= 0 ;j--)",gm->target->name,gm->target_len);
1927
1928 startbrace(dfp);
1929 expr(dfp,"if( %s_DC_SHADOW_SPECIAL(mat,0,j,%s) > max )",gm->name,gm->special[i]->name);
1930 startbrace(dfp);
1931 expr(dfp,"max = %s_DC_SHADOW_SPECIAL(mat,0,j,%s);",gm->name,gm->special[i]->name);
1932 expr(dfp,"maxj = j;");
1933 closebrace(dfp);
1934 closebrace(dfp);
1935
1936 add_break(dfp);
1937
1938
1939 expr(dfp,"if( endj != NULL)");
1940 hang_expr(dfp,"*endj = maxj;");
1941
1942 add_break(dfp);
1943
1944 expr(dfp,"return max");
1945
1946 close_function(dfp);
1947
1948 add_break(dfp);
1949 }
1950
1951
1952 /* Function: heavy_optimised_shadow_GenericMatrix(dfp,gm)
1953 *
1954 * Descrip: heavily optimised start end calc function
1955 *
1956 *
1957 * Arg: dfp [UNKN ] Undocumented argument [DYNFILE *]
1958 * Arg: gm [UNKN ] Undocumented argument [GenericMatrix *]
1959 *
1960 */
1961 # line 1909 "dynashadow.dy"
heavy_optimised_shadow_GenericMatrix(DYNFILE * dfp,GenericMatrix * gm)1962 void heavy_optimised_shadow_GenericMatrix(DYNFILE * dfp,GenericMatrix * gm)
1963 {
1964 int i;
1965 int j;
1966 int k;
1967 FuncInfo * fi;
1968
1969 char * matrixtag = "DC_OPT_SHADOW_MATRIX";
1970 char * shadow_main_tag = "DC_OPT_SHADOW_MATRIX_SP";
1971 char * shadow_special_tag = "DC_OPT_SHADOW_SPECIAL_SP";
1972 char * specialtag = "DC_OPT_SHADOW_SPECIAL";
1973
1974
1975 fi = FuncInfo_named_from_varstr(FI_INTERNAL,"dc_heavy_optimised_start_end_calc_%s",gm->name);
1976 add_line_to_Ftext(fi->ft,"Calculates special strip, leaving start/end/score points in shadow matrix");
1977 add_line_to_Ftext(fi->ft,"Works off specially laid out memory from steve searle");
1978
1979
1980 start_function_FuncInfo(fi,dfp,"boolean dc_heavy_optimised_start_end_calc_%s(%s *mat,DPEnvelope * dpenv)",gm->name,gm->name);
1981
1982 expr(dfp,"int i;");
1983 expr(dfp,"int j;");
1984 expr(dfp,"int k;");
1985
1986
1987 expr(dfp,"int leni;");
1988 expr(dfp,"int lenj;");
1989 expr(dfp,"int localshadow[7]");
1990 expr(dfp,"long int total");
1991 expr(dfp,"long int num=0");
1992 expr(dfp,"int * score_pointers");
1993 expr(dfp,"int * shadow_pointers");
1994
1995
1996 for(i=0;i<gm->len;i++) {
1997 expr(dfp,"int score_%s;",gm->state[i]->name);
1998 expr(dfp,"int temp_%s;",gm->state[i]->name);
1999 expr(dfp,"int * localsp_%s;",gm->state[i]->name);
2000 for(j=0;j<gm->state[i]->len;j++) {
2001 expr(dfp,"int score_%s_%d;",gm->state[i]->name,j);
2002 }
2003 }
2004
2005 add_break(dfp);
2006
2007 expr(dfp,"leni = mat->%s->%s;",gm->query->name,gm->query_len);
2008 expr(dfp,"lenj = mat->%s->%s;",gm->target->name,gm->target_len);
2009
2010 add_break(dfp);
2011
2012 expr(dfp,"score_pointers = (int *) calloc (%d * (leni + %d) * %d,sizeof(int));",gm->window_j,gm->window_i,gm->len);
2013 expr(dfp,"shadow_pointers = (int *) calloc (%d * (leni + %d) * %d * 8,sizeof(int));",gm->window_j,gm->window_i,gm->len);
2014
2015
2016 add_break(dfp);
2017
2018 expr(dfp,"for(j=0;j<lenj;j++)");
2019 startbrace_tag(dfp,"for each j strip");
2020 expr(dfp,"for(i=0;i<leni;i++)");
2021 startbrace_tag(dfp,"for each i position in strip");
2022 expr(dfp,"num++");
2023
2024
2025 expr(dfp,"if( dpenv != NULL && is_in_DPEnvelope(dpenv,i,j) == FALSE )");
2026 startbrace_tag(dfp,"Is not in envelope");
2027
2028 for(i=0;i<gm->len;i++) {
2029 expr(dfp,"%s_DC_OPT_SHADOW_MATRIX(mat,i,j,%s) = NEGI",gm->name,gm->state[i]->name);
2030 }
2031 expr(dfp,"continue;");
2032 closebrace(dfp);
2033
2034
2035 expr(dfp,"if( num%%1000 == 0)");
2036 hang_expr(dfp,"log_full_error(REPORT,0,\"%%6d Cells done [%%2d%%%%%%%%]\",num,num*100/total);");
2037
2038 add_break(dfp);
2039
2040
2041 /* main block */
2042
2043 add_block_comment(dfp,"Retrieve all the calculations first, and put into local variables");
2044
2045 for(i=0;i<gm->len;i++) {
2046 for(j=0;j<gm->state[i]->len;j++) {
2047 expr(dfp,"score_%s_%d = %s_%s(mat,i-%d,j-%d,%s) + %s + (%s)",
2048 gm->state[i]->name,j,
2049 gm->name,
2050 gm->state[i]->source[j]->isspecial == TRUE ? specialtag : matrixtag,
2051 gm->state[i]->source[j]->offi,gm->state[i]->source[j]->offj,
2052 gm->state[i]->source[j]->state_source,
2053 gm->state[i]->source[j]->calc_expr,
2054 gm->state[i]->calc_expr == NULL ? "0" : gm->state[i]->calc_expr
2055 );
2056 }
2057 }
2058
2059 add_break(dfp);
2060
2061 add_block_comment(dfp,"now do the if/then/else store");
2062
2063 for(i=0;i<gm->len;i++) {
2064 add_block_comment(dfp,"handling state %s",gm->state[i]->name);
2065
2066 expr(dfp,"score_%s = score_%s_0;",gm->state[i]->name,gm->state[i]->name);
2067 expr(dfp,"localsp_%s = &(%s_%s(mat,i - %d,j - %d,%s,0));",gm->state[i]->name,
2068 gm->name,gm->state[i]->source[0]->isspecial == TRUE ? shadow_special_tag : shadow_main_tag,
2069 gm->state[i]->source[0]->offi,gm->state[i]->source[0]->offj,gm->state[i]->source[0]->state_source);
2070
2071 for(j=1;j<gm->state[i]->len;j++) {
2072 expr(dfp,"if( score_%s_%d > score_%s)",gm->state[i]->name,j,gm->state[i]->name);
2073 startbrace(dfp);
2074 expr(dfp,"score_%s = score_%s_%d;",gm->state[i]->name,gm->state[i]->name,j);
2075 if( gm->state[i]->source[j]->isspecial == TRUE ) {
2076 add_block_comment(dfp,"This source is a special, push top shadow pointers");
2077 expr(dfp,"localshadow[0] = i;");
2078 expr(dfp,"localshadow[1] = j;");
2079 expr(dfp,"localshadow[2] = %s;",gm->state[i]->name);
2080 expr(dfp,"localshadow[3] = -1;");
2081 expr(dfp,"localshadow[4] = -1;");
2082 expr(dfp,"localshadow[5] = -1;");
2083 expr(dfp,"localshadow[6] = score_%s;",gm->state[i]->name);
2084 expr(dfp,"localsp_%s = localshadow;",gm->state[i]->name);
2085 } else {
2086 expr(dfp,"localsp_%s = &(%s_%s(mat,i -%d,j - %d,%s,0));",gm->state[i]->name,
2087 gm->name,shadow_main_tag,
2088 gm->state[i]->source[j]->offi,gm->state[i]->source[j]->offj,gm->state[i]->source[j]->state_source);
2089 }
2090 closebrace(dfp);
2091
2092 } /* end of loop over all sources */
2093
2094
2095 expr(dfp,"%s_%s(mat,i,j,%s) = score_%s",gm->name,matrixtag,gm->state[i]->name,gm->state[i]->name);
2096 expr(dfp,"for(k=0;k<7;k++)");
2097 hang_expr(dfp,"%s_%s(mat,i,j,%s,k) = localsp_%s[k]",gm->name,shadow_main_tag,gm->state[i]->name,gm->state[i]->name);
2098
2099 for(j=0;j<gm->spec_len;j++) {
2100 auto CellState * specstate;
2101 specstate = gm->special[j];
2102
2103
2104 for(k=0;k<specstate->len;k++) {
2105 if( strcmp(specstate->source[k]->state_source,gm->state[i]->name) == 0) {
2106 /********************************/
2107 /* is a special source! */
2108 /********************************/
2109 add_break(dfp);
2110 add_block_comment(dfp,"state %s is a source for special %s",gm->state[i]->name,specstate->name);
2111 expr(dfp,"temp_%s = score_%s + (%s) + (%s) ",gm->state[i]->name,gm->state[i]->name,specstate->source[k]->calc_expr,specstate->calc_expr == NULL ? "0" : specstate->calc_expr );
2112 expr(dfp,"if( temp_%s > %s_%s(mat,i,j,%s) ) ",gm->state[i]->name,gm->name,specialtag,specstate->name);
2113 startbrace(dfp);
2114 expr(dfp,"%s_%s(mat,i,j,%s) = temp_%s",gm->name,specialtag,specstate->name,gm->state[i]->name);
2115
2116 add_block_comment(dfp,"Have to push only bottem half of system here");
2117 expr(dfp,"for(k=0;k<3;k++)");
2118 hang_expr(dfp,"%s_%s(mat,i,j,%s,k) = %s_%s(mat,i,j,%s,k);",
2119 gm->name,shadow_special_tag,
2120 specstate->name, gm->name,
2121 specstate->source[k]->isspecial == TRUE ? shadow_special_tag : shadow_main_tag,
2122 gm->state[i]->name);
2123
2124 /*** sort of hacky ***/
2125 expr(dfp,"%s_%s(mat,i,j,%s,6) = temp_%s;",
2126 gm->name,shadow_special_tag,
2127 specstate->name, gm->state[i]->name);
2128
2129
2130
2131 expr(dfp,"%s_%s(mat,i,j,%s,3) = i;",gm->name,shadow_special_tag,specstate->name);
2132 expr(dfp,"%s_%s(mat,i,j,%s,4) = j;",gm->name,shadow_special_tag,specstate->name);
2133 expr(dfp,"%s_%s(mat,i,j,%s,5) = %s;",gm->name,shadow_special_tag,specstate->name,gm->state[i]->name);
2134
2135 closebrace(dfp);
2136 }
2137 }
2138 } /* end of loop over all special states */
2139
2140 add_block_comment(dfp,"Finished if/then/else loop for state %s",gm->state[i]->name);
2141
2142 } /* end of loop over states */
2143
2144 add_break(dfp);
2145
2146 closebrace(dfp);
2147
2148 if( gm->specialtospecial == TRUE )
2149 write_special_shadow_block(dfp,gm,"DC_OPT_SHADOW_MATRIX","mat","DC_OPT_SHADOW_SPECIAL","DC_OPT_SHADOW_MATRIX_SP","DC_OPT_SHADOW_SPECIAL_SP",7,TRUE,0);
2150
2151 closebrace(dfp);
2152
2153 add_break;
2154
2155 expr(dfp,"free(score_pointers);");
2156 expr(dfp,"free(shadow_pointers);");
2157
2158 expr(dfp,"return TRUE");
2159
2160 close_function(dfp);
2161
2162 add_break(dfp);
2163
2164 }
2165
2166
2167 /* Function: optimised_shadow_GenericMatrix(dfp,*gm)
2168 *
2169 * Descrip: Makes the optimised shadow matrix routine,
2170 * worked out by Steve Searle - memory access
2171 * is put into one array so that the routine
2172 * is faster
2173 *
2174 *
2175 * Arg: dfp [UNKN ] Undocumented argument [DYNFILE *]
2176 * Arg: *gm [UNKN ] Undocumented argument [const GenericMatrix]
2177 *
2178 */
2179 # line 2120 "dynashadow.dy"
optimised_shadow_GenericMatrix(DYNFILE * dfp,const GenericMatrix * gm)2180 void optimised_shadow_GenericMatrix(DYNFILE * dfp,const GenericMatrix *gm)
2181 {
2182 int i;
2183 FuncInfo * fi;
2184
2185 fi = FuncInfo_named_from_varstr(FI_INTERNAL,"dc_optimised_start_end_calc_%s",gm->name);
2186 add_line_to_Ftext(fi->ft,"Calculates special strip, leaving start/end/score points in shadow matrix");
2187 add_line_to_Ftext(fi->ft,"Works off specially laid out memory from steve searle");
2188
2189
2190 start_function_FuncInfo(fi,dfp,"boolean dc_optimised_start_end_calc_%s(%s *mat,DPEnvelope * dpenv)",gm->name,gm->name);
2191
2192 expr(dfp,"int i;");
2193 expr(dfp,"int j;");
2194 expr(dfp,"int k;");
2195 expr(dfp,"int score;");
2196 expr(dfp,"int temp;");
2197 expr(dfp,"int leni;");
2198 expr(dfp,"int lenj;");
2199 expr(dfp,"int localshadow[7]");
2200 expr(dfp,"long int total");
2201 expr(dfp,"long int num=0");
2202 expr(dfp,"int * score_pointers");
2203 expr(dfp,"int * shadow_pointers");
2204 expr(dfp,"int * localsp;");
2205
2206 expr(dfp,"leni = mat->%s->%s;",gm->query->name,gm->query_len);
2207 expr(dfp,"lenj = mat->%s->%s;",gm->target->name,gm->target_len);
2208 expr(dfp,"total = leni * lenj;");
2209
2210 add_break(dfp);
2211
2212 expr(dfp,"score_pointers = (int *) calloc (%d * (leni + %d) * %d,sizeof(int));",gm->window_j,gm->window_i,gm->len);
2213 expr(dfp,"shadow_pointers = (int *) calloc (%d * (leni + %d) * %d * 8,sizeof(int));",gm->window_j,gm->window_i,gm->len);
2214
2215
2216 add_break(dfp);
2217
2218 expr(dfp,"for(j=0;j<lenj;j++)");
2219 startbrace_tag(dfp,"for each j strip");
2220 expr(dfp,"for(i=0;i<leni;i++)");
2221 startbrace_tag(dfp,"for each i position in strip");
2222 expr(dfp,"num++");
2223
2224
2225 expr(dfp,"if( dpenv != NULL && is_in_DPEnvelope(dpenv,i,j) == FALSE )");
2226 startbrace_tag(dfp,"Is not in envelope");
2227
2228 for(i=0;i<gm->len;i++) {
2229 expr(dfp,"%s_DC_OPT_SHADOW_MATRIX(mat,i,j,%s) = NEGI",gm->name,gm->state[i]->name);
2230 }
2231 expr(dfp,"continue;");
2232 closebrace(dfp);
2233
2234
2235 expr(dfp,"if( num%%1000 == 0)");
2236 hang_expr(dfp,"log_full_error(REPORT,0,\"%%6d Cells done [%%2d%%%%%%%%]\",num,num*100/total);");
2237
2238 add_break(dfp);
2239
2240 write_main_shadow_block(dfp,gm,"DC_OPT_SHADOW_MATRIX","mat","DC_OPT_SHADOW_SPECIAL","DC_OPT_SHADOW_MATRIX_SP","DC_OPT_SHADOW_SPECIAL_SP",7,TRUE,TRUE,0,TRUE);
2241
2242 add_break(dfp);
2243
2244 closebrace(dfp);
2245
2246 if( gm->specialtospecial == TRUE )
2247 write_special_shadow_block(dfp,gm,"DC_OPT_SHADOW_MATRIX","mat","DC_OPT_SHADOW_SPECIAL","DC_OPT_SHADOW_MATRIX_SP","DC_OPT_SHADOW_SPECIAL_SP",7,TRUE,0);
2248
2249 closebrace(dfp);
2250
2251 add_break;
2252
2253 expr(dfp,"free(score_pointers);");
2254 expr(dfp,"free(shadow_pointers);");
2255
2256 /* expr(dfp,"free(mat->basematrix->optimised_shadow);"); */
2257
2258 expr(dfp,"return TRUE");
2259
2260 close_function(dfp);
2261
2262 add_break(dfp);
2263
2264 }
2265
2266
2267
2268 # line 2208 "dynashadow.dy"
write_start_end_build(DYNFILE * dfp,GenericMatrix * gm)2269 void write_start_end_build(DYNFILE * dfp,GenericMatrix * gm)
2270 {
2271 int i;
2272 FuncInfo * fi;
2273
2274 fi = FuncInfo_named_from_varstr(FI_INTERNAL,"dc_start_end_calculate_%s",gm->name);
2275 add_line_to_Ftext(fi->ft,"Calculates special strip, leaving start/end/score points in the shadow matrix ");
2276 add_line_to_Ftext(fi->ft,"One tricky thing is that we need to add score-independent calcs in the states");
2277 add_line_to_Ftext(fi->ft,"As we have to evaluate them then. This is not ideally implemented therefore ");
2278 add_line_to_Ftext(fi->ft,"In fact it is *definitely* not ideal. Will have to do for now");
2279
2280
2281
2282 start_function_FuncInfo(fi,dfp,"boolean dc_start_end_calculate_%s(%s * mat,DPEnvelope * dpenv)",gm->name,gm->name);
2283 expr(dfp,"int i;");
2284 expr(dfp,"int j;");
2285 expr(dfp,"int k;");
2286 expr(dfp,"int score;");
2287 expr(dfp,"int temp;");
2288 expr(dfp,"int leni;");
2289 expr(dfp,"int lenj;");
2290 expr(dfp,"int localshadow[7]");
2291 expr(dfp,"long int total");
2292 expr(dfp,"long int num=0");
2293
2294
2295 add_break(dfp);
2296 expr(dfp,"init_start_end_linear_%s(mat)",gm->name);
2297 add_break(dfp);
2298
2299 expr(dfp,"leni = mat->%s->%s;",gm->query->name,gm->query_len);
2300 expr(dfp,"lenj = mat->%s->%s;",gm->target->name,gm->target_len);
2301 expr(dfp,"total = leni * lenj;");
2302
2303 add_break(dfp);
2304
2305 expr(dfp,"for(j=0;j<lenj;j++)");
2306 startbrace_tag(dfp,"for each j strip");
2307 expr(dfp,"for(i=0;i<leni;i++)");
2308 startbrace_tag(dfp,"for each i position in strip");
2309 expr(dfp,"num++");
2310
2311
2312 expr(dfp,"if( dpenv != NULL && is_in_DPEnvelope(dpenv,i,j) == FALSE )");
2313 startbrace_tag(dfp,"Is not in envelope");
2314
2315 for(i=0;i<gm->len;i++) {
2316 expr(dfp,"%s_DC_SHADOW_MATRIX(mat,i,j,%s) = NEGI",gm->name,gm->state[i]->name);
2317 }
2318 expr(dfp,"continue;");
2319 closebrace(dfp);
2320
2321
2322 expr(dfp,"if( num%%1000 == 0)");
2323 hang_expr(dfp,"log_full_error(REPORT,0,\"%%6d Cells done [%%2d%%%%%%%%]\",num,num*100/total);");
2324
2325 add_break(dfp);
2326
2327 write_main_shadow_block(dfp,gm,"DC_SHADOW_MATRIX","mat","DC_SHADOW_SPECIAL","DC_SHADOW_MATRIX_SP","DC_SHADOW_SPECIAL_SP",7,TRUE,TRUE,0,FALSE);
2328
2329 add_break(dfp);
2330
2331 closebrace(dfp);
2332
2333 if( gm->specialtospecial == TRUE )
2334 write_special_shadow_block(dfp,gm,"DC_SHADOW_MATRIX","mat","DC_SHADOW_SPECIAL","DC_SHADOW_MATRIX_SP","DC_SHADOW_SPECIAL_SP",7,TRUE,0);
2335
2336 closebrace(dfp);
2337
2338 expr(dfp,"return TRUE");
2339
2340 close_function(dfp);
2341
2342 add_break(dfp);
2343 }
2344
2345
2346
2347 # line 2286 "dynashadow.dy"
write_start_end_macros(DYNFILE * dfp,GenericMatrix * gm)2348 void write_start_end_macros(DYNFILE * dfp,GenericMatrix * gm)
2349 {
2350 macro(dfp,"#define %s_SE_SHADOW_MATRIX(thismatrix,i,j,state) (thismatrix->basematrix->matrix[((j+%d)*2) %% %d][(i+%d)*%d+state])",gm->name,gm->window_j+1,(gm->window_j+1)*2,gm->window_i,gm->len);
2351 macro(dfp,"#define %s_SE_SHADOW_SPECIAL(thismatrix,i,j,state) (thismatrix->basematrix->specmatrix[state*2][(j+%d)])",gm->name,gm->window_j);
2352 macro(dfp,"#define %s_SE_SHADOW_MATRIX_SP(thismatrix,i,j,state,shadow) (thismatrix->basematrix->matrix[( (((j+%d)*2)+(shadow+1)) %% %d)][(i+%d)*%d + state])",gm->name,gm->window_j+1,(gm->window_j+1)*2,gm->window_i,gm->len);
2353 macro(dfp,"#define %s_SE_SHADOW_SPECIAL_SP(thismatrix,i,j,state,shadow) (thismatrix->basematrix->specmatrix[state*2 +(shadow+1)][(j+%d)])",gm->name,gm->window_j);
2354
2355 add_break(dfp);
2356 }
2357
2358
2359 # line 2297 "dynashadow.dy"
write_shadow_start_end_alloc(DYNFILE * dfp,GenericMatrix * gm)2360 void write_shadow_start_end_alloc(DYNFILE * dfp,GenericMatrix * gm)
2361 {
2362 start_function(dfp,"%s * shadow_se_alloc_%s(int leni,int lenj)",gm->name,gm->name);
2363 expr(dfp,"register %s * out",gm->name);
2364
2365 add_break(dfp);
2366 add_block_comment(dfp,"Have to have enough memory to hold start for each state");
2367 add_break(dfp);
2368 add_block_comment(dfp,"This means we need (window_j+1)*2 top line pointers by cell number * leni");
2369 add_break(dfp);
2370
2371 expr(dfp,"out = %s_alloc()",gm->name);
2372 expr(dfp,"if(out == NULL)");
2373 hang_expr(dfp,"return NULL;");
2374 add_end_comment(dfp,"warning already issued");
2375
2376 add_break(dfp);
2377
2378 expr(dfp,"out->basematrix = BaseMatrix_alloc_matrix_and_specials(%d,(leni + %d) * %d,%d,lenj+%d)",(gm->window_j+1)*2,gm->window_i,gm->len,gm->spec_len*2,gm->window_j);
2379 expr(dfp,"if(out->basematrix == NULL)");
2380 startbrace(dfp);
2381 expr(dfp,"warn(\"In shadow_dc_alloc_%s unable to allocate basematrix with main matrix %d by %%d ints\",(leni+%d)*%d);",gm->name,(gm->window_j+1)*2,gm->window_i,gm->len);
2382 expr(dfp,"free_%s(out)",gm->name);
2383 expr(dfp,"return NULL;");
2384 closebrace(dfp);
2385
2386 add_break(dfp);
2387
2388 expr(dfp,"return out;");
2389
2390 close_function(dfp);
2391 add_break(dfp);
2392 }
2393
2394
2395 /* Function: write_main_shadow_block(dfp,gm,matrixtag,pointer_tag,specialtag,shadow_main_tag,shadow_special_tag,shadow_length,shadow_on_special,use_special,debug,use_shadow_pointer)
2396 *
2397 * Descrip: The core inner loop for shadow methods. Pretty terrifying stuff in here.
2398 *
2399 * Shadow is considered to be in the memory shadow_main_tag and shadow_special_tag
2400 * and usually has the form MATRIX_TYPE_MAIN/SPECIAL_SP.
2401 *
2402 * shadow has positions 0-length-1, as defined by shadow_length. These are
2403 * indexed by k.
2404 *
2405 * Either shadow_on_special is false
2406 * Some other routine has to place the shadow pointers. This routine just
2407 * propagates the shadow pointers around
2408 *
2409 * Or if shadow_on_special is true
2410 * This routines pushes when it leaves special and also pushes when it
2411 * enters special. This way, special states have the necessary information
2412 * to know where in the main matrix they were made from. Means there must be 7 shadow
2413 * positions.
2414 *
2415 * In addition, as a complete mess, shadow on special needs to have score independent
2416 * calcs added onto each movement, otherwise the scores are incorrect. So... this
2417 * is not *IDEAL* in the slightest!!!
2418 *
2419 *
2420 * Arg: dfp [UNKN ] Undocumented argument [DYNFILE *]
2421 * Arg: gm [UNKN ] Undocumented argument [GenericMatrix *]
2422 * Arg: matrixtag [UNKN ] Undocumented argument [char *]
2423 * Arg: pointer_tag [UNKN ] Undocumented argument [char *]
2424 * Arg: specialtag [UNKN ] Undocumented argument [char *]
2425 * Arg: shadow_main_tag [UNKN ] Undocumented argument [char *]
2426 * Arg: shadow_special_tag [UNKN ] Undocumented argument [char *]
2427 * Arg: shadow_length [UNKN ] Undocumented argument [int]
2428 * Arg: shadow_on_special [UNKN ] Undocumented argument [boolean]
2429 * Arg: use_special [UNKN ] Undocumented argument [boolean]
2430 * Arg: debug [UNKN ] Undocumented argument [int]
2431 * Arg: use_shadow_pointer [UNKN ] Undocumented argument [int]
2432 *
2433 */
2434 # line 2355 "dynashadow.dy"
write_main_shadow_block(DYNFILE * dfp,GenericMatrix * gm,char * matrixtag,char * pointer_tag,char * specialtag,char * shadow_main_tag,char * shadow_special_tag,int shadow_length,boolean shadow_on_special,boolean use_special,int debug,int use_shadow_pointer)2435 void write_main_shadow_block(DYNFILE * dfp,GenericMatrix * gm,char * matrixtag,char * pointer_tag,char * specialtag,char * shadow_main_tag,char * shadow_special_tag,int shadow_length,boolean shadow_on_special,boolean use_special,int debug,int use_shadow_pointer)
2436 {
2437 register int i;
2438 register int j;
2439 register int k;
2440
2441 /*** this function assummes the following local variables
2442
2443 int score
2444 int temp
2445 int k
2446 int localshadow[SHADOW_LENGTH]
2447 int * localsp
2448 ***/
2449
2450 if( shadow_on_special == TRUE && shadow_length != 7)
2451 warn("In writing main shadow block [main matrix tag %s], attempting to push on specials, and yet shadow_length is %d",matrixtag,shadow_length);
2452
2453 if( shadow_on_special == TRUE && use_special == FALSE ) {
2454 fatal("Look, you can't shaodw on special but not being using the specials... get otta here");
2455 }
2456
2457 for(i=0;i<gm->len;i++) {
2458 auto CellState * state;
2459 state = gm->state[i];
2460
2461 add_break(dfp);
2462
2463 add_block_comment(dfp,"For state %s",state->name);
2464 add_block_comment(dfp,"setting first movement to score",state->name);
2465
2466 /*********************************************************************/
2467 /* this line looks like */
2468 /* score = ProteinMatrix_EXPL_MATRIX(mat,i-1,j-1,MATCH) + xxxxx */
2469 /*********************************************************************/
2470
2471 if( shadow_on_special )
2472 expr(dfp,"score = %s_%s(%s,i-%d,j-%d,%s) + %s + (%s)",gm->name,matrixtag,pointer_tag,
2473 state->source[0]->offi,state->source[0]->offj,state->source[0]->state_source,
2474 state->source[0]->calc_expr,state->calc_expr == NULL ? "0" : state->calc_expr);
2475 else
2476 expr(dfp,"score = %s_%s(%s,i-%d,j-%d,%s) + %s",gm->name,matrixtag,pointer_tag,
2477 state->source[0]->offi,state->source[0]->offj,state->source[0]->state_source,
2478 state->source[0]->calc_expr);
2479
2480
2481 /*** must also shift shadown positions ***/
2482
2483 if( use_shadow_pointer == FALSE ) {
2484 add_block_comment(dfp,"shift first shadow numbers");
2485
2486 expr(dfp,"for(k=0;k<%d;k++)",shadow_length);
2487
2488 hang_expr(dfp,"localshadow[k] = %s_%s(mat,i - %d,j - %d,%s,k);",
2489 gm->name,state->source[0]->isspecial == TRUE ? shadow_special_tag : shadow_main_tag,
2490 state->source[0]->offi,state->source[0]->offj,state->source[0]->state_source);
2491 } else {
2492 add_block_comment(dfp,"assign local shadown pointer");
2493 expr(dfp,"localsp = &(%s_%s(mat,i - %d,j - %d,%s,0));",
2494 gm->name,state->source[0]->isspecial == TRUE ? shadow_special_tag : shadow_main_tag,
2495 state->source[0]->offi,state->source[0]->offj,state->source[0]->state_source);
2496 }
2497
2498
2499 /**** ok this is to stop underflow, but is v.v.v. hacky ****/
2500 /*** removing underflow hack
2501 expr(dfp,"if(score < (-10000000) )");
2502 hang_expr(dfp,"score = (-10000000)");
2503 ****/
2504
2505
2506 /****************************************/
2507 /* now we do if then on score and temp */
2508 /****************************************/
2509
2510 for(j=1;j<state->len;j++) {
2511
2512 if( use_special == FALSE && state->source[j]->isspecial == TRUE )
2513 continue;
2514
2515
2516
2517 add_block_comment(dfp,"From state %s to state %s",state->source[j]->state_source,
2518 state->name);
2519
2520 /*** ok, really nasty piece coming up: The expr is going to change wrt to things
2521 a) using special or not (which will require source independent score to be added)
2522 b) special source or not.
2523
2524 Hence the nested if. Ugh.
2525
2526 ***/
2527
2528 if( shadow_on_special ) {
2529
2530 /** add in source-independent score **/
2531
2532 if( state->source[j]->isspecial == TRUE )
2533 expr(dfp,"temp = %s_%s(%s,i-%d,j-%d,%s) + %s + (%s)",gm->name,specialtag,pointer_tag,
2534 state->source[j]->offi,state->source[j]->offj,state->source[j]->state_source,
2535 state->source[j]->calc_expr,state->calc_expr == NULL ? "0" : state->calc_expr);
2536 else expr(dfp,"temp = %s_%s(%s,i-%d,j-%d,%s) + %s +(%s)",gm->name,matrixtag,pointer_tag,
2537 state->source[j]->offi,state->source[j]->offj,state->source[j]->state_source,
2538 state->source[j]->calc_expr,state->calc_expr == NULL ? "0" : state->calc_expr);
2539 }
2540 else {
2541
2542 if( state->source[j]->isspecial == TRUE )
2543 expr(dfp,"temp = %s_%s(%s,i-%d,j-%d,%s) + %s",gm->name,specialtag,pointer_tag,
2544 state->source[j]->offi,state->source[j]->offj,state->source[j]->state_source,
2545 state->source[j]->calc_expr);
2546 else expr(dfp,"temp = %s_%s(%s,i-%d,j-%d,%s) + %s",gm->name,matrixtag,pointer_tag,
2547 state->source[j]->offi,state->source[j]->offj,state->source[j]->state_source,
2548 state->source[j]->calc_expr);
2549 }
2550
2551
2552 /**** ok this is to stop underflow, but is v.v.v. hacky ****/
2553 /**** removing underflow hack
2554 expr(dfp,"if(score < (-10000000) )");
2555 hang_expr(dfp,"score = (-10000000)");
2556 ****/
2557
2558 if( debug == 2 )
2559 expr(dfp,"fprintf(stderr,\"[%%4d,%%4d] Score of %s from %s gets %%d\\n\",i,j,temp)",state->name,state->source[j]->state_source );
2560
2561
2562 expr(dfp,"if( temp > score )");
2563 startbrace(dfp);
2564 expr(dfp,"score = temp;");
2565 /** ok for shadow matrix should put things in here */
2566
2567 if( shadow_on_special == TRUE && state->source[j]->isspecial == TRUE) {
2568 add_block_comment(dfp,"This state [%s] is a special for %s... push top shadow pointers here",state->source[j]->state_source,state->name);
2569 expr(dfp,"localshadow[0]= i;");
2570 expr(dfp,"localshadow[1]= j;");
2571 expr(dfp,"localshadow[2]= %s;",state->name);
2572 expr(dfp,"localshadow[3]= (-1);");
2573 expr(dfp,"localshadow[4]= (-1);");
2574 expr(dfp,"localshadow[5]= (-1);");
2575 expr(dfp,"localshadow[6]= score;");
2576 if( use_shadow_pointer == TRUE ) {
2577 expr(dfp,"localsp = localshadow;");
2578 }
2579 }
2580 else {
2581
2582 if( use_shadow_pointer == FALSE ) {
2583 expr(dfp,"for(k=0;k<%d;k++)",shadow_length);
2584
2585 hang_expr(dfp,"localshadow[k] = %s_%s(mat,i - %d,j - %d,%s,k);",
2586 gm->name,state->source[0]->isspecial == TRUE ? shadow_special_tag : shadow_main_tag,
2587 state->source[j]->offi,state->source[j]->offj,state->source[j]->state_source);
2588
2589 /*** now using local shadow system
2590 hang_expr(dfp,"%s_%s(%s,i,j,%s,k) = %s_%s(%s,i - %d,j - %d,%s,k);",
2591 gm->name,shadow_main_tag,pointer_tag,state->name,
2592 gm->name,state->source[j]->isspecial == TRUE ? shadow_special_tag : shadow_main_tag,pointer_tag,state->source[j]->offi,
2593 state->source[j]->offj,state->source[j]->state_source);
2594 ***/
2595 } else {
2596 add_block_comment(dfp,"assign local shadown pointer");
2597 expr(dfp,"localsp = &(%s_%s(mat,i - %d,j - %d,%s,0));",
2598 gm->name,state->source[j]->isspecial == TRUE ? shadow_special_tag : shadow_main_tag,
2599 state->source[j]->offi,state->source[j]->offj,state->source[j]->state_source);
2600 }
2601
2602 }
2603
2604
2605 /*** end if score > temp ***/
2606 closebrace(dfp);
2607 }
2608
2609 /************************/
2610 /* finished blocks */
2611 /* put in global calc */
2612 /************************/
2613 add_break(dfp);
2614 add_block_comment(dfp,"Ok - finished max calculation for %s",state->name);
2615 add_block_comment(dfp,"Add any movement independant score and put away");
2616
2617 if( shadow_on_special )
2618 add_block_comment(dfp,"Actually, already done inside scores");
2619 else if( state->calc_expr != NULL)
2620 expr(dfp," score += %s",state->calc_expr);
2621
2622
2623
2624 /***************************/
2625 /* put away score */
2626 /***************************/
2627
2628 expr(dfp," %s_%s(%s,i,j,%s) = score;",gm->name,matrixtag,pointer_tag,state->name);
2629
2630
2631 /***************************/
2632 /* put away localshadow */
2633 /***************************/
2634
2635 if( use_shadow_pointer == FALSE ) {
2636 expr(dfp,"for(k=0;k<%d;k++)",shadow_length);
2637 hang_expr(dfp,"%s_%s(%s,i,j,%s,k) = localshadow[k];",gm->name,shadow_main_tag,pointer_tag,state->name);
2638 } else {
2639 expr(dfp,"for(k=0;k<%d;k++)",shadow_length);
2640 hang_expr(dfp,"%s_%s(%s,i,j,%s,k) = localsp[k];",gm->name,shadow_main_tag,pointer_tag,state->name);
2641 }
2642
2643 add_block_comment(dfp,"Now figure out if any specials need this score");
2644
2645 if( use_special == FALSE ) {
2646 add_block_comment(dfp,"Finished calculating state %s",state->name);
2647 continue; /** back to for i over state **/
2648 }
2649
2650
2651 /************************/
2652 /* for each special */
2653 /* thats has this as */
2654 /* source we have to */
2655 /* update */
2656 /************************/
2657
2658 for(j=0;j<gm->spec_len;j++) {
2659 auto CellState * specstate;
2660 specstate = gm->special[j];
2661
2662
2663 for(k=0;k<specstate->len;k++) {
2664 if( strcmp(specstate->source[k]->state_source,state->name) == 0) {
2665 /********************************/
2666 /* is a special source! */
2667 /********************************/
2668 add_break(dfp);
2669 add_block_comment(dfp,"state %s is a source for special %s",state->name,specstate->name);
2670 expr(dfp,"temp = score + (%s) + (%s) ",specstate->source[k]->calc_expr,specstate->calc_expr == NULL ? "0" : specstate->calc_expr );
2671 expr(dfp,"if( temp > %s_%s(%s,i,j,%s) ) ",gm->name,specialtag,pointer_tag,specstate->name);
2672 startbrace(dfp);
2673 expr(dfp,"%s_%s(%s,i,j,%s) = temp",gm->name,specialtag,pointer_tag,specstate->name);
2674
2675 if(shadow_on_special == TRUE ) {
2676 add_block_comment(dfp,"Have to push only bottem half of system here");
2677 expr(dfp,"for(k=0;k<3;k++)");
2678 hang_expr(dfp,"%s_%s(%s,i,j,%s,k) = %s_%s(%s,i,j,%s,k);",
2679 gm->name,shadow_special_tag,pointer_tag,
2680 specstate->name, gm->name,
2681 specstate->source[k]->isspecial == TRUE ? shadow_special_tag : shadow_main_tag,
2682 pointer_tag,state->name);
2683
2684 /*** sort of hacky ***/
2685 expr(dfp,"%s_%s(%s,i,j,%s,6) = %s_%s(%s,i,j,%s,6);",
2686 gm->name,shadow_special_tag,pointer_tag,
2687 specstate->name, gm->name,
2688 specstate->source[k]->isspecial == TRUE ? shadow_special_tag : shadow_main_tag,
2689 pointer_tag,state->name);
2690
2691
2692 expr(dfp,"%s_%s(%s,i,j,%s,3) = i;",gm->name,shadow_special_tag,pointer_tag,specstate->name);
2693 expr(dfp,"%s_%s(%s,i,j,%s,4) = j;",gm->name,shadow_special_tag,pointer_tag,specstate->name);
2694 expr(dfp,"%s_%s(%s,i,j,%s,5) = %s;",gm->name,shadow_special_tag,pointer_tag,specstate->name,state->name);
2695 }
2696 else { /** not pushing on specials, pushing elsewhere **/
2697
2698
2699
2700 expr(dfp,"for(k=0;k<%d;k++)",shadow_length);
2701 hang_expr(dfp,"%s_%s(%s,i,j,%s,k) = %s_%s(%s,i,j,%s,k);",gm->name,shadow_special_tag,pointer_tag,
2702 specstate->name, gm->name,specstate->source[k]->isspecial == TRUE ? shadow_special_tag : shadow_main_tag,
2703 pointer_tag,state->name);
2704 }
2705
2706 closebrace(dfp);
2707 add_break(dfp);
2708
2709 }
2710 }
2711 }
2712
2713
2714 add_break(dfp);
2715 add_block_comment(dfp,"Finished calculating state %s",state->name);
2716
2717 } /* end of for each state */
2718
2719 }
2720
2721
2722
2723 # line 2643 "dynashadow.dy"
write_special_shadow_block(DYNFILE * dfp,GenericMatrix * gm,char * matrix,char * pointer_tag,char * special,char * shadow_main_tag,char * shadow_special_tag,int shadow_length,boolean shadow_on_special,int debug)2724 void write_special_shadow_block(DYNFILE * dfp,GenericMatrix * gm,char * matrix,char * pointer_tag,char * special,char * shadow_main_tag,char * shadow_special_tag,int shadow_length,boolean shadow_on_special,int debug)
2725 {
2726 register int i;
2727 register int j;
2728
2729
2730 for(i=0;i<gm->spec_len;i++) {
2731 auto CellState * state;
2732 state = gm->special[i];
2733 add_break(dfp);
2734 if( state->specialtospecial == FALSE ) {
2735 add_block_comment(dfp,"Special state %s has no special to special movements",state->name);
2736 continue;
2737 }
2738
2739 add_block_comment(dfp,"Special state %s has special to speical",state->name);
2740
2741 add_block_comment(dfp,"Set score to current score (remember, state probably updated during main loop");
2742 expr(dfp,"score = %s_%s(mat,0,j,%s);",gm->name,special,state->name);
2743 add_break(dfp);
2744 for(j=0;j < state->len;j++) {
2745 auto CellSource * source;
2746 source = state->source[j];
2747
2748 if( source->isspecial == FALSE ) {
2749 add_block_comment(dfp,"Source %s for state %s is not special... already calculated",source->state_source,state->name);
2750 continue; /** back to for j **/
2751 }
2752
2753 add_block_comment(dfp,"Source %s is a special source for %s",source->state_source,state->name);
2754 expr(dfp,"temp = %s_%s(%s,0,j - %d,%s) + (%s) + (%s)",gm->name,special,pointer_tag,source->offj,source->state_source,
2755 source->calc_expr,state->calc_expr == NULL ? "0" : state->calc_expr);
2756 expr(dfp,"if( temp > score )");
2757 startbrace(dfp);
2758 expr(dfp,"score = temp");
2759 add_block_comment(dfp,"Also got to propagate shadows ");
2760 expr(dfp,"for(k=0;k<%d;k++)",shadow_length);
2761 hang_expr(dfp,"%s_%s(%s,i,j,%s,k) = %s_%s(%s,i - %d,j - %d,%s,k);",
2762 gm->name,shadow_special_tag,pointer_tag,state->name,
2763 gm->name,shadow_special_tag,pointer_tag,state->source[j]->offi,
2764 state->source[j]->offj,state->source[j]->state_source);
2765 closebrace(dfp);
2766
2767
2768 add_break(dfp);
2769 }
2770 add_block_comment(dfp,"Put back score... (now updated!)");
2771 expr(dfp,"%s_%s(mat,0,j,%s) = score;",gm->name,special,state->name);
2772 add_block_comment(dfp,"Finished updating state %s",state->name);
2773 add_break(dfp);
2774 }
2775 }
2776
2777
2778 # line 2759 "dynashadow.c"
2779
2780 #ifdef _cplusplus
2781 }
2782 #endif
2783