ccan: Correct some poor conventions in _info includes
[ccan] / ccan / bdelta / _info
1 #include "config.h"
2 #include <stdio.h>
3 #include <string.h>
4
5 /**
6  * bdelta - Generate and apply binary deltas
7  *
8  * This library takes two strings containing binary data, and produces a
9  * "patch" that can be applied to the first one to produce the second one.
10  * It can be used to save bandwidth and disk space when many texts differing
11  * by a small number of bytes need to be transmitted or stored.
12  *
13  * Patches produced by this version of the library can be applied using future
14  * versions, but not past versions.
15  *
16  * bdelta implements the algorithm described in
17  * An O(ND) Difference Algorithm and Its Variations by Eugene W. Myers.
18  * Because its memory usage and expected running time are O(N + D^2),
19  * it works well only when the strings differ by a small number of bytes.
20  * This implementation stops trying when the strings differ by more than
21  * 1000 bytes, and falls back to producing a patch that simply emits the new
22  * string.
23  *
24  * Thus, bdelta does not save any space when given two strings that differ by
25  * more than 1000 bytes.  This may be improved in a future version of the
26  * library.
27  *
28  * Example:
29  *      #include <ccan/bdelta/bdelta.h>
30  *      #include <stdio.h>
31  *      #include <stdlib.h>
32  *      #include <string.h>
33  *
34  *      static void gulp(const char *filename, void **data_out, size_t *size_out);
35  *
36  *      static int usage(const char *prog)
37  *      {
38  *              fprintf(
39  *                      stderr,
40  *                      "Usage: %s diff  <old> <new>    >  <patch>\n"
41  *                      "       %s patch <old> <patch>  >  <new>\n",
42  *                      prog, prog
43  *              );
44  *              return 1;
45  *      }
46  *
47  *      int main(int argc, char *argv[])
48  *      {
49  *              void *old, *new_, *patch;
50  *              size_t old_size, new_size, patch_size;
51  *              BDELTAcode rc;
52  *
53  *              if (argc != 4)
54  *                      return usage(argv[0]);
55  *
56  *              if (strcmp(argv[1], "diff") == 0) {
57  *                      gulp(argv[2], &old, &old_size);
58  *                      gulp(argv[3], &new_, &new_size);
59  *
60  *                      rc = bdelta_diff(old, old_size, new_, new_size, &patch, &patch_size);
61  *                      if (rc != BDELTA_OK) {
62  *                              bdelta_perror("bdelta_diff", rc);
63  *                              return 1;
64  *                      }
65  *
66  *                      if (fwrite(patch, 1, patch_size, stdout) != patch_size) {
67  *                              perror("stdout");
68  *                              return 1;
69  *                      }
70  *              } else if (strcmp(argv[1], "patch") == 0) {
71  *                      gulp(argv[2], &old, &old_size);
72  *                      gulp(argv[3], &patch, &patch_size);
73  *
74  *                      rc = bdelta_patch(old, old_size, patch, patch_size, &new_, &new_size);
75  *                      if (rc != BDELTA_OK) {
76  *                              bdelta_perror("bdelta_patch", rc);
77  *                              return 1;
78  *                      }
79  *
80  *                      if (fwrite(new_, 1, new_size, stdout) != new_size) {
81  *                              perror("stdout");
82  *                              return 1;
83  *                      }
84  *              } else {
85  *                      return usage(argv[0]);
86  *              }
87  *
88  *              free(old);
89  *              free(new_);
90  *              free(patch);
91  *              return 0;
92  *      }
93  *
94  *      static void gulp(const char *filename, void **data_out, size_t *size_out)
95  *      {
96  *              FILE *f = fopen(filename, "rb");
97  *              size_t size = 0;
98  *              size_t alloc = 16;
99  *              char *data = malloc(alloc);
100  *
101  *              if (f == NULL || data == NULL)
102  *                      goto error;
103  *
104  *              for (;;) {
105  *                      size += fread(data + size, 1, alloc - size, f);
106  *                      if (size < alloc) {
107  *                              if (!feof(f))
108  *                                      goto error;
109  *                              break;
110  *                      }
111  *                      data = realloc(data, alloc *= 2);
112  *                      if (data == NULL)
113  *                              goto error;
114  *              }
115  *
116  *              if (fclose(f) != 0)
117  *                      goto error;
118  *
119  *              *data_out = data;
120  *              *size_out = size;
121  *              return;
122  *
123  *      error:
124  *              perror(filename);
125  *              exit(EXIT_FAILURE);
126  *      }
127  *
128  * Author: Joey Adams <joeyadams3.14159@gmail.com>
129  * License: MIT
130  * Version: 0.1.1
131  */
132 int main(int argc, char *argv[])
133 {
134         /* Expect exactly one argument */
135         if (argc != 2)
136                 return 1;
137
138         if (strcmp(argv[1], "depends") == 0) {
139                 /* Nothing */
140                 return 0;
141         }
142
143         return 1;
144 }