git.ozlabs.org Git - ccan/blob - tools/doc_extract-core.c

   1 /* This merely extracts, doesn't do XML or anything. */
   2 #include <err.h>
   3 #include <stdio.h>
   4 #include <stdlib.h>
   5 #include <unistd.h>
   6 #include <string.h>
   7 #include <sys/types.h>
   8 #include <sys/stat.h>
   9 #include <fcntl.h>
  10 #include <stdbool.h>
  11 #include <ctype.h>
  12 #include <ccan/talloc/talloc.h>
  13 #include <ccan/str/str.h>
  14 #include "doc_extract.h"
  15 #include "tools.h"
  16
  17 static char **grab_doc(char **lines, unsigned int num)
  18 {
  19         char **ret;
  20         unsigned int i;
  21         bool printing = false;
  22
  23         ret = talloc_array(NULL, char *, num+1);
  24
  25         num = 0;
  26         for (i = 0; lines[i]; i++) {
  27                 if (streq(lines[i], "/**")) {
  28                         printing = true;
  29                         if (num != 0) {
  30                                 ret[num-1] = talloc_append_string(ret[num-1],
  31                                                                   "\n");
  32                         }
  33                 } else if (streq(lines[i], " */"))
  34                         printing = false;
  35                 else if (printing) {
  36                         if (strstarts(lines[i], " * "))
  37                                 ret[num++] = talloc_strdup(ret, lines[i]+3);
  38                         else if (strstarts(lines[i], " *"))
  39                                 ret[num++] = talloc_strdup(ret, lines[i]+2);
  40                         else
  41                                 errx(1, "Malformed line %u", i);
  42                 }
  43         }
  44         ret[num] = NULL;
  45         return ret;
  46 }
  47
  48 static bool is_blank(const char *line)
  49 {
  50         return line && line[strspn(line, " \t\n")] == '\0';
  51 }
  52
  53 static bool is_section(const char *line, bool one_liner)
  54 {
  55         unsigned int len = 0;
  56
  57         /* Any number of upper case words separated by spaces, ending in : */
  58         for (;;) {
  59                 if (!isupper(line[len]))
  60                         return false;
  61                 len += strspn(line+len, IDENT_CHARS);
  62                 if (line[len] == ':')
  63                         break;
  64
  65                 if (line[len] != ' ')
  66                         return false;
  67                 len++;
  68         }
  69
  70         /* If it can be a one-liner, a space is sufficient.*/
  71         if (one_liner)
  72                 return (line[len+1] == ' ' || line[len+1] == '\t');
  73
  74         return line[len] == ':' && is_blank(line+len+1);
  75 }
  76
  77 /* Summary line is form '<identifier> - ' (spaces for 'struct foo -') */
  78 static unsigned int is_summary_line(const char *line)
  79 {
  80         unsigned int id_len;
  81
  82         id_len = strspn(line, IDENT_CHARS" ");
  83         if (id_len == 0)
  84                 return 0;
  85         if (!strstarts(line + id_len-1, " - "))
  86                 return 0;
  87
  88         return id_len - 1;
  89 }
  90
  91 static bool empty_section(struct doc_section *d)
  92 {
  93         unsigned int i;
  94
  95         for (i = 0; i < d->num_lines; i++)
  96                 if (!is_blank(d->lines[i]))
  97                         return false;
  98         return true;
  99 }
 100
 101 static struct doc_section *new_section(struct list_head *list,
 102                                        const char *function,
 103                                        const char *type)
 104 {
 105         struct doc_section *d;
 106         char *lowertype;
 107         unsigned int i;
 108
 109         /* If previous section was empty, delete it. */
 110         d = list_tail(list, struct doc_section, list);
 111         if (d && empty_section(d)) {
 112                 list_del(&d->list);
 113                 talloc_free(d);
 114         }
 115
 116         d = talloc(list, struct doc_section);
 117         d->function = function;
 118         lowertype = talloc_size(d, strlen(type) + 1);
 119         /* Canonicalize type to lower case. */
 120         for (i = 0; i < strlen(type)+1; i++)
 121                 lowertype[i] = tolower(type[i]);
 122         d->type = lowertype;
 123         d->lines = NULL;
 124         d->num_lines = 0;
 125
 126         list_add_tail(list, &d->list);
 127         return d;
 128 }
 129
 130 static void add_line(struct doc_section *curr, const char *line)
 131 {
 132         curr->lines = talloc_realloc(curr, curr->lines, char *,
 133                                      curr->num_lines+1);
 134         curr->lines[curr->num_lines++] = talloc_strdup(curr->lines, line);
 135 }
 136
 137 struct list_head *extract_doc_sections(char **rawlines, unsigned int num)
 138 {
 139         char **lines = grab_doc(rawlines, num);
 140         const char *function = NULL;
 141         struct doc_section *curr = NULL;
 142         unsigned int i;
 143         struct list_head *list;
 144
 145         list = talloc(NULL, struct list_head);
 146         list_head_init(list);
 147
 148         for (i = 0; lines[i]; i++) {
 149                 unsigned funclen;
 150
 151                 funclen = is_summary_line(lines[i]);
 152                 if (funclen) {
 153                         function = talloc_strndup(list, lines[i], funclen);
 154                         curr = new_section(list, function, "summary");
 155                         add_line(curr, lines[i] + funclen + 3);
 156                         curr = new_section(list, function, "description");
 157                 } else if (is_section(lines[i], false)) {
 158                         char *type = talloc_strndup(curr, lines[i],
 159                                                     strcspn(lines[i], ":"));
 160                         curr = new_section(list, function, type);
 161                 } else if (is_section(lines[i], true)) {
 162                         unsigned int sectlen = strcspn(lines[i], ":");
 163                         char *type = talloc_strndup(curr, lines[i], sectlen);
 164                         curr = new_section(list, function, type);
 165                         add_line(curr, lines[i] + sectlen + 1
 166                                  + strspn(lines[i] + sectlen + 1, " \t"));
 167                 } else {
 168                         if (!curr)
 169                                 continue;
 170                         add_line(curr, lines[i]);
 171                 }
 172         }
 173         talloc_free(lines);
 174         return list;
 175 }