/*

 * smixlate.c --

 *

 *      Translate OIDs located in the input stream.

 *

 * Copyright (c) 2006 Juergen Schoenwaelder, International University Bremen.

 *

 * See the file "COPYING" for information on usage and redistribution

 * of this file, and for a DISCLAIMER OF ALL WARRANTIES.

 *

 * @(#) $Id: smilint.c 1867 2004-10-06 13:45:31Z strauss $

 */

#include <config.h>

#include <stdlib.h>

#include <stdio.h>

#include <string.h>

#include <ctype.h>

#include <assert.h>

#ifdef HAVE_UNISTD_H

#include <unistd.h>

#endif

#ifdef HAVE_WIN_H

#include "win.h"

#endif

#include "smi.h"

#include "shhopt.h"

#include "dstring.h"

static int flags;

static int aFlag = 0;	/* translate all OIDs */

static int fFlag = 0;	/* preserve formatting */

static void translate(dstring_t *token, dstring_t *subst)

{

    SmiNode *smiNode;

    SmiSubid oid[256];

    unsigned int oidlen = 0;

    unsigned int i;

    char *p;

    assert(token && subst);

    dstring_truncate(subst, 0);

    dstring_assign(subst, dstring_str(token));

    for (oidlen = 0, p = strtok(dstring_str(token), ". "); p;

	 oidlen++, p = strtok(NULL, ". ")) {

	oid[oidlen] = strtoul(p, NULL, 0);

    }

    smiNode = smiGetNodeByOID(oidlen, oid);

    if (smiNode &&

	(aFlag

	 || smiNode->nodekind == SMI_NODEKIND_SCALAR

	 || smiNode->nodekind == SMI_NODEKIND_COLUMN

	 || smiNode->nodekind == SMI_NODEKIND_NOTIFICATION

	 || smiNode->nodekind == SMI_NODEKIND_TABLE

	 || smiNode->nodekind == SMI_NODEKIND_ROW)) {

	dstring_assign(subst, smiNode->name);

	for (i = smiNode->oidlen; i < oidlen; i++) {

	    dstring_append_printf(subst, ".%d", oid[i]);

	}

    }

}

static void process(FILE *stream)

{

    int c, space = 0;

    enum { TXT, NUM, NUMDOT, NUMDOTNUM, OID, OIDDOT, EATSPACE } state = TXT;

    dstring_t *token, *subst;

    token = dstring_new();

    subst = dstring_new();

    if (! token || ! subst) {

	return;

    }

    /*

     * Shall we require iswhite() or ispunct() before and after the

     * OID?

     *

     * TODO: - translate instance identifier to something meaningful

     *         (e.g. foobar["name",32]) where possible

     *       - generate warnings if instance identifier are incomplete

     *       - provide a reverse translation service (-x) (but this is

     *         more complex since it is unclear how to identify names

     *	     - make the white space magic optional

     */

    while ((c = fgetc(stream)) != EOF) {

	switch (state) {

	case TXT:

	    fputs(dstring_str(token), stdout);

	    dstring_truncate(token, 0);

	    if (isdigit(c) && c >= '0' && c <= '2') {

		dstring_append_char(token, (char) c);

		state = NUM;

	    } else {

		fputc(c, stdout);

		fflush(stdout);

	    }

	    break;

	case NUM:

	    if (isdigit(c)) {

		dstring_append_char(token, (char) c);

	    } else if (c == '.') {

		dstring_append_char(token, (char) c);

		state = NUMDOT;

	    } else {

		dstring_append_char(token, (char) c);

		state = TXT;

	    }

	    break;

	case NUMDOT:

	    if (isdigit(c)) {

		dstring_append_char(token, (char) c);

		state = NUMDOTNUM;

	    } else {

		dstring_append_char(token, (char) c);

		state = TXT;

	    }

	    break;

	case NUMDOTNUM:

	    if (isdigit(c)) {

		dstring_append_char(token, (char) c);

	    } if (c == '.') {

		dstring_append_char(token, (char) c);

		state = OID;

	    } else {

		dstring_append_char(token, (char) c);

		state = TXT;

	    }

	    break;

	case OID:

	    if (isdigit(c)) {

		dstring_append_char(token, (char) c);

	    } else if (c == '.') {

		dstring_append_char(token, (char) c);

		state = OIDDOT;

	    } else {

		translate(token, subst);

		if (fFlag) {

		    if (dstring_len(subst) < dstring_len(token)) {

			dstring_expand(subst, dstring_len(token), ' ');

		    }

		}

		fputs(dstring_str(subst), stdout);

		if (dstring_len(subst) > dstring_len(token)) {

		    space = dstring_len(subst) - dstring_len(token) - 1;

		} else {

		    space = 0;

		}

		if (fFlag && space > 0 && c == ' ') {

		    state = EATSPACE;

		    space--;

		} else {

		    state = TXT;

		    space = 0;

		    fputc(c, stdout);

		}

		dstring_truncate(token, 0);

	    }

	    break;

	case OIDDOT:

	    if (isdigit(c)) {

		dstring_append_char(token, (char) c);

		state = OID;

	    } else {

		translate(token, subst);

		fputs(dstring_str(subst), stdout);

		fputc(c, stdout);

		dstring_truncate(token, 0);

		state = TXT;

	    }

	    break;

	case EATSPACE:

	    if (c == ' ' && space > 0) {

		space--;

	    } else {

		state = TXT;

	    }

	    break;

	}

    }

    if (dstring_len(token)) {

	switch (state) {

	case TXT:

	case NUM:

	case NUMDOT:

	case NUMDOTNUM:

	    fputs(dstring_str(token), stdout);

	    dstring_truncate(token, 0);

	    fputc(c, stdout);

	    fflush(stdout);

	    break;

	case OID:

	    if (isdigit(c)) {

		dstring_append_char(token, (char) c);

	    } else {

		translate(token, subst);

		if (fFlag) {

		    if (dstring_len(subst) < dstring_len(token)) {

			dstring_expand(subst, dstring_len(token), ' ');

		    }

		}

		fputs(dstring_str(subst), stdout);

		if (dstring_len(subst) > dstring_len(token)) {

		    space = dstring_len(subst) - dstring_len(token) - 1;

		} else {

		    space = 0;

		}

		if (fFlag && space > 0 && c == ' ') {

		    space--;

		} else {

		    space = 0;

		    fputc(c, stdout);

		}

		dstring_truncate(token, 0);

	    }

	    break;

	case OIDDOT:

	    if (isdigit(c)) {

		dstring_append_char(token, (char) c);

	    } else {

		translate(token, subst);

		fputs(dstring_str(subst), stdout);

		fputc(c, stdout);

		dstring_truncate(token, 0);

	    }

	    break;

	case EATSPACE:

	    if (c == ' ' && space > 0) {

		space--;

	    } else {

		fputc(c, stdout);

	    }

	    break;

	}

    }

}

static void usage()

{

    fprintf(stderr,

	    "Usage: smixlate [options] [module or path ...]\n"

	    "  -V, --version         show version and license information\n"

	    "  -h, --help            show usage information\n"

	    "  -c, --config=file     load a specific configuration file\n"

	    "  -p, --preload=module  preload <module>\n"

	    "  -r, --recursive       print errors also for imported modules\n"

	    "  -l, --level=level     set maximum level of errors and warnings\n"

	    "  -i, --ignore=prefix   ignore errors matching prefix pattern\n"

	    "  -I, --noignore=prefix do not ignore errors matching prefix pattern\n"

	    "  -a, --all             replace all OIDs (including OID prefixes)\n"

	    "  -f, --format          preserve formatting as much as possible\n");

}

static void help() { usage(); exit(0); }

static void version() { printf("smixlate " SMI_VERSION_STRING "\n"); exit(0); }

static void config(char *filename) { smiReadConfig(filename, "smixlate"); }

static void preload(char *module) { smiLoadModule(module); }

static void recursive() { flags |= SMI_FLAG_RECURSIVE; smiSetFlags(flags); }

static void level(int lev) { smiSetErrorLevel(lev); }

static void ignore(char *ign) { smiSetSeverity(ign, 128); }

static void noignore(char *ign) { smiSetSeverity(ign, -1); }

int main(int argc, char *argv[])

{

    int i;

    static optStruct opt[] = {

	/* short long              type        var/func       special       */

	{ 'a', "all",		 OPT_FLAG,   &aFlag,        0 },

	{ 'f', "format",         OPT_FLAG,   &fFlag,	    0 },

	{ 'h', "help",           OPT_FLAG,   help,          OPT_CALLFUNC },

	{ 'V', "version",        OPT_FLAG,   version,       OPT_CALLFUNC },

	{ 'c', "config",         OPT_STRING, config,        OPT_CALLFUNC },

	{ 'p', "preload",        OPT_STRING, preload,       OPT_CALLFUNC },

	{ 'r', "recursive",      OPT_FLAG,   recursive,     OPT_CALLFUNC },

	{ 'l', "level",          OPT_INT,    level,         OPT_CALLFUNC },

	{ 'i', "ignore",         OPT_STRING, ignore,        OPT_CALLFUNC },

	{ 'I', "noignore",       OPT_STRING, noignore,      OPT_CALLFUNC },

	{ 0, 0, OPT_END, 0, 0 }  /* no more options */

    };

    for (i = 1; i < argc; i++)

	if ((strstr(argv[i], "-c") == argv[i]) ||

	    (strstr(argv[i], "--config") == argv[i])) break;

    if (i == argc) 

	smiInit("smixlate");

    else

	smiInit(NULL);

    flags = smiGetFlags();

    flags |= SMI_FLAG_ERRORS;

    flags |= SMI_FLAG_NODESCR;

    smiSetFlags(flags);

    optParseOptions(&argc, argv, opt, 0);

    for (i = 1; i < argc; i++) {

	if (smiLoadModule(argv[i]) == NULL) {

	    fprintf(stderr, "smixlate: cannot locate module `%s'\n",

		    argv[i]);

	    smiExit();

	    exit(1);

	}

    }

    process(stdin);

    smiExit();

    return 0;

}