utmanage.c

DataDraw is an ultra-fast persistent database for high performance programs written in C. It s so fa

        } else {
            field = fieldTranslationTable[xField];
        }
        value = parseArrayValue(&valueList);
        if(field != NULL && !setObjectField(theClass, field, objectNumber, value)) {
            return false;
        }
    }
    return true;
}

/*--------------------------------------------------------------------------------------------------
  Read a line of text from stdin.
--------------------------------------------------------------------------------------------------*/
static bool readLine(void)
{
    uint32 linePosition = 0;
    int c;

    utDo {
        c = getc(utInputFile);
    } utWhile(c != '\n' && c != EOF) {
        if(linePosition == utLineSize) {
            utLineSize <<= 1;
            utResizeArray(utLineBuffer, utLineSize);
        }
        if(isprint(c)) {
            utLineBuffer[linePosition++] = c;
        }
    } utRepeat;
    if(c == EOF) {
        utAtEndOfFile = true;
    }
    if(linePosition == utLineSize) {
        utLineSize <<= 1;
        utResizeArray(utLineBuffer, utLineSize);
    }
    utLineBuffer[linePosition] = '\0';
    utLinePosition = 0;
    utLineNum++;
    return c != EOF;
}

/*--------------------------------------------------------------------------------------------------
  Find the length of the token.
--------------------------------------------------------------------------------------------------*/
static uint32 findTokenLength(void)
{
    uint32 linePosition = utLinePosition;
    char c = utLineBuffer[linePosition++];

    if(c == '\0') {
        return 0;
    }
    if(!isalnum(c) && c != '_') {
        return 1;
    }
    do {
        c = utLineBuffer[linePosition++];
    } while(isalnum(c) || c == '_');
    return linePosition - utLinePosition - 1;
}

/*--------------------------------------------------------------------------------------------------
  Just skip space.
--------------------------------------------------------------------------------------------------*/
void skipSpace(void)
{
    while(isspace(utLineBuffer[utLinePosition])) {
        utLinePosition++;
    }
}

/*--------------------------------------------------------------------------------------------------
  Read a token from the line buffer.
--------------------------------------------------------------------------------------------------*/
char *readToken(void)
{
    char *token;
    uint32 length;

    skipSpace();
    length = findTokenLength();
    token = utMakeString(length + 1);
    strncpy(token, utLineBuffer + utLinePosition, length);
    utLinePosition += length;
    token[length] = '\0';
    utLastToken = token;
    return token;
}

/*--------------------------------------------------------------------------------------------------
  Find the module with the given prefix.
--------------------------------------------------------------------------------------------------*/
utModule utFindModule(
    char *prefix)
{
    utModule module;
    uint8 xModule;

    for(xModule = 0; xModule < utUsedModules; xModule++) {
        module = utModules + xModule;
        if(!strcmp(module->prefix, prefix)) {
            return module;
        }
    }
    return NULL;
}

/*--------------------------------------------------------------------------------------------------
  Find the class with the given name.
--------------------------------------------------------------------------------------------------*/
static utClass findClass(
    utModule module,
    char *name)
{
    utClass theClass;
    uint16 xClass;

    for(xClass = 0; xClass < module->numClasses; xClass++) {
        theClass = utClasses + module->firstClassIndex + xClass;
        if(!strcmp(theClass->name, name)) {
            return theClass;
        }
    }
    return NULL;
}

/*--------------------------------------------------------------------------------------------------
  Find the field with the given name.
--------------------------------------------------------------------------------------------------*/
utField utFindField(
    utClass theClass,
    char *name)
{
    utField field;
    uint16 xField;

    for(xField = 0; xField < theClass->numFields; xField++) {
        field = utFields + theClass->firstFieldIndex + xField;
        if(!strcmp(field->name, name)) {
            return field;
        }
    }
    return NULL;
}

/*--------------------------------------------------------------------------------------------------
  Check that we parsed the whole line, and complain if we didn't.  Return true if the end was
  correct.
--------------------------------------------------------------------------------------------------*/
static bool expectEnd(void)
{
    char *token = readToken();

    if(*token != '\0') {
        reportError("Extra characters at end of command.\n");
        return false;
    }
    return true;
}

/*--------------------------------------------------------------------------------------------------
  Parse a module name.
--------------------------------------------------------------------------------------------------*/
static utModule parseModule(
    bool required,
    bool *error)
{
    utModule module;
    char *token = readToken();

    *error = false;
    if(*token == '\0') {
        if(required) {
            reportError("Expecting a module name.");
            *error = true;
        }
        return NULL;
    }
    module = utFindModule(token);
    if(module == NULL) {
        reportError("Invalid module name.");
        *error = true;
    }
    return module;
}

/*--------------------------------------------------------------------------------------------------
  Parse a class name.
--------------------------------------------------------------------------------------------------*/
static utClass parseClass(
    utModule module,
    bool required,
    bool *error)
{
    utClass theClass;
    char *token = readToken();

    *error = false;
    if(*token == '\0') {
        if(required) {
            reportError("Expecting a class name.");
            *error = true;
        }
        return NULL;
    }
    theClass = findClass(module, token);
    if(theClass == NULL) {
        reportError("Invalid class name.");
        *error = true;
    }
    return theClass;
}

