ed4005a839e943367d40fb25e0ed1a605f8190ad kent Tue Aug 6 17:43:49 2013 -0700 Making it generate a new function. diff --git src/utils/raToStructGen/raToStructGen.c src/utils/raToStructGen/raToStructGen.c index c21ff63..4f0fe58 100644 --- src/utils/raToStructGen/raToStructGen.c +++ src/utils/raToStructGen/raToStructGen.c @@ -1,265 +1,296 @@ /* raToStructGen - Write C code that will read/write a C structure from a ra file.. */ #include "common.h" #include "linefile.h" #include "hash.h" #include "options.h" #include "obscure.h" #include "sqlNum.h" #include "ra.h" #include "asParse.h" char *requiredAsComma = NULL; void usage() /* Explain usage and exit. */ { errAbort( "raToStructGen - Write C code that will read/write a C structure from a ra file.\n" "In some ways a poor cousin to AutoSql. Only handles numeric and string types, and\n" - "arrays of these\n" + "arrays of these.\n" "usage:\n" " raToStructGen guide.as output.c\n" "options:\n" " -required=comma,sep,list - comma separated list of required fields.\n" ); } /* Command line validation table. */ static struct optionSpec options[] = { {"required", OPTION_STRING}, {NULL, 0}, }; struct raToStructReader /* Something to help us parse RAs into C structures. */ { - struct xyzReader *next; + struct raToStructReader *next; char *name; /* Name of structure */ int fieldCount; /* Number of fields. */ char **fields; /* Names of all fields - not allocated here. */ char **requiredFields; /* Names of required fields - not allocated here */ int requiredFieldCount; /* Count of required fields. */ struct hash *fieldIds; /* So we can do hashLookup/switch instead of strcmp chain */ int *requiredFieldIds; /* An array of IDs of required fields. */ bool *fieldsObserved; /* An entry for each field we've observed. */ }; struct raToStructReader *raToStructReaderNew(char *name, int fieldCount, char **fields, int requiredFieldCount, char **requiredFields) /* Create a helper object for parsing an ra file into a C structure. This structure will * contain */ { struct raToStructReader *reader; AllocVar(reader); reader->name = cloneString(name); reader->fieldCount = fieldCount; reader->fields = fields; reader->requiredFieldCount = requiredFieldCount; reader->requiredFields = requiredFields; struct hash *fieldIds = reader->fieldIds = hashNew(4); int i; for (i=0; i<fieldCount; ++i) hashAddInt(fieldIds, fields[i], i); if (requiredFieldCount > 0) { AllocArray(reader->requiredFieldIds, requiredFieldCount); for (i=0; i<requiredFieldCount; ++i) { char *required = requiredFields[i]; struct hashEl *hel = hashLookup(fieldIds, required); if (hel == NULL) errAbort("Required field %s is not in field list", required); reader->requiredFieldIds[i] = ptToInt(hel->val); } } AllocArray(reader->fieldsObserved, fieldCount); return reader; } void raToStructReaderFree(struct raToStructReader **pReader) /* Free up memory associated with reader. */ { struct raToStructReader *reader = *pReader; if (reader != NULL) { freeMem(reader->name); freeHash(&reader->fieldIds); freeMem(reader->fieldIds); freeMem(reader->fieldsObserved); freez(pReader); } } void raToStructReaderCheckRequiredFields(struct raToStructReader *reader, struct lineFile *lf) /* Make sure that all required files have been seen in the stanza we just parsed. */ { int *requiredFieldIds = reader->requiredFieldIds; bool *fieldsObserved = reader->fieldsObserved; int i; for (i=0; i<reader->requiredFieldCount; ++i) { if (!fieldsObserved[requiredFieldIds[i]]) { - errAbort("Required field %s not found line %d of %s\n", reader->requiredFields[i], + errAbort("Required field %s not found line %d of %s", reader->requiredFields[i], lf->lineIx, lf->fileName); } } } - void raToStructGen(char *guideFile, char *outFileC) /* raToStructGen - Write C code that will read/write a C structure from a ra file. */ { int requiredCount = 0; char **requiredFields = NULL; if (requiredAsComma != NULL) { if (lastChar(requiredAsComma) == ',') trimLastChar(requiredAsComma); requiredCount = chopByChar(requiredAsComma, ',', NULL, 0); AllocArray(requiredFields, requiredCount); chopByChar(requiredAsComma, ',', requiredFields, requiredCount); } struct asObject *as = asParseFile(guideFile); if (as == NULL) errAbort("Nothing in %s", guideFile); if (as->next != NULL) errAbort("Multiple objects in %s, only one allowed", guideFile); -uglyf("%d of %d fields of %s are required\n", requiredCount, slCount(as->columnList), as->name); FILE *f = mustOpen(outFileC, "w"); +/* Print out start of reader-maker function. */ +fprintf(f, + "struct raToStructReader *%sRaReader()\n" + "/* Make a raToStructReader for %s */\n" + "{\n" + "static char *fields[] = {\n" + , as->name, as->name); + +/* Print out all field names */ +struct asColumn *col; +for (col = as->columnList; col != NULL; col = col->next) + fprintf(f, " \"%s\",\n", col->name); +fprintf(f, " };\n"); + +char *rfString = "NULL"; +if (requiredCount > 0) + { + fprintf(f, "static char *requiredFields[] = {\n"); + int i; + for (i=0; i<requiredCount; ++i) + fprintf(f, " \"%s\",\n", requiredFields[i]); + fprintf(f, " };\n"); + rfString = "requiredFields"; + } + +/* Print out end of reader->maker function. */ +fprintf(f, + "return raToStructReaderNew(\"%s\", %d, fields, %d, %s);\n" + "}\n" + "\n" + , as->name, slCount(as->columnList), requiredCount, rfString); + /* Print out start of parsing function. */ fprintf(f, "\n" -"struct %s *%sFromNextRaStanza(struct lineFile *lf, struct raToStructReader *reader)\n" +"struct %s *%sFromNextRa(struct lineFile *lf, struct raToStructReader *reader)\n" "/* Return next stanza put into an %s. */\n" "{\n" "if (!raSkipLeadingEmptyLines(lf, NULL))\n" " return NULL;\n" "\n" "struct %s *el;\n" "AllocVar(el);\n" "\n" "bool *fieldsObserved = reader->fieldsObserved;\n" "bzero(fieldsObserved, reader->fieldCount);\n" "\n" "char *tag, *val;\n" "while (raNextTagVal(lf, &tag, &val, NULL))\n" " {\n" " struct hashEl *hel = hashLookup(reader->fieldIds, tag);\n" " if (hel != NULL)\n" " {\n" " int id = ptToInt(hel->val);\n" " if (fieldsObserved[id])\n" " errAbort(\"Duplicate tag %%s line %%d of %%s\\n\", tag, lf->lineIx, lf->fileName);\n" " fieldsObserved[id] = TRUE;\n" " switch (id)\n" " {\n" , as->name, as->name, as->name, as->name); /* Now loop through and print out cases for each field. */ -struct asColumn *col; int colIx = 0; for (col = as->columnList; col != NULL; col = col->next) { fprintf(f, " case %d:\n", colIx++); fprintf(f, " {\n"); struct asTypeInfo *lt = col->lowType; enum asTypes type = lt->type; if (col->isList) { switch (type) { /* Handle numerical types */ case t_float: case t_double: case t_int: case t_uint: case t_short: case t_ushort: case t_off: case t_string: case t_lstring: if (col->linkedSizeName) { fprintf(f, " int %sSize;\n", col->name); fprintf(f, " sql%sDynamicArray(val, &el->%s, &%sSize);\n", lt->listyName, col->name, col->name); fprintf(f, " if (!fieldsObserved[%d])\n", asColumnFindIx(as->columnList, col->linkedSizeName)); fprintf(f, " errAbort(\"%s must precede %s\");\n", col->linkedSizeName, col->name); fprintf(f, " if (%sSize != el->%s)\n", col->name, col->linkedSizeName); fprintf(f, " errAbort(\"%s has wrong count\");\n", col->name); } else if (col->fixedSize) fprintf(f, " sql%sArray(val, el->%s, %d);\n", lt->listyName, col->name, col->fixedSize); else internalErr(); break; default: errAbort("Sorry, %s array column is too complex for this program", col->name); break; } } else { switch (type) { /* Handle numerical types */ case t_float: case t_double: case t_int: case t_uint: case t_short: case t_ushort: case t_off: fprintf(f, " el->%s = sql%s(val);\n", col->name, lt->nummyName); break; case t_string: case t_lstring: fprintf(f, " el->%s = cloneString(val);\n", col->name); break; default: errAbort("Sorry, %s column is too complex for this program", col->name); break; } } fprintf(f, " break;\n"); fprintf(f, " }\n"); } /* Print out end of parsing function. */ fprintf(f, " default:\n" " internalErr();\n" " break;\n" " }\n" " }\n" " }\n" "\n" "if (reader->requiredFieldIds != NULL)\n" " raToStructReaderCheckRequiredFields(reader, lf);\n" "return el;\n" "}\n" "\n" ); carefulClose(&f); +verbose(1, "Generated parser for %d required fields, %d total fields\n", + requiredCount, slCount(as->columnList)); } int main(int argc, char *argv[]) /* Process command line. */ { optionInit(&argc, argv, options); if (argc != 3) usage(); requiredAsComma = optionVal("required", NULL); raToStructGen(argv[1], argv[2]); return 0; }