Routino SVN Repository Browser

Check out the latest version of Routino: svn co http://routino.org/svn/trunk routino

/[routino]/trunk/src/waysx.c
ViewVC logotype

Contents of /trunk/src/waysx.c

Parent Directory Parent Directory | Revision Log Revision Log

Revision 1317 - (show annotations) (download) (as text)
Sun May 12 18:00:25 2013 UTC (11 years, 10 months ago) by amb
File MIME type: text/x-csrc
File size: 18420 byte(s) 
Add functions to process the binary error log file and convert it into a
geographically searchable database.
1 /***************************************
2 Extended Way data type functions.
3
4 Part of the Routino routing software.
5 ******************/ /******************
6 This file Copyright 2008-2013 Andrew M. Bishop
7
8 This program is free software: you can redistribute it and/or modify
9 it under the terms of the GNU Affero General Public License as published by
10 the Free Software Foundation, either version 3 of the License, or
11 (at your option) any later version.
12
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU Affero General Public License for more details.
17
18 You should have received a copy of the GNU Affero General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>.
20 ***************************************/
21
22
23 #include <stdlib.h>
24 #include <string.h>
25
26 #include "types.h"
27 #include "ways.h"
28
29 #include "typesx.h"
30 #include "segmentsx.h"
31 #include "waysx.h"
32
33 #include "files.h"
34 #include "logging.h"
35 #include "sorting.h"
36
37
38 /* Global variables */
39
40 /*+ The command line '--tmpdir' option or its default value. +*/
41 extern char *option_tmpdirname;
42
43 /* Local variables */
44
45 /*+ Temporary file-local variables for use by the sort functions. +*/
46 static WaysX *sortwaysx;
47 static SegmentsX *sortsegmentsx;
48
49 /* Local functions */
50
51 static int sort_by_id(WayX *a,WayX *b);
52 static int deduplicate_by_id(WayX *wayx,index_t index);
53
54 static int sort_by_name(WayX *a,WayX *b);
55 static int index_by_id(WayX *wayx,index_t index);
56
57 static int delete_unused(WayX *wayx,index_t index);
58 static int sort_by_name_and_prop_and_id(WayX *a,WayX *b);
59 static int deduplicate_and_index_by_compact_id(WayX *wayx,index_t index);
60
61
62 /*++++++++++++++++++++++++++++++++++++++
63 Allocate a new way list (create a new file or open an existing one).
64
65 WaysX *NewWayList Returns the way list.
66
67 int append Set to 1 if the file is to be opened for appending.
68
69 int readonly Set to 1 if the file is to be opened for reading.
70 ++++++++++++++++++++++++++++++++++++++*/
71
72 WaysX *NewWayList(int append,int readonly)
73 {
74 WaysX *waysx;
75
76 waysx=(WaysX*)calloc(1,sizeof(WaysX));
77
78 logassert(waysx,"Failed to allocate memory (try using slim mode?)"); /* Check calloc() worked */
79
80 waysx->filename =(char*)malloc(strlen(option_tmpdirname)+32);
81 waysx->filename_tmp=(char*)malloc(strlen(option_tmpdirname)+32);
82
83 sprintf(waysx->filename ,"%s/waysx.parsed.mem",option_tmpdirname);
84 sprintf(waysx->filename_tmp,"%s/waysx.%p.tmp" ,option_tmpdirname,(void*)waysx);
85
86 if(append || readonly)
87 if(ExistsFile(waysx->filename))
88 {
89 off_t size,position=0;
90 int fd;
91
92 size=SizeFile(waysx->filename);
93
94 fd=ReOpenFile(waysx->filename);
95
96 while(position<size)
97 {
98 FILESORT_VARINT waysize;
99
100 SeekReadFile(fd,&waysize,FILESORT_VARSIZE,position);
101
102 waysx->number++;
103 position+=waysize+FILESORT_VARSIZE;
104 }
105
106 CloseFile(fd);
107
108 RenameFile(waysx->filename,waysx->filename_tmp);
109 }
110
111 if(append)
112 waysx->fd=OpenFileAppend(waysx->filename_tmp);
113 else if(!readonly)
114 waysx->fd=OpenFileNew(waysx->filename_tmp);
115 else
116 waysx->fd=-1;
117
118 #if SLIM
119 waysx->cache=NewWayXCache();
120 #endif
121
122
123 waysx->nfilename_tmp=(char*)malloc(strlen(option_tmpdirname)+32);
124
125 sprintf(waysx->nfilename_tmp,"%s/waynames.%p.tmp",option_tmpdirname,(void*)waysx);
126
127 return(waysx);
128 }
129
130
131 /*++++++++++++++++++++++++++++++++++++++
132 Free a way list.
133
134 WaysX *waysx The set of ways to be freed.
135
136 int keep If set then the results file is to be kept.
137 ++++++++++++++++++++++++++++++++++++++*/
138
139 void FreeWayList(WaysX *waysx,int keep)
140 {
141 if(keep)
142 RenameFile(waysx->filename_tmp,waysx->filename);
143 else
144 DeleteFile(waysx->filename_tmp);
145
146 free(waysx->filename);
147 free(waysx->filename_tmp);
148
149 if(waysx->idata)
150 free(waysx->idata);
151
152 if(waysx->odata)
153 free(waysx->odata);
154
155 if(waysx->cdata)
156 free(waysx->cdata);
157
158 DeleteFile(waysx->nfilename_tmp);
159
160 free(waysx->nfilename_tmp);
161
162 #if SLIM
163 DeleteWayXCache(waysx->cache);
164 #endif
165
166 free(waysx);
167 }
168
169
170 /*++++++++++++++++++++++++++++++++++++++
171 Append a single way to an unsorted way list.
172
173 WaysX *waysx The set of ways to process.
174
175 way_t id The ID of the way.
176
177 Way *way The way data itself.
178
179 const char *name The name or reference of the way.
180 ++++++++++++++++++++++++++++++++++++++*/
181
182 void AppendWayList(WaysX *waysx,way_t id,Way *way,const char *name)
183 {
184 WayX wayx;
185 FILESORT_VARINT size;
186
187 wayx.id=id;
188 wayx.way=*way;
189
190 size=sizeof(WayX)+strlen(name)+1;
191
192 WriteFile(waysx->fd,&size,FILESORT_VARSIZE);
193 WriteFile(waysx->fd,&wayx,sizeof(WayX));
194 WriteFile(waysx->fd,name,strlen(name)+1);
195
196 waysx->number++;
197
198 logassert(waysx->number!=0,"Too many ways (change index_t to 64-bits?)"); /* Zero marks the high-water mark for ways. */
199 }
200
201
202 /*++++++++++++++++++++++++++++++++++++++
203 Finish appending ways and change the filename over.
204
205 WaysX *waysx The ways that have been appended.
206 ++++++++++++++++++++++++++++++++++++++*/
207
208 void FinishWayList(WaysX *waysx)
209 {
210 if(waysx->fd!=-1)
211 waysx->fd=CloseFile(waysx->fd);
212 }
213
214
215 /*++++++++++++++++++++++++++++++++++++++
216 Find a particular way index.
217
218 index_t IndexWayX Returns the index of the extended way with the specified id.
219
220 WaysX *waysx The set of ways to process.
221
222 way_t id The way id to look for.
223 ++++++++++++++++++++++++++++++++++++++*/
224
225 index_t IndexWayX(WaysX *waysx,way_t id)
226 {
227 index_t start=0;
228 index_t end=waysx->number-1;
229 index_t mid;
230
231 if(waysx->number==0) /* There are no ways */
232 return(NO_WAY);
233
234 if(id<waysx->idata[start]) /* Key is before start */
235 return(NO_WAY);
236
237 if(id>waysx->idata[end]) /* Key is after end */
238 return(NO_WAY);
239
240 /* Binary search - search key exact match only is required.
241 *
242 * # <- start | Check mid and move start or end if it doesn't match
243 * # |
244 * # | Since an exact match is wanted we can set end=mid-1
245 * # <- mid | or start=mid+1 because we know that mid doesn't match.
246 * # |
247 * # | Eventually either end=start or end=start+1 and one of
248 * # <- end | start or end is the wanted one.
249 */
250
251 do
252 {
253 mid=(start+end)/2; /* Choose mid point */
254
255 if(waysx->idata[mid]<id) /* Mid point is too low */
256 start=mid+1;
257 else if(waysx->idata[mid]>id) /* Mid point is too high */
258 end=mid?(mid-1):mid;
259 else /* Mid point is correct */
260 return(mid);
261 }
262 while((end-start)>1);
263
264 if(waysx->idata[start]==id) /* Start is correct */
265 return(start);
266
267 if(waysx->idata[end]==id) /* End is correct */
268 return(end);
269
270 return(NO_WAY);
271 }
272
273
274 /*++++++++++++++++++++++++++++++++++++++
275 Sort the list of ways.
276
277 WaysX *waysx The set of ways to process.
278 ++++++++++++++++++++++++++++++++++++++*/
279
280 void SortWayList(WaysX *waysx)
281 {
282 index_t xnumber;
283 int fd;
284
285 /* Print the start message */
286
287 printf_first("Sorting Ways");
288
289 /* Re-open the file read-only and a new file writeable */
290
291 waysx->fd=ReOpenFile(waysx->filename_tmp);
292
293 DeleteFile(waysx->filename_tmp);
294
295 fd=OpenFileNew(waysx->filename_tmp);
296
297 /* Sort the ways by ID and index them */
298
299 xnumber=waysx->number;
300
301 waysx->number=filesort_vary(waysx->fd,fd,NULL,
302 (int (*)(const void*,const void*))sort_by_id,
303 (int (*)(void*,index_t))deduplicate_by_id);
304
305 /* Close the files */
306
307 waysx->fd=CloseFile(waysx->fd);
308 CloseFile(fd);
309
310 /* Print the final message */
311
312 printf_last("Sorted Ways: Ways=%"Pindex_t" Duplicates=%"Pindex_t,xnumber,xnumber-waysx->number);
313 }
314
315
316 /*++++++++++++++++++++++++++++++++++++++
317 Sort the ways into id order.
318
319 int sort_by_id Returns the comparison of the id fields.
320
321 WayX *a The first extended way.
322
323 WayX *b The second extended way.
324 ++++++++++++++++++++++++++++++++++++++*/
325
326 static int sort_by_id(WayX *a,WayX *b)
327 {
328 way_t a_id=a->id;
329 way_t b_id=b->id;
330
331 if(a_id<b_id)
332 return(-1);
333 else if(a_id>b_id)
334 return(1);
335 else
336 return(-FILESORT_PRESERVE_ORDER(a,b)); /* latest version first */
337 }
338
339
340 /*++++++++++++++++++++++++++++++++++++++
341 Discard duplicate ways.
342
343 int deduplicate_by_id Return 1 if the value is to be kept, otherwise 0.
344
345 WayX *wayx The extended way.
346
347 index_t index The number of sorted ways that have already been written to the output file.
348 ++++++++++++++++++++++++++++++++++++++*/
349
350 static int deduplicate_by_id(WayX *wayx,index_t index)
351 {
352 static way_t previd=NO_WAY_ID;
353
354 if(wayx->id!=previd)
355 {
356 previd=wayx->id;
357
358 if(wayx->way.type==WAY_DELETED)
359 return(0);
360 else
361 return(1);
362 }
363 else
364 return(0);
365 }
366
367
368 /*++++++++++++++++++++++++++++++++++++++
369 Extract the way names from the ways and reference the list of names from the ways.
370
371 WaysX *waysx The set of ways to process.
372
373 int keep If set to 1 then keep the old data file otherwise delete it.
374 ++++++++++++++++++++++++++++++++++++++*/
375
376 void ExtractWayNames(WaysX *waysx,int keep)
377 {
378 index_t i;
379 int fd;
380 char *names[2]={NULL,NULL};
381 int namelen[2]={0,0};
382 int nnames=0;
383 uint32_t lastlength=0;
384
385 /* Print the start message */
386
387 printf_first("Sorting Ways by Name");
388
389 /* Re-open the file read-only and a new file writeable */
390
391 waysx->fd=ReOpenFile(waysx->filename_tmp);
392
393 if(keep)
394 RenameFile(waysx->filename_tmp,waysx->filename);
395 else
396 DeleteFile(waysx->filename_tmp);
397
398 waysx->knumber=waysx->number;
399
400 fd=OpenFileNew(waysx->filename_tmp);
401
402 /* Sort the ways to allow separating the names */
403
404 filesort_vary(waysx->fd,fd,NULL,
405 (int (*)(const void*,const void*))sort_by_name,
406 NULL);
407
408 /* Close the files */
409
410 waysx->fd=CloseFile(waysx->fd);
411 CloseFile(fd);
412
413 /* Print the final message */
414
415 printf_last("Sorted Ways by Name: Ways=%"Pindex_t,waysx->number);
416
417
418 /* Print the start message */
419
420 printf_first("Separating Way Names: Ways=0 Names=0");
421
422 /* Re-open the file read-only and new files writeable */
423
424 waysx->fd=ReOpenFile(waysx->filename_tmp);
425
426 DeleteFile(waysx->filename_tmp);
427
428 fd=OpenFileNew(waysx->filename_tmp);
429
430 waysx->nfd=OpenFileNew(waysx->nfilename_tmp);
431
432 /* Copy from the single file into two files */
433
434 for(i=0;i<waysx->number;i++)
435 {
436 WayX wayx;
437 FILESORT_VARINT size;
438
439 ReadFile(waysx->fd,&size,FILESORT_VARSIZE);
440
441 if(namelen[nnames%2]<size)
442 names[nnames%2]=(char*)realloc((void*)names[nnames%2],namelen[nnames%2]=size);
443
444 ReadFile(waysx->fd,&wayx,sizeof(WayX));
445 ReadFile(waysx->fd,names[nnames%2],size-sizeof(WayX));
446
447 if(nnames==0 || strcmp(names[0],names[1]))
448 {
449 WriteFile(waysx->nfd,names[nnames%2],size-sizeof(WayX));
450
451 lastlength=waysx->nlength;
452 waysx->nlength+=size-sizeof(WayX);
453
454 nnames++;
455 }
456
457 wayx.way.name=lastlength;
458
459 WriteFile(fd,&wayx,sizeof(WayX));
460
461 if(!((i+1)%1000))
462 printf_middle("Separating Way Names: Ways=%"Pindex_t" Names=%"Pindex_t,i+1,nnames);
463 }
464
465 if(names[0]) free(names[0]);
466 if(names[1]) free(names[1]);
467
468 /* Close the files */
469
470 waysx->fd=CloseFile(waysx->fd);
471 CloseFile(fd);
472
473 waysx->nfd=CloseFile(waysx->nfd);
474
475 /* Print the final message */
476
477 printf_last("Separated Way Names: Ways=%"Pindex_t" Names=%"Pindex_t,waysx->number,nnames);
478
479
480 /* Print the start message */
481
482 printf_first("Sorting Ways");
483
484 /* Re-open the file read-only and a new file writeable */
485
486 waysx->fd=ReOpenFile(waysx->filename_tmp);
487
488 DeleteFile(waysx->filename_tmp);
489
490 fd=OpenFileNew(waysx->filename_tmp);
491
492 /* Allocate the array of indexes */
493
494 waysx->idata=(way_t*)malloc(waysx->number*sizeof(way_t));
495
496 logassert(waysx->idata,"Failed to allocate memory (try using slim mode?)"); /* Check malloc() worked */
497
498 /* Sort the ways by ID */
499
500 sortwaysx=waysx;
501
502 filesort_fixed(waysx->fd,fd,sizeof(WayX),NULL,
503 (int (*)(const void*,const void*))sort_by_id,
504 (int (*)(void*,index_t))index_by_id);
505
506 /* Close the files */
507
508 waysx->fd=CloseFile(waysx->fd);
509 CloseFile(fd);
510
511 /* Print the final message */
512
513 printf_last("Sorted Ways: Ways=%"Pindex_t,waysx->number);
514 }
515
516
517 /*++++++++++++++++++++++++++++++++++++++
518 Sort the ways into name order and then id order.
519
520 int sort_by_name Returns the comparison of the name fields.
521
522 WayX *a The first extended Way.
523
524 WayX *b The second extended Way.
525 ++++++++++++++++++++++++++++++++++++++*/
526
527 static int sort_by_name(WayX *a,WayX *b)
528 {
529 int compare;
530 char *a_name=(char*)a+sizeof(WayX);
531 char *b_name=(char*)b+sizeof(WayX);
532
533 compare=strcmp(a_name,b_name);
534
535 if(compare)
536 return(compare);
537 else
538 return(FILESORT_PRESERVE_ORDER(a,b));
539 }
540
541
542 /*++++++++++++++++++++++++++++++++++++++
543 Create the index of identifiers.
544
545 int index_by_id Return 1 if the value is to be kept, otherwise 0.
546
547 WayX *wayx The extended way.
548
549 index_t index The number of sorted ways that have already been written to the output file.
550 ++++++++++++++++++++++++++++++++++++++*/
551
552 static int index_by_id(WayX *wayx,index_t index)
553 {
554 sortwaysx->idata[index]=wayx->id;
555
556 return(1);
557 }
558
559
560 /*++++++++++++++++++++++++++++++++++++++
561 Compact the way list, removing duplicated ways and unused ways.
562
563 WaysX *waysx The set of ways to process.
564
565 SegmentsX *segmentsx The set of segments to check.
566 ++++++++++++++++++++++++++++++++++++++*/
567
568 void CompactWayList(WaysX *waysx,SegmentsX *segmentsx)
569 {
570 int fd;
571 index_t cnumber;
572
573 if(waysx->number==0)
574 return;
575
576 /* Print the start message */
577
578 printf_first("Sorting Ways and Compacting");
579
580 /* Allocate the array of indexes */
581
582 waysx->cdata=(index_t*)malloc(waysx->number*sizeof(index_t));
583
584 logassert(waysx->cdata,"Failed to allocate memory (try using slim mode?)"); /* Check malloc() worked */
585
586 /* Re-open the file read-only and a new file writeable */
587
588 waysx->fd=ReOpenFile(waysx->filename_tmp);
589
590 DeleteFile(waysx->filename_tmp);
591
592 fd=OpenFileNew(waysx->filename_tmp);
593
594 /* Sort the ways to allow compacting according to the properties */
595
596 sortwaysx=waysx;
597 sortsegmentsx=segmentsx;
598
599 cnumber=filesort_fixed(waysx->fd,fd,sizeof(WayX),(int (*)(void*,index_t))delete_unused,
600 (int (*)(const void*,const void*))sort_by_name_and_prop_and_id,
601 (int (*)(void*,index_t))deduplicate_and_index_by_compact_id);
602
603 /* Close the files */
604
605 waysx->fd=CloseFile(waysx->fd);
606 CloseFile(fd);
607
608 /* Print the final message */
609
610 printf_last("Sorted and Compacted Ways: Ways=%"Pindex_t" Unique=%"Pindex_t,waysx->number,cnumber);
611 waysx->number=cnumber;
612
613 free(segmentsx->usedway);
614 segmentsx->usedway=NULL;
615 }
616
617
618 /*++++++++++++++++++++++++++++++++++++++
619 Delete the ways that are no longer being used.
620
621 int delete_unused Return 1 if the value is to be kept, otherwise 0.
622
623 WayX *wayx The extended way.
624
625 index_t index The number of unsorted ways that have been read from the input file.
626 ++++++++++++++++++++++++++++++++++++++*/
627
628 static int delete_unused(WayX *wayx,index_t index)
629 {
630 if(sortsegmentsx && !IsBitSet(sortsegmentsx->usedway,index))
631 {
632 sortwaysx->cdata[index]=NO_WAY;
633
634 return(0);
635 }
636 else
637 {
638 wayx->id=index;
639
640 return(1);
641 }
642 }
643
644
645 /*++++++++++++++++++++++++++++++++++++++
646 Sort the ways into name, properties and id order.
647
648 int sort_by_name_and_prop_and_id Returns the comparison of the name, properties and id fields.
649
650 WayX *a The first extended Way.
651
652 WayX *b The second extended Way.
653 ++++++++++++++++++++++++++++++++++++++*/
654
655 static int sort_by_name_and_prop_and_id(WayX *a,WayX *b)
656 {
657 int compare;
658 index_t a_name=a->way.name;
659 index_t b_name=b->way.name;
660
661 if(a_name<b_name)
662 return(-1);
663 else if(a_name>b_name)
664 return(1);
665
666 compare=WaysCompare(&a->way,&b->way);
667
668 if(compare)
669 return(compare);
670
671 return(sort_by_id(a,b));
672 }
673
674
675 /*++++++++++++++++++++++++++++++++++++++
676 Create the index of compacted Way identifiers and ignore Ways with duplicated properties.
677
678 int deduplicate_and_index_by_compact_id Return 1 if the value is to be kept, otherwise 0.
679
680 WayX *wayx The extended way.
681
682 index_t index The number of sorted ways that have already been written to the output file.
683 ++++++++++++++++++++++++++++++++++++++*/
684
685 static int deduplicate_and_index_by_compact_id(WayX *wayx,index_t index)
686 {
687 static Way lastway;
688
689 if(index==0 || wayx->way.name!=lastway.name || WaysCompare(&lastway,&wayx->way))
690 {
691 lastway=wayx->way;
692
693 sortwaysx->cdata[wayx->id]=index;
694
695 wayx->id=index;
696
697 return(1);
698 }
699 else
700 {
701 sortwaysx->cdata[wayx->id]=index-1;
702
703 return(0);
704 }
705 }
706
707
708 /*++++++++++++++++++++++++++++++++++++++
709 Save the way list to a file.
710
711 WaysX *waysx The set of ways to save.
712
713 const char *filename The name of the file to save.
714 ++++++++++++++++++++++++++++++++++++++*/
715
716 void SaveWayList(WaysX *waysx,const char *filename)
717 {
718 index_t i;
719 int fd;
720 index_t position=0;
721 WayX wayx;
722 WaysFile waysfile={0};
723 highways_t highways=0;
724 transports_t allow=0;
725 properties_t props=0;
726
727 /* Print the start message */
728
729 printf_first("Writing Ways: Ways=0");
730
731 /* Re-open the files */
732
733 waysx->fd=ReOpenFile(waysx->filename_tmp);
734 waysx->nfd=ReOpenFile(waysx->nfilename_tmp);
735
736 /* Write out the ways data */
737
738 fd=OpenFileNew(filename);
739
740 SeekFile(fd,sizeof(WaysFile));
741
742 for(i=0;i<waysx->number;i++)
743 {
744 ReadFile(waysx->fd,&wayx,sizeof(WayX));
745
746 highways|=HIGHWAYS(wayx.way.type);
747 allow |=wayx.way.allow;
748 props |=wayx.way.props;
749
750 WriteFile(fd,&wayx.way,sizeof(Way));
751
752 if(!((i+1)%1000))
753 printf_middle("Writing Ways: Ways=%"Pindex_t,i+1);
754 }
755
756 /* Write out the ways names */
757
758 SeekFile(fd,sizeof(WaysFile)+(off_t)waysx->number*sizeof(Way));
759
760 while(position<waysx->nlength)
761 {
762 size_t len=1024;
763 char temp[1024];
764
765 if((waysx->nlength-position)<1024)
766 len=waysx->nlength-position;
767
768 ReadFile(waysx->nfd,temp,len);
769
770 WriteFile(fd,temp,len);
771
772 position+=len;
773 }
774
775 /* Close the files */
776
777 waysx->fd=CloseFile(waysx->fd);
778 waysx->nfd=CloseFile(waysx->nfd);
779
780 /* Write out the header structure */
781
782 waysfile.number =waysx->number;
783
784 waysfile.highways=highways;
785 waysfile.allow =allow;
786 waysfile.props =props;
787
788 SeekFile(fd,0);
789 WriteFile(fd,&waysfile,sizeof(WaysFile));
790
791 CloseFile(fd);
792
793 /* Print the final message */
794
795 printf_last("Wrote Ways: Ways=%"Pindex_t,waysx->number);
796 }

