Commit 90f280e8 authored by Rusty Russell's avatar Rusty Russell

Remove _infotojson (unused for now)

parent 2257c0ac
......@@ -17,4 +17,3 @@ tools-clean: ccanlint-clean
rm -f $(ALL_TOOLS)
include tools/ccanlint/Makefile
include tools/_infotojson/Makefile
tools/_infotojson/infotojson: tools/depends.o tools/_infotojson/infotojson.o tools/_infotojson/sqlite3_database.o tools/_infotojson/utils.o ccan/string/string.o ccan/noerr/noerr.o ccan/talloc/talloc.o
$(CC) $(LDFLAGS) -o $@ $^ -lsqlite3
/* Simple SQL-style database ops. Currently implemented for sqlite3. */
#include <stdbool.h>
/* Returns handle to the database.. */
void *db_open(const char *file);
/* Runs query (SELECT). Fills in columns. */
struct db_query
{
unsigned int num_rows;
char ***rows;
};
struct db_query *db_query(void *h, const char *query);
/* Runs command (CREATE TABLE/INSERT) */
void db_command(void *h, const char *command);
/* Closes database (only called when everything OK). */
void db_close(void *h);
/* This extract info from _info.c and create json file and also optionally store to db */
#include "infotojson.h"
/*creating json structure for storing to file/db*/
static struct json *createjson(char **infofile, const char *author, const char *directory)
{
struct json *jsonobj;
unsigned int modulename;
if (infofile == NULL || author == NULL) {
printf("Error Author or Info file is NULL\n");
exit(1);
}
jsonobj = talloc(NULL, struct json);
if (!jsonobj)
errx(1, "talloc error");
jsonobj->author = talloc_strdup(jsonobj, author);
/* First line should be module name and short description */
modulename = strchr(infofile[0], '-') - infofile[0];
jsonobj->module = talloc_strndup(jsonobj, infofile[0], modulename - 1);
if (!jsonobj->module)
errx(1, "talloc error");
jsonobj->title = infofile[0];
jsonobj->desc = &infofile[1];
jsonobj->depends = get_deps(jsonobj, directory);
return jsonobj;
}
/*extracting title and description from _info.c files*/
static char **extractinfo(char **file)
{
char **infofile;
unsigned int count = 0, j = 0, num_lines = 0;
bool printing = false;
while (file[num_lines++]);
infofile = talloc_array(NULL, char *, num_lines);
for (j = 0; j < num_lines - 1; j++) {
if (streq(file[j], "/**")) {
printing = true;
}
else if (streq(file[j], " */"))
printing = false;
else if (printing) {
if (strstarts(file[j], " * "))
infofile[count++] = file[j] + 3;
else if (strstarts(file[j], " *"))
infofile[count++] = file[j] + 2;
else {
err(1,"Error in comments structure\n%d",j);
exit(1);
}
}
}
infofile[count] = NULL;
return infofile;
}
/*storing json structure to json file*/
static int storejsontofile(const struct json *jsonobj, const char *file)
{
FILE *fp;
unsigned int j = 0;
fp = fopen(file, "wt");
fprintf(fp,"\"Module\":\"%s\",\n",jsonobj->module);
fprintf(fp,"\"Title\":\"%s\",\n",jsonobj->title);
fprintf(fp,"\"Author\":\"%s\",\n",jsonobj->author);
fprintf(fp,"\"Dependencies\":[\n");
for (j = 0; jsonobj->depends[j]; j++)
fprintf(fp,"{\n\"depends\":\"%s\"\n},\n",jsonobj->depends[j]);
fprintf(fp,"]\n");
fprintf(fp,"\"Description\":[\n");
for (j = 0; jsonobj->desc[j]; j++)
fprintf(fp,"{\n\"str\":\"%s\"\n},\n",jsonobj->desc[j]);
fprintf(fp,"]\n");
fclose(fp);
return 1;
}
/*storing json structure to db*/
static int storejsontodb(const struct json *jsonobj, const char *db)
{
char *cmd, *query, *desc, *depends;
sqlite3 *handle;
struct db_query *q;
handle = db_open(db);
query = talloc_asprintf(NULL, "SELECT module, author from search where module=\"%s\";", jsonobj->module);
q = db_query(handle, query);
desc = strjoin(NULL, jsonobj->desc,"\n");
strreplace(desc, '\'', ' ');
depends = strjoin(NULL, jsonobj->depends,"\n");
if (q->num_rows && streq(jsonobj->author, q->rows[0][1]))
cmd = talloc_asprintf(NULL, "UPDATE search set author=\"%s\", title=\"%s\", desc=\'%s\' depends=\'%s\' where module=\"%s\";",
jsonobj->author, jsonobj->title, desc, depends, jsonobj->module);
else if (!q->num_rows)
cmd = talloc_asprintf(NULL, "INSERT INTO search VALUES(\"%s\",\"%s\",\"%s\", \'%s\', \'%s\', 0);",
jsonobj->module, jsonobj->author, jsonobj->title, depends, desc);
else
cmd = talloc_asprintf(NULL, "INSERT INTO search VALUES(\"%s-%s\",\"%s\",\"%s\", \'%s\', \'%s\', 0);",
jsonobj->module, jsonobj->author, jsonobj->author, jsonobj->title, depends, desc);
db_command(handle, cmd);
db_close(handle);
talloc_free(depends);
talloc_free(query);
talloc_free(desc);
talloc_free(cmd);
return 1;
}
int main(int argc, char *argv[])
{
char *file;
char **lines;
char **infofile;
struct json *jsonobj;
talloc_enable_leak_report();
if (argc < 5)
errx(1, "usage: infotojson dir_of_module info_filename target_json_file author [sqlitedb]\n"
"Convert _info.c file to json file and optionally store to database");
file = grab_file(NULL, argv[2], NULL);
if (!file)
err(1, "Reading file %s", argv[2]);
lines = strsplit(NULL, file, "\n", NULL);
//extract info from lines
infofile = extractinfo(lines);
//create json obj
jsonobj = createjson(infofile, argv[4], argv[1]);
//store to file
storejsontofile(jsonobj, argv[3]);
if (argv[5] != NULL)
storejsontodb(jsonobj, argv[5]);
talloc_free(file);
talloc_free(jsonobj);
talloc_free(lines);
talloc_free(infofile);
return 0;
}
/** json structure
* This file contains definition of json structure
**/
#include <err.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdbool.h>
#include <sqlite3.h>
#include "database.h"
#include "ccan/talloc/talloc.h"
#include "ccan/string/string.h"
#include "utils.h"
#include "tools/tools.h"
struct json
{
char *module;
char *title;
char *author;
char **depends;
char **desc;
};
/* Function for storing json structure to file given struct json*/
static int storejsontofile(const struct json *jsonobj, const char *jsonfile);
/*Function to store in database*/
static int storejsontodb(const struct json *jsonobj, const char *db);
/*create json structure*/
static struct json *createjson(char **infofile, const char *author, const char *directory);
/*Extract info from file*/
static char **extractinfo(char **file);
/* SQLite3 database backend. */
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <sqlite3.h>
#include "database.h"
#include "utils.h"
/* sqlite3_busy_timeout sleeps for a *second*. What a piece of shit. */
static int busy(void *unused __attribute__((unused)), int count)
{
usleep(50000);
/* If we've been stuck for 1000 iterations (at least 50
* seconds), give up. */
return (count < 1000);
}
void *db_open(const char *file)
{
sqlite3 *handle;
int err = sqlite3_open(file, &handle);
if (err != SQLITE_OK)
printf("Error %i from sqlite3_open of db '%s'\n", err, file);
sqlite3_busy_handler(handle, busy, NULL);
return handle;
}
static int query_cb(void *data, int num, char**vals,
char**names __attribute__((unused)))
{
int i;
struct db_query *query = data;
query->rows = realloc_array(query->rows, query->num_rows+1);
query->rows[query->num_rows] = new_array(char *, num);
for (i = 0; i < num; i++) {
/* We don't count rows with NULL results
* (eg. count(*),player where count turns out to be
* zero. */
if (!vals[i])
return 0;
query->rows[query->num_rows][i] = strdup(vals[i]);
}
query->num_rows++;
return 0;
}
/* Runs query (SELECT). Fails if > 1 row returned. Fills in columns. */
struct db_query *db_query(void *h, const char *query)
{
struct db_query *ret;
char *err;
ret = (struct db_query*) palloc(sizeof(struct db_query));
ret->rows = NULL;
ret->num_rows = 0;
if (sqlite3_exec(h, query, query_cb, ret, &err) != SQLITE_OK)
printf("Failed sqlite3 query '%s': %s", query, err);
return ret;
}
/* Runs command (CREATE TABLE/INSERT) */
void db_command(void *h, const char *command)
{
char *err;
if (sqlite3_exec(h, command, NULL, NULL, &err) != SQLITE_OK)
printf("Failed sqlite3 command '%s': %s", command, err);
}
/* Closes database (only called when everything OK). */
void db_close(void *h)
{
sqlite3_close(h);
}
#define _GNU_SOURCE
#include <stdio.h>
#include "utils.h"
#include <string.h>
#include <limits.h>
#include <stdint.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <err.h>
#include <assert.h>
#include "utils.h"
void * palloc(int size)
{
void *p;
p = malloc(size);
if(p == NULL) {
printf("Error Malloc does not allocate\n");
exit(1);
}
return p;
}
char *aprintf(const char *fmt, ...)
{
char *ret;
va_list arglist;
va_start(arglist, fmt);
vasprintf(&ret, fmt, arglist);
va_end(arglist);
return ret;
}
void strreplace(char * str, char src, char dest)
{
int i;
for(i = 0; str[i]; i++)
if(str[i] == src)
str[i] = dest;
}
void *_realloc_array(void *ptr, size_t size, size_t num)
{
if (num >= SIZE_MAX/size)
return NULL;
return realloc_nofail(ptr, size * num);
}
void *realloc_nofail(void *ptr, size_t size)
{
ptr = realloc(ptr, size);
if (ptr)
return ptr;
err(1, "realloc of %zu failed", size);
}
#include <stdarg.h>
#include <stdbool.h>
#include <string.h>
#define new_array(type, num) realloc_array((type *)0, (num))
#define realloc_array(ptr, num) ((__typeof__(ptr))_realloc_array((ptr), sizeof((*ptr)), (num)))
void *realloc_nofail(void *ptr, size_t size);
void *_realloc_array(void *ptr, size_t size, size_t num);
void * palloc(int size);
char *aprintf(const char *fmt, ...);
void strreplace(char * str, char src, char dest);
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment