?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Autodoc corrections.
[cake.git] / tools / cxref / sgml.c
blob328d58db8a23f9e6bc8950cc00d023c170f0d98f
1 /***************************************
2 $Header$
3
4 C Cross Referencing & Documentation tool. Version 1.5f.
5
6 Writes the SGML output.
7 ******************/ /******************
8 Written by Andrew M. Bishop
9
10 This file Copyright 1995,96,97,98,2001,04 Andrew M. Bishop
11 It may be distributed under the GNU Public License, version 2, or
12 any higher version. See section COPYING of the GNU Public license
13 for conditions under which this file may be redistributed.
14 ***************************************/
15
16 #include <stdlib.h>
17 #include <stdio.h>
18 #include <string.h>
19 #include <sys/types.h>
20 #include <sys/stat.h>
21 #include <unistd.h>
22
23 #include "memory.h"
24 #include "datatype.h"
25 #include "cxref.h"
26
27 /*+ The name of the output tex file that includes each of the others. +*/
28 #define SGML_FILE ".sgml"
29 #define SGML_FILE_BACKUP ".sgml~"
30
31 /*+ The name of the output tex file that contains the appendix. +*/
32 #define SGML_APDX ".apdx"
33
34 /*+ The comments are to be inserted verbatim. +*/
35 extern int option_verbatim_comments;
36
37 /*+ The name of the directory for the output. +*/
38 extern char* option_odir;
39
40 /*+ The base name of the file for the output. +*/
41 extern char* option_name;
42
43 /*+ The information about the cxref run, +*/
44 extern char *run_command, /*+ the command line options. +*/
45 *run_cpp_command; /*+ the cpp command and options. +*/
46
47 /*+ The directories to go back to get to the base output directory. +*/
48 static char* goback=NULL;
49
50 static void WriteSGMLFilePart(File file);
51 static void WriteSGMLInclude(Include inc);
52 static void WriteSGMLSubInclude(Include inc,int depth);
53 static void WriteSGMLDefine(Define def);
54 static void WriteSGMLTypedef(Typedef type);
55 static void WriteSGMLStructUnion(StructUnion su,int depth);
56 static void WriteSGMLVariable(Variable var);
57 static void WriteSGMLFunction(Function func);
58
59 static void WriteSGMLPreamble(FILE* f,char* title);
60 static void WriteSGMLPostamble(FILE* f);
61
62 static char* sgml(char* c,int verbatim);
63
64 /*+ The output file for the SGML. +*/
65 static FILE* of;
66
67 /*+ The name of the file. +*/
68 static char *filename;
69
70
71 /*++++++++++++++++++++++++++++++++++++++
72 Write an sgml file for a complete File structure and all components.
73
74 File file The File structure to output.
75 ++++++++++++++++++++++++++++++++++++++*/
76
77 void WriteSGMLFile(File file)
78 {
79 char* ofile;
80 int i;
81
82 filename=file->name;
83
84 /* Open the file */
85
86 ofile=ConcatStrings(4,option_odir,"/",file->name,SGML_FILE);
87
88 of=fopen(ofile,"w");
89 if(!of)
90 {
91 struct stat stat_buf;
92 int i,ofl=strlen(ofile);
93
94 for(i=strlen(option_odir)+1;i<ofl;i++)
95 if(ofile[i]=='/')
96 {
97 ofile[i]=0;
98 if(stat(ofile,&stat_buf))
99 mkdir(ofile,S_IRUSR|S_IWUSR|S_IXUSR|S_IRGRP|S_IXGRP|S_IROTH|S_IXOTH);
100 ofile[i]='/';
101 }
102
103 of=fopen(ofile,"w");
104 }
105
106 if(!of)
107 {fprintf(stderr,"cxref: Failed to open the SGML output file '%s'\n",ofile);exit(1);}
108
109 for(goback="",i=strlen(file->name);i>0;i--)
110 if(file->name[i]=='/')
111 goback=ConcatStrings(2,goback,"../");
112
113 /* Write out a header. */
114
115 WriteSGMLPreamble(of,ConcatStrings(5,"Cross reference for ",file->name," of ",option_name,"."));
116
117 /*+ The file structure is broken into its components and they are each written out. +*/
118
119 WriteSGMLFilePart(file);
120
121 if(file->includes)
122 {
123 Include inc =file->includes;
124 fprintf(of,"\n<sect1>Included Files\n\n<p>\n");
125 do{
126 WriteSGMLInclude(inc);
127 }
128 while((inc=inc->next));
129 }
130
131 if(file->defines)
132 {
133 Define def =file->defines;
134 fprintf(of,"\n<sect1>Preprocessor definitions\n\n<p>\n");
135 do{
136 if(def!=file->defines)
137 fprintf(of,"<p>\n");
138 WriteSGMLDefine(def);
139 }
140 while((def=def->next));
141 }
142
143 if(file->typedefs)
144 {
145 Typedef type=file->typedefs;
146 do{
147 WriteSGMLTypedef(type);
148 }
149 while((type=type->next));
150 }
151
152 if(file->variables)
153 {
154 int any_to_mention=0;
155 Variable var=file->variables;
156
157 do{
158 if(var->scope&(GLOBAL|LOCAL|EXTERNAL|EXTERN_F))
159 any_to_mention=1;
160 }
161 while((var=var->next));
162
163 if(any_to_mention)
164 {
165 int first_ext=1,first_local=1;
166 Variable var=file->variables;
167 do{
168 if(var->scope&GLOBAL)
169 WriteSGMLVariable(var);
170 }
171 while((var=var->next));
172 var=file->variables;
173 do{
174 if(var->scope&(EXTERNAL|EXTERN_F) && !(var->scope&GLOBAL))
175 {
176 if(first_ext)
177 {fprintf(of,"\n<sect1>External Variables\n\n"); first_ext=0;}
178 fprintf(of,"<p>\n");
179 WriteSGMLVariable(var);
180 }
181 }
182 while((var=var->next));
183 var=file->variables;
184 do{
185 if(var->scope&LOCAL)
186 {
187 if(first_local)
188 {fprintf(of,"\n<sect1>Local Variables\n\n"); first_local=0;}
189 fprintf(of,"<p>\n");
190 WriteSGMLVariable(var);
191 }
192 }
193 while((var=var->next));
194 }
195 }
196
197 if(file->functions)
198 {
199 Function func=file->functions;
200 do{
201 if(func->scope&(GLOBAL|EXTERNAL))
202 WriteSGMLFunction(func);
203 }
204 while((func=func->next));
205 func=file->functions;
206 do{
207 if(func->scope&LOCAL)
208 WriteSGMLFunction(func);
209 }
210 while((func=func->next));
211 }
212
213 WriteSGMLPostamble(of);
214
215 fclose(of);
216
217 /* Clear the memory in sgml() */
218
219 sgml(NULL,0); sgml(NULL,0); sgml(NULL,0); sgml(NULL,0);
220 }
221
222
223 /*++++++++++++++++++++++++++++++++++++++
224 Write a File structure out.
225
226 File file The File to output.
227 ++++++++++++++++++++++++++++++++++++++*/
228
229 static void WriteSGMLFilePart(File file)
230 {
231 int i;
232
233 fprintf(of,"<sect>File %s\n",sgml(file->name,0));
234
235 if(file->comment)
236 {
237 if(option_verbatim_comments)
238 fprintf(of,"<p><tscreen><verb>\n%s\n</verb></tscreen>\n\n",sgml(file->comment,1));
239 else
240 {
241 char *rcs1=strstr(file->comment,"$Header"),*rcs2=NULL;
242 if(rcs1)
243 {
244 rcs2=strstr(&rcs1[1],"$");
245 if(rcs2)
246 {
247 rcs2[0]=0;
248 fprintf(of,"<bf>RCS %s</bf>\n<p>\n",sgml(&rcs1[1],0));
249 rcs2[0]='$';
250 }
251 }
252 if(rcs2)
253 fprintf(of,"%s\n<p>\n",sgml(&rcs2[2],0));
254 else
255 fprintf(of,"%s\n<p>\n",sgml(file->comment,0));
256 }
257 }
258
259 if(file->inc_in->n)
260 {
261 int i;
262
263 fprintf(of,"<p>\n<descrip>\n<tag>Included in:</tag>\n<itemize>\n");
264 for(i=0;i<file->inc_in->n;i++)
265 fprintf(of,"<item>%s\n",sgml(file->inc_in->s[i],0));
266 fprintf(of,"</itemize>\n</descrip>\n");
267 }
268
269 if(file->f_refs->n || file->v_refs->n)
270 fprintf(of,"<descrip>\n");
271
272 if(file->f_refs->n)
273 {
274 int others=0;
275 fprintf(of,"<tag>References Functions:</tag>\n<itemize>\n");
276 for(i=0;i<file->f_refs->n;i++)
277 if(file->f_refs->s2[i])
278 fprintf(of,"<item>%s() : %s\n",sgml(file->f_refs->s1[i],0),sgml(file->f_refs->s2[i],0));
279 else
280 others++;
281
282 if(others)
283 {
284 fprintf(of,"<item>");
285 for(i=0;i<file->f_refs->n;i++)
286 if(!file->f_refs->s2[i])
287 fprintf(of,--others?" %s(),":" %s()",sgml(file->f_refs->s1[i],0));
288 fprintf(of,"\n");
289 }
290 fprintf(of,"</itemize>\n");
291 }
292
293 if(file->v_refs->n)
294 {
295 int others=0;
296 fprintf(of,"<tag>References Variables:</tag>\n<itemize>\n");
297 for(i=0;i<file->v_refs->n;i++)
298 {
299 if(file->v_refs->s2[i])
300 fprintf(of,"<item>%s : %s\n",sgml(file->v_refs->s1[i],0),sgml(file->v_refs->s2[i],0));
301 else
302 others++;
303 }
304
305 if(others)
306 {
307 fprintf(of,"<item>");
308 for(i=0;i<file->v_refs->n;i++)
309 if(!file->v_refs->s2[i])
310 fprintf(of,--others?" %s,":" %s",sgml(file->v_refs->s1[i],0));
311 fprintf(of,"\n");
312 }
313 fprintf(of,"</itemize>\n");
314 }
315
316 if(file->f_refs->n || file->v_refs->n)
317 fprintf(of,"</descrip>\n");
318 }
319
320
321 /*++++++++++++++++++++++++++++++++++++++
322 Write an Include structure out.
323
324 Include inc The Include structure to output.
325 ++++++++++++++++++++++++++++++++++++++*/
326
327 static void WriteSGMLInclude(Include inc)
328 {
329 if(inc->comment)
330 fprintf(of,"%s\n<p>\n",sgml(inc->comment,0));
331
332 fprintf(of,"<itemize>\n");
333
334 if(inc->scope==LOCAL)
335 fprintf(of,"<item><tt>#include &quot;%s&quot;</tt>\n",sgml(inc->name,0));
336 else
337 fprintf(of,"<item><tt>#include &lt;%s&gt;</tt>\n",sgml(inc->name,0));
338
339 if(inc->includes)
340 WriteSGMLSubInclude(inc->includes,1);
341
342 fprintf(of,"</itemize>\n");
343 }
344
345
346 /*++++++++++++++++++++++++++++++++++++++
347 Write an Sub Include structure out. (An include structure that is included from another file.)
348
349 Include inc The Include structure to output.
350
351 int depth The depth of the include hierarchy.
352 ++++++++++++++++++++++++++++++++++++++*/
353
354 static void WriteSGMLSubInclude(Include inc,int depth)
355 {
356 fprintf(of,"<itemize>\n");
357
358 while(inc)
359 {
360 if(inc->scope==LOCAL)
361 fprintf(of,"<item><tt>#include &quot;%s&quot;</tt>\n",sgml(inc->name,0));
362 else
363 fprintf(of,"<item><tt>#include &lt;%s&gt;</tt>\n",sgml(inc->name,0));
364
365 if(inc->includes)
366 WriteSGMLSubInclude(inc->includes,depth+1);
367
368 inc=inc->next;
369 }
370
371 fprintf(of,"</itemize>\n");
372 }
373
374
375 /*++++++++++++++++++++++++++++++++++++++
376 Write a Define structure out.
377
378 Define def The Define structure to output.
379 ++++++++++++++++++++++++++++++++++++++*/
380
381 static void WriteSGMLDefine(Define def)
382 {
383 int i;
384 int pargs=0;
385
386 if(def->comment)
387 fprintf(of,"%s\n<p>\n",sgml(def->comment,0));
388
389 fprintf(of,"<tt>#define %s",sgml(def->name,0));
390
391 if(def->value)
392 fprintf(of," %s",sgml(def->value,0));
393
394 if(def->args->n)
395 {
396 fprintf(of,"( ");
397 for(i=0;i<def->args->n;i++)
398 fprintf(of,i?", %s":"%s",sgml(def->args->s1[i],0));
399 fprintf(of," )");
400 }
401 fprintf(of,"</tt><newline>\n");
402
403 for(i=0;i<def->args->n;i++)
404 if(def->args->s2[i])
405 pargs=1;
406
407 if(pargs)
408 {
409 fprintf(of,"<descrip>\n");
410 for(i=0;i<def->args->n;i++)
411 fprintf(of,"<tag><tt>%s</tt></tag>\n%s\n",sgml(def->args->s1[i],0),def->args->s2[i]?sgml(def->args->s2[i],0):"");
412 fprintf(of,"</descrip>\n");
413 }
414 }
415
416
417 /*++++++++++++++++++++++++++++++++++++++
418 Write a Typedef structure out.
419
420 Typedef type The Typedef structure to output.
421 ++++++++++++++++++++++++++++++++++++++*/
422
423 static void WriteSGMLTypedef(Typedef type)
424 {
425 fprintf(of,"\n<sect1>");
426
427 if(type->type)
428 fprintf(of,"Typedef %s",sgml(type->name,0));
429 else
430 fprintf(of,"Type %s",sgml(type->name,0));
431
432 fprintf(of,"\n\n<p>\n");
433
434 if(type->comment)
435 fprintf(of,"%s\n<p>\n",sgml(type->comment,0));
436
437 if(type->type)
438 fprintf(of,"<tt>typedef %s</tt><newline>\n",sgml(type->type,0));
439
440 if(type->sutype)
441 {
442 fprintf(of,"<itemize>\n");
443 WriteSGMLStructUnion(type->sutype,0);
444 fprintf(of,"</itemize>\n");
445 }
446 else
447 if(type->typexref)
448 {
449 fprintf(of,"<descrip>\n<tag>See:</tag>\n<itemize>\n");
450 if(type->typexref->type)
451 fprintf(of,"<item>Typedef %s\n",sgml(type->typexref->name,0));
452 else
453 if(!strncmp("enum",type->typexref->name,4))
454 fprintf(of,"<item>Type %s\n",sgml(type->typexref->name,0));
455 else
456 if(!strncmp("union",type->typexref->name,5))
457 fprintf(of,"<item>Type %s\n",sgml(type->typexref->name,0));
458 else
459 if(!strncmp("struct",type->typexref->name,6))
460 fprintf(of,"<item>Type %s\n",sgml(type->typexref->name,0));
461 fprintf(of,"</itemize>\n</descrip>\n");
462 }
463 }
464
465
466 /*++++++++++++++++++++++++++++++++++++++
467 Write a structure / union structure out.
468
469 StructUnion su The structure / union to write.
470
471 int depth The current depth within the structure.
472 ++++++++++++++++++++++++++++++++++++++*/
473
474 static void WriteSGMLStructUnion(StructUnion su, int depth)
475 {
476 int i;
477 char* splitsu=NULL;
478
479 splitsu=strstr(su->name,"{...}");
480 if(splitsu) splitsu[-1]=0;
481
482 if(depth && su->comment && !su->comps)
483 fprintf(of,"<item><tt>%s; </tt>%s<newline>\n",sgml(su->name,0),sgml(su->comment,0));
484 else if(!depth || su->comps)
485 fprintf(of,"<item><tt>%s</tt><newline>\n",sgml(su->name,0));
486 else
487 fprintf(of,"<item><tt>%s;</tt><newline>\n",sgml(su->name,0));
488
489 if(!depth || su->comps)
490 {
491 fprintf(of,"<itemize>\n");
492
493 fprintf(of,"<item><tt>{</tt><newline>\n");
494
495 for(i=0;i<su->n_comp;i++)
496 WriteSGMLStructUnion(su->comps[i],depth+1);
497
498 fprintf(of,"<item><tt>}</tt><newline>\n");
499
500 fprintf(of,"</itemize>\n");
501
502 if(splitsu)
503 {
504 if(depth && su->comment)
505 fprintf(of,"<item><tt>%s; </tt>%s<newline>\n",splitsu[5]?sgml(&splitsu[6],0):"",sgml(su->comment,0));
506 else
507 fprintf(of,"<item><tt>%s;</tt><newline>\n",splitsu[5]?sgml(&splitsu[6],0):"");
508 }
509 }
510
511 if(splitsu) splitsu[-1]=' ';
512 }
513
514
515 /*++++++++++++++++++++++++++++++++++++++
516 Write a Variable structure out.
517
518 Variable var The Variable structure to output.
519 ++++++++++++++++++++++++++++++++++++++*/
520
521 static void WriteSGMLVariable(Variable var)
522 {
523 int i;
524
525 if(var->scope&GLOBAL)
526 fprintf(of,"\n<sect1>Global Variable %s\n\n<p>\n",sgml(var->name,0));
527 else
528 fprintf(of,"<bf>%s</bf><newline>\n",sgml(var->name,0));
529
530 if(var->comment)
531 fprintf(of,"%s\n<p>\n",sgml(var->comment,0));
532
533 fprintf(of,"<tt>");
534
535 if(var->scope&LOCAL)
536 fprintf(of,"static ");
537 else
538 if(!(var->scope&GLOBAL) && var->scope&(EXTERNAL|EXTERN_F))
539 fprintf(of,"extern ");
540
541 fprintf(of,"%s</tt><newline>\n",sgml(var->type,0));
542
543 if(var->scope&(GLOBAL|LOCAL))
544 {
545 if(var->incfrom || var->visible->n || var->used->n)
546 fprintf(of,"<descrip>\n");
547
548 if(var->incfrom)
549 {
550 fprintf(of,"<tag>Included from:</tag>\n<itemize>\n");
551 fprintf(of,"<item>%s\n",sgml(var->incfrom,0));
552 fprintf(of,"</itemize>\n");
553 }
554
555 if(var->visible->n)
556 {
557 fprintf(of,"<tag>Visible in:</tag>\n<itemize>\n");
558 for(i=0;i<var->visible->n;i++)
559 if(var->visible->s1[i][0]=='$' && !var->visible->s1[i][1])
560 fprintf(of,"<item>%s\n",sgml(var->visible->s2[i],0));
561 else
562 fprintf(of,"<item>%s() : %s\n",sgml(var->visible->s1[i],0),sgml(var->visible->s2[i],0));
563 fprintf(of,"</itemize>\n");
564 }
565
566 if(var->used->n)
567 {
568 fprintf(of,"<tag>Used in:</tag>\n<itemize>\n");
569 for(i=0;i<var->used->n;i++)
570 {
571 if(var->used->s1[i][0]=='$' && !var->used->s1[i][1])
572 fprintf(of,"<item>%s\n",sgml(var->used->s2[i],0));
573 else
574 {
575 if(var->scope&LOCAL)
576 fprintf(of,"<item>%s()\n",sgml(var->used->s1[i],0));
577 else
578 fprintf(of,"<item>%s() : %s\n",sgml(var->used->s1[i],0),sgml(var->used->s2[i],0));
579 }
580 }
581 fprintf(of,"</itemize>\n");
582 }
583
584 if(var->incfrom || var->visible->n || var->used->n)
585 fprintf(of,"</descrip>\n");
586 }
587 else
588 if(var->scope&(EXTERNAL|EXTERN_F) && var->defined)
589 {
590 fprintf(of,"<descrip>\n<tag>Defined in:</tag>\n<itemize>\n");
591 fprintf(of,"<item>%s",sgml(var->name,0));
592 fprintf(of,"</itemize>\n</descrip>\n");
593 }
594 }
595
596
597 /*++++++++++++++++++++++++++++++++++++++
598 Write a Function structure out.
599
600 Function func The Function structure to output.
601 ++++++++++++++++++++++++++++++++++++++*/
602
603 static void WriteSGMLFunction(Function func)
604 {
605 int i,pret,pargs;
606 char* comment2=NULL,*type;
607
608 if(func->scope&(GLOBAL|EXTERNAL))
609 fprintf(of,"\n<sect1>Global Function %s()\n\n<p>",sgml(func->name,0));
610 else
611 fprintf(of,"\n<sect1>Local Function %s()\n\n<p>",sgml(func->name,0));
612
613 if(func->comment)
614 {
615 if(option_verbatim_comments)
616 fprintf(of,"<tscreen><verb>\n%s\n</verb></tscreen>\n\n",sgml(func->comment,1));
617 else
618 {
619 comment2=strstr(func->comment,"\n\n");
620 if(comment2)
621 comment2[0]=0;
622 fprintf(of,"%s\n<p>\n",sgml(func->comment,0));
623 }
624 }
625
626 fprintf(of,"<tt>");
627
628 if(func->scope&LOCAL)
629 fprintf(of,"static ");
630 if(func->scope&INLINED)
631 fprintf(of,"inline ");
632
633 if((type=strstr(func->type,"()")))
634 type[0]=0;
635 fprintf(of,"%s ( ",sgml(func->type,0));
636
637 for(i=0;i<func->args->n;i++)
638 fprintf(of,i?", %s":"%s",sgml(func->args->s1[i],0));
639
640 if(type)
641 {fprintf(of," %s</tt><newline>\n",sgml(&type[1],0));type[0]='(';}
642 else
643 fprintf(of," )</tt><newline>\n");
644
645 pret =strncmp("void ",func->type,5) && func->cret;
646 for(pargs=0,i=0;i<func->args->n;i++)
647 pargs = pargs || ( strcmp("void",func->args->s1[i]) && func->args->s2[i] );
648
649 if(pret || pargs)
650 {
651 fprintf(of,"<descrip>\n");
652 if(pret)
653 fprintf(of,"<tag><tt>%s</tt></tag>\n%s\n",sgml(func->type,0),func->cret?sgml(func->cret,0):"&nbsp;");
654 if(pargs)
655 for(i=0;i<func->args->n;i++)
656 fprintf(of,"<tag><tt>%s</tt></tag>\n%s\n",sgml(func->args->s1[i],0),func->args->s2[i]?sgml(func->args->s2[i],0):"&nbsp;");
657 fprintf(of,"</descrip>\n");
658 }
659
660 if(comment2)
661 {
662 fprintf(of,"%s\n<p>\n",sgml(&comment2[2],0));
663 comment2[0]='\n';
664 }
665
666 if(func->protofile || func->incfrom || func->calls->n || func->called->n || func->used->n || func->f_refs->n || func->v_refs->n)
667 fprintf(of,"<descrip>\n");
668
669 if(func->protofile)
670 {
671 fprintf(of,"<tag>Prototyped in:</tag>\n<itemize>\n");
672 fprintf(of,"<item>%s\n",sgml(func->protofile,0));
673 fprintf(of,"</itemize>\n");
674 }
675
676 if(func->incfrom)
677 {
678 fprintf(of,"<tag>Included from:</tag>\n<itemize>\n");
679 fprintf(of,"<item>%s\n",sgml(func->incfrom,0));
680 fprintf(of,"</itemize>\n");
681 }
682
683 if(func->calls->n)
684 {
685 int others=0;
686 fprintf(of,"<tag>Calls:</tag>\n<itemize>\n");
687 for(i=0;i<func->calls->n;i++)
688 {
689 if(func->calls->s2[i])
690 fprintf(of,"<item>%s() : %s\n",sgml(func->calls->s1[i],0),sgml(func->calls->s2[i],0));
691 else
692 others++;
693 }
694
695 if(others)
696 {
697 fprintf(of,"<item>");
698 for(i=0;i<func->calls->n;i++)
699 if(!func->calls->s2[i])
700 fprintf(of,--others?"%s(), ":"%s()",sgml(func->calls->s1[i],0));
701 fprintf(of,"\n");
702 }
703 fprintf(of,"</itemize>\n");
704 }
705
706 if(func->called->n)
707 {
708 fprintf(of,"<tag>Called by:</tag>\n<itemize>\n");
709 for(i=0;i<func->called->n;i++)
710 fprintf(of,"<item>%s() : %s\n",sgml(func->called->s1[i],0),sgml(func->called->s2[i],0));
711 fprintf(of,"</itemize>\n");
712 }
713
714 if(func->used->n)
715 {
716 fprintf(of,"<tag>Used in:</tag>\n<itemize>\n");
717 for(i=0;i<func->used->n;i++)
718 {
719 if(func->used->s1[i][0]=='$' && !func->used->s1[i][1])
720 fprintf(of,"<item>%s\n",sgml(func->used->s2[i],0));
721 else
722 fprintf(of,"<item>%s() : %s\n",sgml(func->used->s1[i],0),sgml(func->used->s2[i],0));
723 }
724 fprintf(of,"</itemize>\n");
725 }
726
727 if(func->f_refs->n)
728 {
729 int others=0;
730 fprintf(of,"<tag>References Functions:</tag>\n<itemize>\n");
731 for(i=0;i<func->f_refs->n;i++)
732 {
733 if(func->f_refs->s2[i])
734 fprintf(of,"<item>%s() : %s\n",sgml(func->f_refs->s1[i],0),sgml(func->f_refs->s2[i],0));
735 else
736 others++;
737 }
738
739 if(others)
740 {
741 fprintf(of,"<item>");
742 for(i=0;i<func->f_refs->n;i++)
743 if(!func->f_refs->s2[i])
744 fprintf(of,--others?"%s(), ":"%s()",sgml(func->f_refs->s1[i],0));
745 fprintf(of,"\n");
746 }
747 fprintf(of,"</itemize>\n");
748 }
749
750 if(func->v_refs->n)
751 {
752 int others=0;
753 fprintf(of,"<tag>References Variables:</tag>\n<itemize>\n");
754 for(i=0;i<func->v_refs->n;i++)
755 {
756 if(func->v_refs->s2[i])
757 fprintf(of,"<item>%s : %s\n",sgml(func->v_refs->s1[i],0),sgml(func->v_refs->s2[i],0));
758 else
759 others++;
760 }
761
762 if(others)
763 {
764 fprintf(of,"<item>");
765 for(i=0;i<func->v_refs->n;i++)
766 if(!func->v_refs->s2[i])
767 fprintf(of,--others?"%s, ":"%s",sgml(func->v_refs->s1[i],0));
768 fprintf(of,"\n");
769 }
770 fprintf(of,"</itemize>\n");
771 }
772
773 if(func->protofile || func->incfrom || func->calls->n || func->called->n || func->used->n || func->f_refs->n || func->v_refs->n)
774 fprintf(of,"</descrip>\n");
775 }
776
777
778 /*++++++++++++++++++++++++++++++++++++++
779 Write out a standard pre-amble.
780
781 FILE* f The file to write the pre amble to.
782
783 char* title The title of the file.
784 ++++++++++++++++++++++++++++++++++++++*/
785
786 static void WriteSGMLPreamble(FILE* f,char* title)
787 {
788 fputs("<!DOCTYPE LINUXDOC SYSTEM>\n",f);
789 fputs("\n",f);
790 fputs("<!-- This SGML file generated by cxref. -->\n",f);
791 fputs("<!-- cxref program (c) Andrew M. Bishop 1995,96,97,98,99. -->\n",f);
792 fputs("\n",f);
793 fputs("<!--\n",f);
794 if(filename)
795 fprintf(f,"Cxref: %s %s\n",run_command,filename);
796 else
797 fprintf(f,"Cxref: %s\n",run_command);
798 fprintf(f,"CPP : %s\n",run_cpp_command);
799 fputs("-->\n",f);
800 fputs("\n",f);
801 fputs("<article>\n",f);
802 fputs("\n",f);
803 fputs("<title>",f);
804 fputs(title,f);
805 fputs("\n",f);
806 fputs("<author>cxref\n",f);
807 fputs("\n",f);
808 }
809
810
811 /*++++++++++++++++++++++++++++++++++++++
812 Write out a standard post-amble. This includes the end of document marker.
813
814 FILE* f The file to write the post amble to.
815 ++++++++++++++++++++++++++++++++++++++*/
816
817 static void WriteSGMLPostamble(FILE* f)
818 {
819 fputs("\n",f);
820 fputs("</article>\n",f);
821 }
822
823
824 /*++++++++++++++++++++++++++++++++++++++
825 Write out the appendix information.
826
827 StringList files The list of files to write.
828
829 StringList2 funcs The list of functions to write.
830
831 StringList2 vars The list of variables to write.
832
833 StringList2 types The list of types to write.
834 ++++++++++++++++++++++++++++++++++++++*/
835
836 void WriteSGMLAppendix(StringList files,StringList2 funcs,StringList2 vars,StringList2 types)
837 {
838 char* ofile;
839 int i;
840
841 filename=NULL;
842
843 /* Open the file */
844
845 ofile=ConcatStrings(5,option_odir,"/",option_name,SGML_APDX,SGML_FILE);
846
847 of=fopen(ofile,"w");
848
849 if(!of)
850 {fprintf(stderr,"cxref: Failed to open the SGML appendix file '%s'\n",ofile);exit(1);}
851
852 /* Write the file structure out */
853
854 WriteSGMLPreamble(of,ConcatStrings(3,"Cross reference index of ",option_name,"."));
855
856 fprintf(of,"<sect>Cross References\n");
857
858 /* Write out the appendix of files. */
859
860 if(files->n)
861 {
862 fprintf(of,"\n<sect1>Files\n\n<p>\n");
863 fprintf(of,"<itemize>\n");
864 for(i=0;i<files->n;i++)
865 fprintf(of,"<item>%s>\n",sgml(files->s[i],0));
866 fprintf(of,"</itemize>\n");
867 }
868
869 /* Write out the appendix of functions. */
870
871 if(funcs->n)
872 {
873 fprintf(of,"\n<sect1>Global Functions\n\n<p>\n");
874 fprintf(of,"<itemize>\n");
875 for(i=0;i<funcs->n;i++)
876 fprintf(of,"<item>%s() : %s\n",sgml(funcs->s1[i],0),sgml(funcs->s2[i],0));
877 fprintf(of,"</itemize>\n");
878 }
879
880 /* Write out the appendix of variables. */
881
882 if(vars->n)
883 {
884 fprintf(of,"\n<sect1>Global Variables\n\n<p>\n");
885 fprintf(of,"<itemize>\n");
886 for(i=0;i<vars->n;i++)
887 fprintf(of,"<item>%s : %s\n",sgml(vars->s1[i],0),sgml(vars->s2[i],0));
888 fprintf(of,"</itemize>\n");
889 }
890
891 /* Write out the appendix of types. */
892
893 if(types->n)
894 {
895 fprintf(of,"\n<sect1>Defined Types\n\n<p>\n");
896 fprintf(of,"<itemize>\n");
897 for(i=0;i<types->n;i++)
898 if(!strncmp("enum",types->s1[i],4))
899 fprintf(of,"<item>%s : %s\n",sgml(types->s1[i],0),sgml(types->s2[i],0));
900 else
901 if(!strncmp("union",types->s1[i],5))
902 fprintf(of,"<item>%s : %s\n",sgml(types->s1[i],0),sgml(types->s2[i],0));
903 else
904 if(!strncmp("struct",types->s1[i],6))
905 fprintf(of,"<item>%s : %s\n",sgml(types->s1[i],0),sgml(types->s2[i],0));
906 else
907 fprintf(of,"<item>%s : %s\n",sgml(types->s1[i],0),sgml(types->s2[i],0));
908 fprintf(of,"</itemize>\n");
909 }
910
911 WriteSGMLPostamble(of);
912
913 fclose(of);
914
915 /* Clear the memory in sgml(,0) */
916
917 sgml(NULL,0); sgml(NULL,0); sgml(NULL,0); sgml(NULL,0);
918 }
919
920
921 /*++++++++++++++++++++++++++++++++++++++
922 Delete the SGML file and main file reference that belong to the named file.
923
924 char *name The name of the file to delete.
925 ++++++++++++++++++++++++++++++++++++++*/
926
927 void WriteSGMLFileDelete(char *name)
928 {
929 char *ofile;
930
931 ofile=ConcatStrings(4,option_odir,"/",name,SGML_FILE);
932 unlink(ofile);
933 }
934
935
936 /*++++++++++++++++++++++++++++++++++++++
937 Make the input string safe to output as SGML ( not <, >, &, ", $, #, % or ~ ).
938
939 char* sgml Returns a safe SGML string.
940
941 char* c A non-safe SGML string.
942
943 int verbatim Set to true inside a verbatim environment.
944
945 The function can only be called four times in each fprintf() since it returns one of only four static strings.
946 ++++++++++++++++++++++++++++++++++++++*/
947
948 static char* sgml(char* c,int verbatim)
949 {
950 static char safe[4][256],*malloced[4]={NULL,NULL,NULL,NULL};
951 static int which=0;
952 int copy=0,skip=0;
953 int i=0,j=0,delta=10,len=256-delta;
954 char* ret;
955
956 which=(which+1)%4;
957 ret=safe[which];
958
959 safe[which][0]=0;
960
961 if(malloced[which])
962 {Free(malloced[which]);malloced[which]=NULL;}
963
964 if(c)
965 {
966 i=CopyOrSkip(c,"sgml",&copy,&skip);
967
968 while(1)
969 {
970 for(;j<len && c[i];i++)
971 {
972 if(copy)
973 {ret[j++]=c[i]; if(c[i]=='\n') copy=0;}
974 else if(skip)
975 { if(c[i]=='\n') skip=0;}
976 else if(verbatim)
977 switch(c[i])
978 {
979 case '&':
980 strcpy(&ret[j],"&ero;");j+=5;
981 break;
982 case '<':
983 if(c[i+1]=='/')
984 {strcpy(&ret[j],"&etago;");j+=7; break;}
985 default:
986 ret[j++]=c[i];
987 }
988 else
989 switch(c[i])
990 {
991 case '<':
992 if(c[i+1]=='/')
993 {strcpy(&ret[j],"&etago;");j+=7;}
994 else
995 {strcpy(&ret[j],"&lt;");j+=4;}
996 break;
997 case '>':
998 strcpy(&ret[j],"&gt;");j+=4;
999 break;
1000 case '"':
1001 strcpy(&ret[j],"&quot;");j+=6;
1002 break;
1003 case '&':
1004 strcpy(&ret[j],"&amp;");j+=5;
1005 break;
1006 case '$':
1007 strcpy(&ret[j],"&dollar;");j+=8;
1008 break;
1009 case '#':
1010 strcpy(&ret[j],"&num;");j+=5;
1011 break;
1012 case '%':
1013 strcpy(&ret[j],"&percnt;");j+=8;
1014 break;
1015 case '~':
1016 strcpy(&ret[j],"&tilde;");j+=7;
1017 break;
1018 case '\n':
1019 if(j && ret[j-1]=='\n')
1020 {
1021 strcpy(&ret[j],"<newline>");j+=9;
1022 }
1023 ret[j++]=c[i];
1024 break;
1025 default:
1026 ret[j++]=c[i];
1027 }
1028 if(c[i]=='\n')
1029 i+=CopyOrSkip(c+i,"sgml",&copy,&skip);
1030 }
1031
1032 if(c[i]) /* Not finished */
1033 {
1034 if(malloced[which])
1035 malloced[which]=Realloc(malloced[which],len+delta+256);
1036 else
1037 {malloced[which]=Malloc(len+delta+256); strncpy(malloced[which],ret,(unsigned)j);}
1038 ret=malloced[which];
1039 len+=256;
1040 }
1041 else
1042 {ret[j]=0; break;}
1043 }
1044 }
1045
1046 return(ret);
1047 }
The AROS cake. Goodness baked in, have it and eat it too. Delicious!