tools/dump-fig.c

   1 /*
   2  * dump-fig.c --
   3  *
   4  *      Operations to dump graphic representation of MIBs in fig format.
   5  *
   6  * Copyright (c) 1999 J. Schoenwaelder, Technical University of Braunschweig.
   7  *
   8  * See the file "COPYING" for information on usage and redistribution
   9  * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
  10  *
  11  * @(#) $Id: dump-fig.c 1050 2000-11-29 16:34:45Z strauss $
  12  */
  13
  14 #include <config.h>
  15
  16 #include <stdlib.h>
  17 #include <stdio.h>
  18 #include <string.h>
  19
  20 #include "smi.h"
  21 #include "smidump.h"
  22
  23
  24 #define  X_OFFSET       225
  25 #define  Y_OFFSET       225
  26 #define  X_INDENT       225
  27 #define  Y_INDENT       225
  28
  29
  30
  31 static void setupPage()
  32 {
  33     printf("#FIG 3.2\n"
  34            "#\n"
  35            "# This FIG file has been generated by smidump " SMI_VERSION_STRING
  36            ". Do not edit.\n#\n"
  37            "Landscape\n"
  38            "Center\n"
  39            "Metric\n"
  40            "A4\n"
  41            "50.00\n"
  42            "Single\n"
  43            "-1\n"
  44            "1200 2\n");
  45 }
  46
  47
  48
  49 static void printString(int x, int y, int angle, char *string)
  50 {
  51     int height = 180, length = 22;
  52
  53     printf("4 0 0 0 0 18 12 0.0 4 %d %d %d %d %s\\001\n",
  54            height, length, x, y, string);
  55 }
  56
  57
  58
  59 static int isGroup(SmiNode *smiNode)
  60 {
  61     SmiNode *childNode;
  62
  63     for(childNode = smiGetFirstChildNode(smiNode);
  64         childNode;
  65         childNode = smiGetNextChildNode(childNode)) {
  66         if ((childNode->nodekind == SMI_NODEKIND_SCALAR
  67              || childNode->nodekind == SMI_NODEKIND_TABLE)
  68             && childNode->status == SMI_STATUS_CURRENT) {
  69             return 1;
  70         }
  71     }
  72
  73     return 0;
  74 }
  75
  76
  77
  78 static void printGroup(int *x, int *y, SmiNode *smiNode)
  79 {
  80     SmiNode *childNode;
  81     char string[4096];
  82
  83     *y += Y_OFFSET;
  84     printString(*x, *y, 0, smiNode->name);
  85
  86     for(childNode = smiGetFirstChildNode(smiNode);
  87         childNode;
  88         childNode = smiGetNextChildNode(childNode)) {
  89         if (childNode->nodekind == SMI_NODEKIND_SCALAR
  90             || childNode->nodekind == SMI_NODEKIND_COLUMN) {
  91             if (childNode->status != SMI_STATUS_OBSOLETE) {
  92                 *y += Y_OFFSET;
  93                 sprintf(string, "%s(%d)", childNode->name,
  94                         childNode->oid[childNode->oidlen-1]);
  95                 printString(*x + X_INDENT, *y, 0, string);
  96             }
  97         }
  98     }
  99     *y += Y_OFFSET;
 100 }
 101
 102
 103
 104 static void printGroups(int *x, int *y, SmiModule *smiModule)
 105 {
 106     SmiNode *smiNode;
 107
 108     for(smiNode = smiGetFirstNode(smiModule, SMI_NODEKIND_ANY);
 109         smiNode;
 110         smiNode = smiGetNextNode(smiNode, SMI_NODEKIND_ANY)) {
 111         if (isGroup(smiNode)) {
 112             printGroup(x, y, smiNode);
 113         }
 114         if (smiNode->nodekind == SMI_NODEKIND_ROW) {
 115             printGroup(x, y, smiNode);
 116         }
 117     }
 118 }
 119
 120
 121
 122 void dumpFigTree(Module *module)
 123 {
 124     SmiModule    *smiModule;
 125     int          x, y;
 126
 127     smiModule = module->smiModule;
 128
 129     setupPage();
 130
 131     x = X_OFFSET, y = Y_OFFSET;
 132     printGroups(&x, &y, smiModule);
 133 }
 134
 135
 136
 137 static void printClass(int *x, int *y, SmiNode *smiNode)
 138 {
 139     SmiNode *childNode;
 140     SmiType *smiType;
 141     char string[4096];
 142
 143     *y += Y_OFFSET;
 144     printString(*x, *y, 0, smiNode->name);
 145
 146     for(childNode = smiGetFirstChildNode(smiNode);
 147         childNode;
 148         childNode = smiGetNextChildNode(childNode)) {
 149         if (childNode->nodekind == SMI_NODEKIND_SCALAR
 150             || childNode->nodekind == SMI_NODEKIND_COLUMN) {
 151             if (childNode->status != SMI_STATUS_OBSOLETE) {
 152                 smiType = smiGetNodeType(childNode);
 153                 *y += Y_OFFSET;
 154                 sprintf(string, "%s : %s", childNode->name, smiType->name);
 155                 printString(*x + X_INDENT, *y, 0, string);
 156             }
 157         }
 158     }
 159     *y += Y_OFFSET;
 160 }
 161
 162
 163
 164 static void printClasses(int *x, int *y, SmiModule *smiModule)
 165 {
 166     SmiNode *smiNode;
 167
 168     for(smiNode = smiGetFirstNode(smiModule, SMI_NODEKIND_ANY);
 169         smiNode;
 170         smiNode = smiGetNextNode(smiNode, SMI_NODEKIND_ANY)) {
 171         if (isGroup(smiNode)) {
 172             printClass(x, y, smiNode);
 173         }
 174         if (smiNode->nodekind == SMI_NODEKIND_ROW) {
 175             printClass(x, y, smiNode);
 176         }
 177     }
 178 }
 179
 180
 181
 182 void dumpFigUml(Module *module)
 183 {
 184     SmiModule    *smiModule;
 185     int          x, y;
 186
 187     smiModule = module->smiModule;
 188
 189     setupPage();
 190
 191     x = X_OFFSET, y = Y_OFFSET;
 192     printClasses(&x, &y, smiModule);
 193 }
 194
 195
 196
 197 void init_fig()
 198 {
 199     static SmidumpDriver driverTree = {
 200         "fig-tree",
 201         dumpFigTree,
 202         SMI_FLAG_NODESCR,
 203         SMIDUMP_DRIVER_CANT_UNITE | SMIDUMP_DRIVER_CANT_OUTPUT,
 204         "tree graphics in xfig fig format",
 205         NULL,
 206         NULL
 207     };
 208     static SmidumpDriver driverUml = {
 209         "fig-uml",
 210         dumpFigUml,
 211         SMI_FLAG_NODESCR,
 212         SMIDUMP_DRIVER_CANT_UNITE | SMIDUMP_DRIVER_CANT_OUTPUT,
 213         "UML graphics in xfig fig format",
 214         NULL,
 215         NULL
 216     };
 217
 218     smidumpRegisterDriver(&driverTree);
 219     smidumpRegisterDriver(&driverUml);
 220 }