Properties

Name Value
cvs:description Extended ways functions.
Index: This Site Routino Software Download Source Code Documentation XML Files Links
Index: View SVN Development Recent changes Development (destination-access branch) Version 3.4.2 (destination-access branch) Version 3.4.2 Version 3.4.1 (destination-access branch) Version 3.4.1 Version 3.4 (destination-access branch) Version 3.4 Version 3.3.3 (destination-access branch) Version 3.3.3 Version 3.3.2 (destination-access branch) Version 3.3.2 Version 3.3.1 (destination-access branch) Version 3.3.1 Version 3.3 (destination-access branch) Version 3.3 Version 3.2 Version 3.1.1 Version 3.1 Version 3.0 Version 2.7.3 Version 2.7.2 Version 2.7.1 Version 2.7 Version 2.6 Version 2.5.1 Version 2.5 Version 2.4.1 Version 2.4 Version 2.3.2 Version 2.3.1 Version 2.3 Version 2.2 Version 2.1.2 Version 2.1.1 Version 2.1 Version 2.0.3 Version 2.0.2 Version 2.0.1 Version 2.0 Version 1.5.1 Version 1.5 Version 1.4.1 Version 1.4 Version 1.3 Version 1.2 Version 1.1 Version 1.0
Powered by ViewVC 1.3.0-dev ViewVC Help
© Andrew M. Bishop = < amb @ ... >
Root