/*--------------------------------------------------------------------------------------------------
  Parse an object number.
--------------------------------------------------------------------------------------------------*/
static uint64 parseObjectNumber(
    utClass theClass,
    bool required,
    bool *error)
{
    uint64 numUsed = utFindIntValue(theClass->numUsedPtr, theClass->referenceSize);
    char *token = readToken();
    uint64 objectNumber;

    *error = false;
    if(*token == '\0') {
        if(required) {
            reportError("Expecting an object number");
            *error = true;
        }
        return UINT64_MAX;
    }
    if(!readInteger((uint8 *)&objectNumber, token, 8, true)) {
        reportError("Invalid number");
        *error = true;
        return UINT64_MAX;
    }
    if(objectNumber >= numUsed) {
        reportError("Object number too large");
        *error = true;
        return UINT64_MAX;
    }
    return objectNumber;
}

/*--------------------------------------------------------------------------------------------------
  Process a list command.
--------------------------------------------------------------------------------------------------*/
static void processListCommand(void)
{
    bool error;
    utModule module = parseModule(false, &error);
    utClass theClass;

    if(error) {
        return;
    }
    if(module == NULL) {
        listModules();
        return;
    }
    theClass = parseClass(module, false, &error);
    if(error) {
        return;
    }
    if(theClass == NULL) {
        listClasses(module);
        return;
    }
    if(!expectEnd()) {
        return;
    }
    listFields(theClass);
}

/*--------------------------------------------------------------------------------------------------
  Process a show command.
--------------------------------------------------------------------------------------------------*/
static void processShowCommand(void)
{
    bool error;
    utModule module = parseModule(true, &error);
    utClass theClass;
    uint64 objectNumber;

    if(error) {
        return;
    }
    theClass = parseClass(module, true, &error);
    if(error) {
        return;
    }
    objectNumber = parseObjectNumber(theClass, false, &error);
    if(error) {
        return;
    }
    if(objectNumber == UINT64_MAX) {
        showClass(module, theClass);
        return;
    }
    if(!expectEnd()) {
        return;
    }
    showObject(theClass, objectNumber);
}

/*--------------------------------------------------------------------------------------------------
  Process a set command.
        "set <module> <class> <object number> = comma separated values – \n"
        "    set all fields of an object\n"
        "set <module> <class> <object number> <field> = <value> – set a field value\n"
--------------------------------------------------------------------------------------------------*/
static void processSetCommand(void)
{
    bool error;
    utModule module = parseModule(true, &error);
    utClass theClass;
    utField field;
    uint64 objectNumber;
    char *token;

    if(error) {
        return;
    }
    theClass = parseClass(module, true, &error);
    if(error) {
        return;
    }
    objectNumber = parseObjectNumber(theClass, true, &error);
    if(error) {
        return;
    }
    token = readToken();
    if(!strcmp(token, "=")) {
        skipSpace();
        setObjectFields(theClass, objectNumber, utLineBuffer + utLinePosition, NULL);
        return;
    }
    field = utFindField(theClass, token);
    if(field == NULL) {
        reportError("Field not found");
        return;
    }
    token = readToken();
    if(strcmp(token, "=")) {
        reportError("Expected '='");
        return;
    }
    skipSpace();
    setObjectField(theClass, field, objectNumber, utLineBuffer + utLinePosition);
}

/*--------------------------------------------------------------------------------------------------
  Process a create command.
--------------------------------------------------------------------------------------------------*/
static void processCreateCommand(void)
{
    bool error;
    utModule module = parseModule(true, &error);
    utClass theClass;

    if(error) {
        return;
    }
    theClass = parseClass(module, true, &error);
    if(error) {
        return;
    }
    if(theClass->constructor == NULL) {
        reportError("This is a class extension.  Call the base class constructor instead");
        return;
    }
    if(!expectEnd()) {
        return;
    }
    fprintf(utOutputFile, "New %s object 0x%llx\n", theClass->name, theClass->constructor());
}

/*--------------------------------------------------------------------------------------------------
  Destroy an object.
--------------------------------------------------------------------------------------------------*/
static void processDestroyCommand(void)
{
    bool error;
    utModule module = parseModule(true, &error);
    utClass theClass;
    uint64 objectNumber;

    if(error) {
        return;
    }
    theClass = parseClass(module, true, &error);
    if(error) {
        return;
    }
    objectNumber = parseObjectNumber(theClass, true, &error);
    if(error) {
        return;
    }
    if(!expectEnd()) {
        return;
    }
    if(theClass->destructor == NULL) {
        reportError("This class has no destructor, either because it is an extension, or "
            "because it is declared 'create_only'");
        return;
    }
    theClass->destructor(objectNumber);
    fprintf(utOutputFile, "Destroyed %s object 0x%llx\n", theClass->name, objectNumber);