static int
calcSize(SmiModule *smiModule)
{
SmiNode *smiNode;
SmiType *smiType;
int size = 0;
for (smiType = smiGetFirstType(smiModule);
smiType;
smiType = smiGetNextType(smiType)) {
if (smiType->name) {
size++;
}
}
for (smiNode = smiGetFirstNode(smiModule, SMI_NODEKIND_ANY);
smiNode;
smiNode = smiGetNextNode(smiNode, SMI_NODEKIND_ANY)) {
switch (smiNode->nodekind) {
case SMI_NODEKIND_SCALAR:
case SMI_NODEKIND_COLUMN:
case SMI_NODEKIND_NOTIFICATION:
size++;
break;
default:
break;
}
}
return size;
}
static void fprintNodes(FILE *f, SmiModule *smiModule)
{
int i;
SmiNode *smiNode, *lastSmiNode;
SmiNodekind nodekinds;
nodekinds = SMI_NODEKIND_NODE | SMI_NODEKIND_TABLE |
SMI_NODEKIND_ROW | SMI_NODEKIND_COLUMN | SMI_NODEKIND_SCALAR |
SMI_NODEKIND_CAPABILITIES;
for (i = 0, lastSmiNode = NULL,
smiNode = smiGetFirstNode(smiModule, nodekinds);
smiNode;
i++, lastSmiNode = smiNode,
smiNode = smiGetNextNode(smiNode, nodekinds)) {
if (i == 0) {
fprintSegment(f, INDENT, "<nodes>\n", 0);
}
fprintNode(f, 2 * INDENT, smiNode, lastSmiNode);
}
if (lastSmiNode
&& lastSmiNode->nodekind == SMI_NODEKIND_COLUMN) {
fprintNodeEndTag(f, 3 * INDENT, "row");
fprintNodeEndTag(f, 2 * INDENT, "table");
}
if (i) {
fprintSegment(f, INDENT, "</nodes>\n\n", 0);
}
}
static void printAgtWriteMethodDecls(FILE *f, SmiModule *smiModule)
{
SmiNode *smiNode;
int cnt = 0;
for (smiNode = smiGetFirstNode(smiModule, SMI_NODEKIND_ANY);
smiNode;
smiNode = smiGetNextNode(smiNode, SMI_NODEKIND_ANY)) {
if (smiNode->access == SMI_ACCESS_READ_WRITE) {
cnt++;
if (cnt == 1) {
fprintf(f,
"/*\n"
" * Forward declaration of write methods for writable objects:\n"
" */\n\n");
}
fprintf(f,
"static int\nwrite_%s_stub(int,"
" u_char *, u_char, int, u_char *, oid *, int);\n",
smiNode->name);
}
}
if (cnt) {
fprintf(f, "\n");
}
}
static void printAgtWriteMethods(FILE *f, SmiModule *smiModule)
{
SmiNode *smiNode;
int cnt = 0;
for (smiNode = smiGetFirstNode(smiModule, SMI_NODEKIND_ANY);
smiNode;
smiNode = smiGetNextNode(smiNode, SMI_NODEKIND_ANY)) {
if (smiNode->access == SMI_ACCESS_READ_WRITE) {
cnt++;
if (cnt == 1) {
fprintf(f,
"/*\n"
" * Forward declaration of write methods for writable objects:\n"
" */\n\n");
}
fprintf(f,
"static int\nwrite_%s_stub(int action,\n"
" u_char *var_val,\n"
" u_char var_val_type,\n"
" int var_val_len,\n"
" u_char *statP,\n"
" oid *name,\n"
" int name_len)\n"
"{\n", smiNode->name);
fprintf(f,
" return SNMP_ERR_NOERROR;\n"
"}\n\n");
}
}
if (cnt) {
fprintf(f, "\n");
}
}
static void printAgtReadMethodDecls(FILE *f, SmiModule *smiModule)
{
SmiNode *smiNode;
int cnt = 0;
for (smiNode = smiGetFirstNode(smiModule, SMI_NODEKIND_ANY);
smiNode;
smiNode = smiGetNextNode(smiNode, SMI_NODEKIND_ANY)) {
if (isGroup(smiNode) && isAccessible(smiNode)) {
cnt++;
if (cnt == 1) {
fprintf(f,
"/*\n"
" * Forward declaration of read methods for groups of scalars and tables:\n"
" */\n\n");
}
fprintf(f,
"static unsigned char *\nread_%s_stub(struct variable *,"
" oid *, size_t *, int, size_t *, WriteMethod **);\n",
smiNode->name);
}
}
if (cnt) {
fprintf(f, "\n");
}
}
static void printHeaderTypedefs(FILE *f, SmiModule *smiModule)
{
SmiNode *smiNode;
int cnt = 0;
char *cModuleName;
char *cSmiNodeName;
for (smiNode = smiGetFirstNode(smiModule, SMI_NODEKIND_ANY);
smiNode;
smiNode = smiGetNextNode(smiNode, SMI_NODEKIND_ANY)) {
if (isGroup(smiNode) && isAccessible(smiNode)) {
cnt++;
printHeaderTypedef(f, smiModule, smiNode);
}
}
if (cnt) {
fprintf(f, "\n");
}
if (cnt) {
/*
* Should this go into the agent implementation module?
*/
cModuleName = translateLower(smiModule->name);
fprintf(f, "typedef struct %s {\n", cModuleName);
for (smiNode = smiGetFirstNode(smiModule, SMI_NODEKIND_ANY);
smiNode;
smiNode = smiGetNextNode(smiNode, SMI_NODEKIND_ANY)) {
if (isGroup(smiNode) && isAccessible(smiNode)) {
cSmiNodeName = translate(smiNode->name);
if (smiNode->nodekind == SMI_NODEKIND_ROW) {
fprintf(f, " %s_t\t*%s;\n", cSmiNodeName, cSmiNodeName);
} else {
fprintf(f, " %s_t\t%s;\n", cSmiNodeName, cSmiNodeName);
}
xfree(cSmiNodeName);
}
}
fprintf(f, "} %s_t;\n\n", cModuleName);
xfree(cModuleName);
}
}
static void
dumpNotificationPduSizes(FILE *f, SmiModule *smiModule)
{
SmiNode *smiNode;
for (smiNode = smiGetFirstNode(smiModule, SMI_NODEKIND_NOTIFICATION);
smiNode;
smiNode = smiGetNextNode(smiNode, SMI_NODEKIND_NOTIFICATION)) {
dumpSizeOfNotificationPDU(f, smiModule, smiNode);
}
}
static void
dumpSmallRowCreatePduSizes(FILE *f, SmiModule *smiModule)
{
SmiNode *smiNode;
for (smiNode = smiGetFirstNode(smiModule, SMI_NODEKIND_ROW);
smiNode;
smiNode = smiGetNextNode(smiNode, SMI_NODEKIND_ROW)) {
if (smiNode->create) {
dumpSizeOfCreatePDU(f, smiModule, smiNode, 1);
}
}
}
static void
dumpGroupPduSizes(FILE *f, SmiModule *smiModule)
{
SmiNode *smiNode;
for (smiNode = smiGetFirstNode(smiModule, SMI_NODEKIND_ANY);
smiNode;
smiNode = smiGetNextNode(smiNode, SMI_NODEKIND_ANY)) {
if (isGroup(smiNode)) {
dumpSizeOfPDU(f, smiModule, smiNode);
}
}
}
static void fprintCompliances(FILE *f, SmiModule *smiModule)
{
SmiNode *smiNode;
int i, typelen = 0, namelen = 0;
for (i = 0, smiNode = smiGetFirstNode(smiModule, SMI_NODEKIND_COMPLIANCE);
smiNode;
smiNode = smiGetNextNode(smiNode, SMI_NODEKIND_COMPLIANCE), i++) {
fprintf(f, "%s%s:\n", i ? "\n" : "", smiNode->name);
fprintCompliance(f, smiNode, &typelen, &namelen, 1);
fprintCompliance(f, smiNode, &typelen, &namelen, 2);
}
}
/*
* Creates the graph nodes of the given module
*/
static void algCreateNodes(SmiModule *module)
{
SmiNode *node;
/* get tables and scalars from the MIB module */
for (node = smiGetFirstNode(module, SMI_NODEKIND_TABLE);
node;
node = smiGetNextNode(node, SMI_NODEKIND_TABLE)) {
if (node->status != SMI_STATUS_OBSOLETE) {
if (!SUPPRESS_DEPRECATED || node->status != SMI_STATUS_DEPRECATED)
graphInsertNode(graph, node);
}
}
for (node = smiGetFirstNode(module, SMI_NODEKIND_SCALAR);
node;
node = smiGetNextNode(node, SMI_NODEKIND_SCALAR)) {
if (node->status != SMI_STATUS_OBSOLETE) {
if (!SUPPRESS_DEPRECATED || node->status != SMI_STATUS_DEPRECATED)
graphInsertNode(graph, node);
}
}
}
static void printClasses(int *x, int *y, SmiModule *smiModule)
{
SmiNode *smiNode;
for(smiNode = smiGetFirstNode(smiModule, SMI_NODEKIND_ANY);
smiNode;
smiNode = smiGetNextNode(smiNode, SMI_NODEKIND_ANY)) {
if (isGroup(smiNode)) {
printClass(x, y, smiNode);
}
if (smiNode->nodekind == SMI_NODEKIND_ROW) {
printClass(x, y, smiNode);
}
}
}
static void printAgtInit(FILE *f, SmiModule *smiModule)
{
SmiNode *smiNode;
int cnt = 0;
for (smiNode = smiGetFirstNode(smiModule, SMI_NODEKIND_ANY);
smiNode;
smiNode = smiGetNextNode(smiNode, SMI_NODEKIND_ANY)) {
if (isGroup(smiNode)) {
printAgtRegister(f, smiNode, ++cnt);
}
}
if (cnt) {
fprintf(f, "\n");
}
}
static void printCreateTables(SmiModule *smiModule)
{
SmiNode *smiNode;
int cnt = 0;
for(smiNode = smiGetFirstNode(smiModule, SMI_NODEKIND_ANY);
smiNode;
smiNode = smiGetNextNode(smiNode, SMI_NODEKIND_ANY)) {
if (isGroup(smiNode) && isAccessible(smiNode)) {
cnt++;
printCreateTable(smiNode);
}
}
if (cnt) {
printf("\n");
}
}
static void printMgrGetMethods(FILE *f, SmiModule *smiModule)
{
SmiNode *smiNode;
int cnt = 0;
for (smiNode = smiGetFirstNode(smiModule, SMI_NODEKIND_ANY);
smiNode;
smiNode = smiGetNextNode(smiNode, SMI_NODEKIND_ANY)) {
if (isGroup(smiNode) && isAccessible(smiNode)) {
cnt++;
printMgrGetMethod(f, smiModule, smiNode);
}
}
if (cnt) {
fprintf(f, "\n");
}
}
static void fprintNotifications(FILE *f, SmiModule *smiModule)
{
SmiNode *smiNode;
int i;
for(i = 0, smiNode = smiGetFirstNode(smiModule, SMI_NODEKIND_NOTIFICATION);
smiNode;
i++, smiNode = smiGetNextNode(smiNode, SMI_NODEKIND_NOTIFICATION)) {
if (i == 0) {
fprintSegment(f, INDENT, "<notifications>\n", 0);
}
fprintNotification(f, 2 * INDENT, smiNode);
}
if (i) {
fprintSegment(f, INDENT, "</notifications>\n\n", 0);
}
}
static void fprintGroups(FILE *f, SmiModule *smiModule)
{
SmiNode *smiNode;
int i;
for(i = 0, smiNode = smiGetFirstNode(smiModule, SMI_NODEKIND_GROUP);
smiNode;
i++, smiNode = smiGetNextNode(smiNode, SMI_NODEKIND_GROUP)) {
if (i == 0) {
fprintSegment(f, INDENT, "<groups>\n", 0);
}
fprintGroup(f, 2 * INDENT, smiNode);
}
if (i) {
fprintSegment(f, INDENT, "</groups>\n\n", 0);
}
}
/*
* prints all columns objects of the given node
*/
static void diaPrintXMLAllColumns(GraphNode *node)
{
SmiModule *module = NULL;
SmiNode *smiNode = NULL;
SmiNode *ppNode;
module = smiGetNodeModule(node->smiNode);
for (smiNode = smiGetFirstNode(module, SMI_NODEKIND_COLUMN);
smiNode;
smiNode = smiGetNextNode(smiNode, SMI_NODEKIND_COLUMN)) {
ppNode = smiGetParentNode(smiNode);
ppNode = smiGetParentNode(ppNode);
if (!algIsIndexElement(node->smiNode, smiNode) &&
cmpSmiNodes(node->smiNode, ppNode))
diaPrintXMLAttribute(smiNode, 0);
}
}
static void fprintCompliances(FILE *f, SmiModule *smiModule)
{
SmiNode *smiNode;
int i;
for(i = 0, smiNode = smiGetFirstNode(smiModule, SMI_NODEKIND_COMPLIANCE);
smiNode;
i++, smiNode = smiGetNextNode(smiNode, SMI_NODEKIND_COMPLIANCE)) {
if (!i) {
fprintSegment(f, INDENT, "<compliances>\n", 0);
}
fprintCompliance(f, 2 * INDENT, smiNode);
}
if (i) {
fprintSegment(f, INDENT, "</compliances>\n\n", 0);
}
}
static void createImportList(SmiModule *smiModule)
{
SmiNode *smiNode;
SmiType *smiType;
SmiModule *smiTypeModule;
SmiNodekind kind = SMI_NODEKIND_SCALAR | SMI_NODEKIND_COLUMN;
SmiImport *smiImport;
for (smiNode = smiGetFirstNode(smiModule, kind);
smiNode;
smiNode = smiGetNextNode(smiNode, kind)) {
smiType = smiGetNodeType(smiNode);
if (smiType && (smiType->decl == SMI_DECL_IMPLICIT_TYPE)) {
smiType = smiGetParentType(smiType);
}
if (smiType) {
smiTypeModule = smiGetTypeModule(smiType);
if (smiTypeModule &&
strcmp(smiTypeModule->name, smiModule->name)) {
if (strlen(smiTypeModule->name)) {
addImport(smiTypeModule->name, smiType->name);
}
}
if (smiType->basetype == SMI_BASETYPE_INTEGER32) {
addImport("SNMPv2-SMI", "Integer32");
}
}
}
for (smiImport = smiGetFirstImport(smiModule); smiImport;
smiImport = smiGetNextImport(smiImport)) {
if (islower((int) smiImport->name[0]) ||
(smiImport->module && !strcmp(smiImport->module, "SNMPv2-SMI")) ||
(smiImport->module && !strcmp(smiImport->module, "SNMPv2-TC"))) {
addImport(smiImport->module, smiImport->name);
}
}
}
static void printMgrOidDefinitions(FILE *f, SmiModule *smiModule)
{
SmiNode *smiNode;
char *cName;
unsigned int i;
for (smiNode = smiGetFirstNode(smiModule, SMI_NODEKIND_ANY);
smiNode;
smiNode = smiGetNextNode(smiNode, SMI_NODEKIND_ANY)) {
if (smiNode->nodekind & (SMI_NODEKIND_COLUMN | SMI_NODEKIND_SCALAR)
&& smiNode->access != SMI_ACCESS_NOTIFY) {
cName = translate(smiNode->name);
fprintf(f, "static oid %s[] = {", cName);
for (i = 0; i < smiNode->oidlen; i++) {
fprintf(f, "%s%u", i ? ", " : "", smiNode->oid[i]);
}
fprintf(f, "};\n");
xfree(cName);
}
}
fprintf(f, "\n");
}
static VALUE
get_oid_hash(SmiModule* module)
{
VALUE hash;
SmiNode* node;
hash = rb_hash_new();
node = smiGetFirstNode(module, NODE_KINDS);
while (node != NULL) {
char* oid_string;
VALUE name;
VALUE oid;
oid_string = smiRenderOID(node->oidlen, node->oid, SMI_RENDER_NUMERIC);
name = rb_str_new2(node->name);
oid = rb_str_new2(oid_string);
rb_hash_aset(hash, name, oid);
node = smiGetNextNode(node, NODE_KINDS);
}
return hash;
}
static void printAgtReadMethods(FILE *f, SmiModule *smiModule)
{
SmiNode *smiNode;
int cnt = 0;
for (smiNode = smiGetFirstNode(smiModule, SMI_NODEKIND_ANY);
smiNode;
smiNode = smiGetNextNode(smiNode, SMI_NODEKIND_ANY)) {
if (isGroup(smiNode) && isAccessible(smiNode)) {
cnt++;
if (cnt == 1) {
fprintf(f,
"/*\n"
" * Read methods for groups of scalars and tables:\n"
" */\n\n");
}
printAgtReadMethod(f, smiNode);
}
}
if (cnt) {
fprintf(f, "\n");
}
}
static void
addMetrics(Metrics *metrics, SmiModule *smiModule)
{
SmiNode *smiNode;
SmiType *smiType;
size_t len;
for (smiNode = smiGetFirstNode(smiModule, SMI_NODEKIND_ANY);
smiNode;
smiNode = smiGetNextNode(smiNode, SMI_NODEKIND_ANY)) {
len = smiNode->description ? strlen(smiNode->description) : 0;
switch (smiNode->nodekind) {
case SMI_NODEKIND_TABLE:
incrStatusCounter(&metrics->statusTables, smiNode->status);
incrStatusCounter(&metrics->statusAll, smiNode->status);
incrLengthCounter(&metrics->lengthTables,
smiNode->description, smiNode->reference,
smiNode->units, smiNode->format);
incrLengthCounter(&metrics->lengthAll,
smiNode->description, smiNode->reference,
smiNode->units, smiNode->format);
break;
case SMI_NODEKIND_ROW:
incrIndexCounter(&metrics->indexTables, smiNode->indexkind);
incrLengthCounter(&metrics->lengthRows,
smiNode->description, smiNode->reference,
smiNode->units, smiNode->format);
incrLengthCounter(&metrics->lengthAll,
smiNode->description, smiNode->reference,
smiNode->units, smiNode->format);
incrRowStatusCounter(smiNode);
{
int cnt = 0;
foreachIndexDo(NULL, smiNode, count, &cnt);
incrIndexLenCounter(&metrics->indexLenTables, cnt);
foreachIndexDo(NULL, smiNode, yadayada, smiModule);
}
{
int cmplx = 0;
foreachIndexDo(NULL, smiNode, complexity, &cmplx);
incrIndexComplexityCounter(smiModule, smiNode, cmplx);
incrIndexComplexityMetric(&metrics->indexComplexity, cmplx);
}
// count the childs ...
{
SmiModule *smiModule = smiGetModule("SNMPv2-TC");
SmiNode *childNode;
SmiType *rowStatus = smiGetType(smiModule, "RowStatus");
SmiType *storageType = smiGetType(smiModule, "StorageType");
// include index elements not in table
int n = 0;
for (childNode = smiGetFirstChildNode(smiNode);
childNode;
childNode = smiGetNextChildNode(childNode)) {
n++;
if (rowStatus == smiGetNodeType(childNode)) {
fprintf(stderr, "**** GEEEEEE - ROWSTATUS\n");
}
if (storageType == smiGetNodeType(childNode)) {
fprintf(stderr, "**** GEEEEEE - STORAGETYPE\n");
}
}
incrTableLenCounter(&metrics->tableLength, n);
}
break;
case SMI_NODEKIND_COLUMN:
incrBasetypeCounter(&metrics->basetypesColumns, smiNode);
incrBasetypeCounter(&metrics->basetypesAll, smiNode);
incrStatusCounter(&metrics->statusColumns, smiNode->status);
incrStatusCounter(&metrics->statusAll, smiNode->status);
incrAccessCounter(&metrics->accessColumns, smiNode->access);
incrAccessCounter(&metrics->accessAll, smiNode->access);
incrLengthCounter(&metrics->lengthColumns,
smiNode->description, smiNode->reference,
smiNode->units, smiNode->format);
incrLengthCounter(&metrics->lengthAll,
smiNode->description, smiNode->reference,
smiNode->units, smiNode->format);
incrTypeAndNodeUsageCounter(smiModule, smiNode, INCR_TYPE);
break;
case SMI_NODEKIND_SCALAR:
incrBasetypeCounter(&metrics->basetypesScalars, smiNode);
incrBasetypeCounter(&metrics->basetypesAll, smiNode);
incrStatusCounter(&metrics->statusScalars, smiNode->status);
incrStatusCounter(&metrics->statusAll, smiNode->status);
incrAccessCounter(&metrics->accessScalars, smiNode->access);
incrAccessCounter(&metrics->accessAll, smiNode->access);
incrLengthCounter(&metrics->lengthScalars,
smiNode->description, smiNode->reference,
smiNode->units, smiNode->format);
incrLengthCounter(&metrics->lengthAll,
smiNode->description, smiNode->reference,
smiNode->units, smiNode->format);
incrTypeAndNodeUsageCounter(smiModule, smiNode, INCR_TYPE);
break;
case SMI_NODEKIND_NOTIFICATION:
incrStatusCounter(&metrics->statusNotifications, smiNode->status);
incrStatusCounter(&metrics->statusAll, smiNode->status);
incrLengthCounter(&metrics->lengthNotifications,
smiNode->description, smiNode->reference,
smiNode->units, smiNode->format);
incrLengthCounter(&metrics->lengthAll,
smiNode->description, smiNode->reference,
smiNode->units, smiNode->format);
break;
case SMI_NODEKIND_GROUP:
incrStatusCounter(&metrics->statusGroups, smiNode->status);
incrStatusCounter(&metrics->statusAll, smiNode->status);
break;
case SMI_NODEKIND_COMPLIANCE:
incrStatusCounter(&metrics->statusCompliances, smiNode->status);
incrStatusCounter(&metrics->statusAll, smiNode->status);
break;
}
}
for (smiType = smiGetFirstType(smiModule);
smiType;
smiType = smiGetNextType(smiType)) {
/*
* Ignore all types with empty descriptions coming from the
* "SNMPv2-SMI" module since they are not really defined
* types but part of the language itself.
*/
if (! smiType->description) {
SmiModule *m = smiGetTypeModule(smiType);
if (m && strcmp(m->name, "SNMPv2-SMI") == 0) {
continue;
}
}
incrStatusCounter(&metrics->statusTypes, smiType->status);
incrStatusCounter(&metrics->statusAll, smiType->status);
incrLengthCounter(&metrics->lengthTypes,
smiType->description, smiType->reference,
smiType->units, smiType->format);
incrLengthCounter(&metrics->lengthAll,
smiType->description, smiType->reference,
smiType->units, smiType->format);
}
}
/*
* diaCalcSize
*
* Calculates the size of a given node for the UML representation.
*/
static GraphNode *diaCalcSize(GraphNode *node)
{
GraphEdge *tEdge;
SmiNode *tNode,*ppNode;
SmiElement *smiElement;
SmiModule *module;
if (node->smiNode->nodekind == SMI_NODEKIND_SCALAR) return node;
node->dia.w = (strlen(node->smiNode->name)+4) * HEADFONTSIZETABLE
+ HEADSPACESIZETABLE;
node->dia.h = TABLEHEIGHT;
for (smiElement = smiGetFirstElement(
smiGetFirstChildNode(node->smiNode));
smiElement;
smiElement = smiGetNextElement(smiElement)) {
tNode = smiGetElementNode(smiElement);
node->dia.w = max(node->dia.w, (strlen(tNode->name) +
strlen(algGetTypeName(tNode)) +
strlen(INDEXPROPERTY))
* ATTRFONTSIZE
+ ATTRSPACESIZE);
node->dia.h += TABLEELEMHEIGHT;
}
for (tEdge = graphGetFirstEdgeByNode(graph,node);
tEdge;
tEdge = graphGetNextEdgeByNode(graph, tEdge, node)) {
if (tEdge->startNode == node &&
tEdge->endNode->smiNode->nodekind == SMI_NODEKIND_SCALAR) {
node->dia.h += TABLEELEMHEIGHT;
tNode = tEdge->endNode->smiNode;
node->dia.w = max(node->dia.w, (strlen(tNode->name) +
strlen(algGetTypeName(tNode)))
* ATTRFONTSIZE
+ ATTRSPACESIZE);
}
}
if (PRINT_DETAILED_ATTR && node->smiNode->nodekind == SMI_NODEKIND_TABLE) {
module = smiGetNodeModule(node->smiNode);
for (tNode = smiGetFirstNode(module, SMI_NODEKIND_COLUMN);
tNode;
tNode = smiGetNextNode(tNode, SMI_NODEKIND_COLUMN)) {
ppNode = smiGetParentNode(tNode);
ppNode = smiGetParentNode(ppNode);
if (cmpSmiNodes(node->smiNode, ppNode)) {
int len;
char *typeName;
typeName = algGetTypeName(tNode);
len = strlen(tNode->name) + (typeName ? strlen(typeName) : 0);
node->dia.h += TABLEELEMHEIGHT;
node->dia.w = max(node->dia.w, len)
* ATTRFONTSIZE
+ ATTRSPACESIZE;
}
}
}
return node;
}
static void fprintNotifications(FILE *f, SmiModule *smiModule)
{
int i, j;
SmiNode *smiNode;
SmiElement *smiElement;
for(i = 0, smiNode = smiGetFirstNode(smiModule,
SMI_NODEKIND_NOTIFICATION);
smiNode;
smiNode = smiGetNextNode(smiNode, SMI_NODEKIND_NOTIFICATION)) {
if (!i && !silent) {
fprint(f, "//\n// NOTIFICATION DEFINITIONS\n//\n\n");
}
fprintSegment(f, INDENT, "", 0);
fprint(f, "notification %s {\n", smiNode->name);
if (smiNode->oid) {
fprintSegment(f, 2 * INDENT, "oid", INDENTVALUE);
fprint(f, "%s;\n", getOidString(smiNode, 0));
}
if ((smiElement = smiGetFirstElement(smiNode))) {
fprintSegment(f, 2 * INDENT, "objects", INDENTVALUE);
fprint(f, "(");
for (j = 0; smiElement;
j++, smiElement = smiGetNextElement(smiElement)) {
if (j) {
fprint(f, ", ");
}
fprintWrapped(f, INDENTVALUE + 1,
smiGetElementNode(smiElement)->name);
/* TODO: non-local name if non-local */
} /* TODO: empty? -> print error */
fprint(f, ");\n");
}
if ((smiNode->status != SMI_STATUS_CURRENT) &&
(smiNode->status != SMI_STATUS_UNKNOWN) &&
(smiNode->status != SMI_STATUS_MANDATORY) &&
(smiNode->status != SMI_STATUS_OPTIONAL)) {
fprintSegment(f, 2 * INDENT, "status", INDENTVALUE);
fprint(f, "%s;\n", getStringStatus(smiNode->status));
}
if (smiNode->description) {
fprintSegment(f, 2 * INDENT, "description", INDENTVALUE);
fprint(f, "\n");
fprintMultilineString(f, 2 * INDENT, smiNode->description);
fprint(f, ";\n");
}
if (smiNode->reference) {
fprintSegment(f, 2 * INDENT, "reference", INDENTVALUE);
fprint(f, "\n");
fprintMultilineString(f, 2 * INDENT, smiNode->reference);
fprint(f, ";\n");
}
fprintSegment(f, INDENT, "", 0);
fprint(f, "};\n\n");
i++;
}
}
static void fprintObjects(FILE *f, SmiModule *smiModule)
{
int i, j;
SmiNode *smiNode, *relatedNode;
SmiElement *smiElement;
SmiType *smiType;
int indent = 0;
int lastindent = -1;
char *s = NULL;
SmiNodekind nodekinds;
nodekinds = SMI_NODEKIND_NODE | SMI_NODEKIND_TABLE |
SMI_NODEKIND_ROW | SMI_NODEKIND_COLUMN | SMI_NODEKIND_SCALAR |
SMI_NODEKIND_CAPABILITIES;
for(i = 0, smiNode = smiGetFirstNode(smiModule, nodekinds);
smiNode; smiNode = smiGetNextNode(smiNode, nodekinds)) {
if (smiNode->nodekind == SMI_NODEKIND_NODE) {
indent = 0;
s = "node";
} else if (smiNode->nodekind == SMI_NODEKIND_CAPABILITIES) {
indent = 0;
s = "node";
} else if (smiNode->nodekind == SMI_NODEKIND_TABLE) {
indent = 0;
s = "table";
} else if (smiNode->nodekind == SMI_NODEKIND_ROW) {
indent = 1;
s = "row";
} else if (smiNode->nodekind == SMI_NODEKIND_COLUMN) {
indent = 2;
s = "column";
} else if (smiNode->nodekind == SMI_NODEKIND_SCALAR) {
indent = 0;
s = "scalar";
}
if (!i && !silent) {
fprint(f, "//\n// OBJECT DEFINITIONS\n//\n\n");
}
for (j = lastindent; j >= indent; j--) {
fprintSegment(f, (1 + j) * INDENT, "", 0);
fprint(f, "};\n");
}
fprint(f, "\n");
lastindent = indent;
if (smiNode->nodekind == SMI_NODEKIND_CAPABILITIES) {
fprintSegment(f, (1 + indent) * INDENT, "", 0);
fprint(f, "-- This has been an SMIv2 AGENT-CAPABILITIES node:\n");
}
fprintSegment(f, (1 + indent) * INDENT, "", 0);
fprint(f, "%s %s {\n", s, smiNode->name);
if (smiNode->oid) {
fprintSegment(f, (2 + indent) * INDENT, "oid", INDENTVALUE);
fprint(f, "%s;\n", getOidString(smiNode, 0));
}
smiType = smiGetNodeType(smiNode);
if (smiType && (smiType->basetype != SMI_BASETYPE_UNKNOWN)) {
fprintSegment(f, (2 + indent) * INDENT, "type", INDENTVALUE);
if (!smiType->name) {
/*
* an implicitly restricted type.
*/
fprint(f, "%s", getTypeString(smiType->basetype,
smiGetParentType(smiType)));
fprintSubtype(f, smiType);
fprint(f, ";\n");
} else {
fprint(f, "%s;\n",
getTypeString(smiType->basetype, smiType));
}
}
if ((smiNode->nodekind != SMI_NODEKIND_TABLE) &&
(smiNode->nodekind != SMI_NODEKIND_ROW) &&
(smiNode->nodekind != SMI_NODEKIND_CAPABILITIES) &&
(smiNode->nodekind != SMI_NODEKIND_NODE)) {
if (smiNode->access != SMI_ACCESS_UNKNOWN) {
fprintSegment(f, (2 + indent) * INDENT, "access", INDENTVALUE);
fprint(f, "%s;\n", getAccessString(smiNode->access));
}
}
relatedNode = smiGetRelatedNode(smiNode);
switch (smiNode->indexkind) {
case SMI_INDEX_INDEX:
if (smiNode->implied) {
fprintSegment(f, (2 + indent) * INDENT, "index implied",
INDENTVALUE);
} else {
fprintSegment(f, (2 + indent) * INDENT, "index", INDENTVALUE);
}
fprint(f, "(");
for (j = 0, smiElement = smiGetFirstElement(smiNode); smiElement;
j++, smiElement = smiGetNextElement(smiElement)) {
if (j) {
fprint(f, ", ");
}
fprintWrapped(f, INDENTVALUE + 1,
smiGetElementNode(smiElement)->name);
/* TODO: non-local name if non-local */
} /* TODO: empty? -> print error */
fprint(f, ");\n");
break;
case SMI_INDEX_AUGMENT:
if (relatedNode) {
fprintSegment(f, (2 + indent) * INDENT, "augments",
INDENTVALUE);
fprint(f, "%s;\n", relatedNode->name);
/* TODO: non-local name if non-local */
} /* TODO: else print error */
break;
case SMI_INDEX_REORDER:
if (relatedNode) {
fprintSegment(f, (2 + indent) * INDENT, "", 0);
fprint(f, "reorders %s", relatedNode->name);
/* TODO: non-local name if non-local */
if (smiNode->implied) {
fprint(f, " implied");
}
fprint(f, " (");
for (j = 0, smiElement = smiGetFirstElement(smiNode);
smiElement;
j++, smiElement = smiGetNextElement(smiElement)) {
if (j) {
fprint(f, ", ");
}
fprintWrapped(f, INDENTVALUE + 1,
smiGetElementNode(smiElement)->name);
/* TODO: non-local name if non-local */
} /* TODO: empty? -> print error */
fprint(f, ");\n");
} /* TODO: else print error */
break;
case SMI_INDEX_SPARSE:
if (relatedNode) {
fprintSegment(f, (2 + indent) * INDENT, "sparse", INDENTVALUE);
fprint(f, "%s;\n", relatedNode->name);
/* TODO: non-local name if non-local */
} /* TODO: else print error */
break;
case SMI_INDEX_EXPAND:
if (relatedNode) {
fprintSegment(f, (2 + indent) * INDENT, "", 0);
fprint(f, "expands %s", relatedNode->name);
/* TODO: non-local name if non-local */
if (smiNode->implied) {
fprint(f, " implied");
}
fprint(f, " (");
for (j = 0, smiElement = smiGetFirstElement(smiNode);
smiElement;
j++, smiElement = smiGetNextElement(smiElement)) {
if (j) {
fprint(f, ", ");
}
fprintWrapped(f, INDENTVALUE + 1,
smiGetElementNode(smiElement)->name);
/* TODO: non-local name if non-local */
} /* TODO: empty? -> print error */
fprint(f, ");\n");
} /* TODO: else print error */
break;
case SMI_INDEX_UNKNOWN:
break;
}
if (smiNode->create) {
fprintSegment(f, (2 + indent) * INDENT, "create", INDENTVALUE);
/* TODO: create list */
fprint(f, ";\n");
}
if (smiNode->value.basetype != SMI_BASETYPE_UNKNOWN) {
fprintSegment(f, (2 + indent) * INDENT, "default", INDENTVALUE);
fprint(f, "%s", getValueString(&smiNode->value, smiType));
fprint(f, ";\n");
}
if (smiNode->format) {
fprintSegment(f, (2 + indent) * INDENT, "format", INDENTVALUE);
fprint(f, "\"%s\";\n",smiNode->format);
}
if (smiNode->units) {
fprintSegment(f, (2 + indent) * INDENT, "units", INDENTVALUE);
fprint(f, "\"%s\";\n", smiNode->units);
}
if ((smiNode->status != SMI_STATUS_CURRENT) &&
(smiNode->status != SMI_STATUS_UNKNOWN) &&
(smiNode->status != SMI_STATUS_MANDATORY) &&
(smiNode->status != SMI_STATUS_OPTIONAL)) {
fprintSegment(f, (2 + indent) * INDENT, "status", INDENTVALUE);
fprint(f, "%s;\n", getStringStatus(smiNode->status));
}
if (smiNode->description) {
fprintSegment(f, (2 + indent) * INDENT, "description",
INDENTVALUE);
fprint(f, "\n");
fprintMultilineString(f, (2 + indent) * INDENT,
smiNode->description);
fprint(f, ";\n");
}
if (smiNode->reference) {
fprintSegment(f, (2 + indent) * INDENT, "reference",
INDENTVALUE);
fprint(f, "\n");
fprintMultilineString(f, (2 + indent) * INDENT,
smiNode->reference);
fprint(f, ";\n");
}
i++;
}
if (i) {
fprintSegment(f, (1 + indent) * INDENT, "", 0);
fprint(f, "};\n\n");
}
}
static void fprintCompliances(FILE *f, SmiModule *smiModule)
{
int i, j;
SmiNode *smiNode, *smiNode2;
SmiType *smiType;
SmiOption *smiOption;
SmiRefinement *smiRefinement;
SmiElement *smiElement;
for(i = 0, smiNode = smiGetFirstNode(smiModule, SMI_NODEKIND_COMPLIANCE);
smiNode; smiNode = smiGetNextNode(smiNode, SMI_NODEKIND_COMPLIANCE)) {
if (!i && !silent) {
fprint(f, "//\n// COMPLIANCE DEFINITIONS\n//\n\n");
}
fprintSegment(f, INDENT, "", 0);
fprint(f, "compliance %s {\n", smiNode->name);
if (smiNode->oid) {
fprintSegment(f, 2 * INDENT, "oid", INDENTVALUE);
fprint(f, "%s;\n", getOidString(smiNode, 0));
}
if ((smiNode->status != SMI_STATUS_CURRENT) &&
(smiNode->status != SMI_STATUS_UNKNOWN) &&
(smiNode->status != SMI_STATUS_MANDATORY) &&
(smiNode->status != SMI_STATUS_OPTIONAL)) {
fprintSegment(f, 2 * INDENT, "status", INDENTVALUE);
fprint(f, "%s;\n", getStringStatus(smiNode->status));
}
if (smiNode->description) {
fprintSegment(f, 2 * INDENT, "description", INDENTVALUE);
fprint(f, "\n");
fprintMultilineString(f, 2 * INDENT, smiNode->description);
fprint(f, ";\n");
}
if (smiNode->reference) {
fprintSegment(f, 2 * INDENT, "reference", INDENTVALUE);
fprint(f, "\n");
fprintMultilineString(f, 2 * INDENT, smiNode->reference);
fprint(f, ";\n");
}
if ((smiElement = smiGetFirstElement(smiNode))) {
fprint(f, "\n");
fprintSegment(f, 2 * INDENT, "mandatory", INDENTVALUE);
fprint(f, "(");
for (j = 0; smiElement;
j++, smiElement = smiGetNextElement(smiElement)) {
if (j) {
fprint(f, ", ");
}
fprintWrapped(f, INDENTVALUE + 1,
smiGetElementNode(smiElement)->name);
/* TODO: non-local name if non-local */
} /* TODO: empty? -> print error */
fprint(f, ");\n");
}
if ((smiOption = smiGetFirstOption(smiNode))) {
fprint(f, "\n");
for(; smiOption; smiOption = smiGetNextOption(smiOption)) {
smiNode2 = smiGetOptionNode(smiOption);
fprintSegment(f, 2 * INDENT, "", 0);
fprint(f, "optional %s {\n", smiNode2->name);
fprintSegment(f, 3 * INDENT, "description", INDENTVALUE);
fprint(f, "\n");
fprintMultilineString(f, 3 * INDENT, smiOption->description);
fprint(f, ";\n");
fprintSegment(f, 2 * INDENT, "};\n", 0);
}
}
if ((smiRefinement = smiGetFirstRefinement(smiNode))) {
fprint(f, "\n");
for(; smiRefinement;
smiRefinement = smiGetNextRefinement(smiRefinement)) {
fprintSegment(f, 2 * INDENT, "", 0);
fprint(f, "refine %s {\n",
smiGetRefinementNode(smiRefinement)->name);
smiType = smiGetRefinementType(smiRefinement);
if (smiType) {
fprintSegment(f, 3 * INDENT, "type", INDENTVALUE);
fprint(f, "%s",
getTypeString(smiType->basetype,
smiGetParentType(smiType)));
fprintSubtype(f, smiType);
fprint(f, ";\n");
}
smiType = smiGetRefinementWriteType(smiRefinement);
if (smiType) {
fprintSegment(f, 3 * INDENT, "writetype", INDENTVALUE);
fprint(f, "%s",
getTypeString(smiType->basetype,
smiGetParentType(smiType)));
fprintSubtype(f, smiType);
fprint(f, ";\n");
}
if (smiRefinement->access != SMI_ACCESS_UNKNOWN) {
fprintSegment(f, 3 * INDENT, "access", INDENTVALUE);
fprint(f, "%s;\n", getAccessString(smiRefinement->access));
}
fprintSegment(f, 3 * INDENT, "description", INDENTVALUE);
fprint(f, "\n");
fprintMultilineString(f, 3 * INDENT,
smiRefinement->description);
fprint(f, ";\n");
fprintSegment(f, 2 * INDENT, "};\n", 0);
}
}
fprintSegment(f, INDENT, "", 0);
fprint(f, "};\n\n");
i++;
}
}
