static int get(void) {
if (*bp == 0) {
bp = buf;
*bp = 0;
if (fgets(buf, sizeof buf, infp) == NULL)
return EOF;
yylineno++;
while (buf[0] == '%' && buf[1] == '{' && buf[2] == '\n') {
for (;;) {
if (fgets(buf, sizeof buf, infp) == NULL) {
yywarn("unterminated %{...%}\n");
return EOF;
}
yylineno++;
if (strcmp(buf, "%}\n") == 0)
break;
fputs(buf, outfp);
}
if (fgets(buf, sizeof buf, infp) == NULL)
return EOF;
yylineno++;
}
}
return *bp++;
}
static void add_define (const char * name, int nargs, const char * exps)
{
defn_t *p = lookup_definition(name);
int h, len;
/* trim off leading and trailing whitespace */
while (uisspace(*exps)) exps++;
for (len = strlen(exps); len && uisspace(exps[len - 1]); len--);
if (*exps == '#' && *(exps + 1) == '#') {
yyerror("'##' at start of macro definition");
return;
}
if (len > 2 && *(exps + len - 2) == '#' && *(exps + len - 1) == '#') {
yyerror("'##' at end of macro definition");
return;
}
if (p) {
if (p->flags & DEF_IS_UNDEFINED) {
p->exps = (char *)DREALLOC(p->exps, len + 1, TAG_COMPILER, "add_define: redef");
memcpy(p->exps, exps, len);
p->exps[len] = 0;
p->flags = 0;
p->nargs = nargs;
} else {
if (p->flags & DEF_IS_PREDEF) {
yyerror("Illegal to redefine predefined value.");
return;
}
if (nargs != p->nargs || strcmp(exps, p->exps)) {
char buf[200 + NSIZE];
sprintf(buf, "redefinition of #define %s\n", name);
yywarn(buf);
p->exps = (char *)DREALLOC(p->exps, len + 1, TAG_COMPILER, "add_define: redef");
memcpy(p->exps, exps, len);
p->exps[len] = 0;
p->nargs = nargs;
}
#ifndef LEXER
p->flags &= ~DEF_IS_NOT_LOCAL;
#endif
}
} else {
p = ALLOCATE(defn_t, TAG_COMPILER, "add_define: def");
p->name = (char *) DXALLOC(strlen(name) + 1, TAG_COMPILER, "add_define: def name");
strcpy(p->name, name);
p->exps = (char *) DXALLOC(len + 1, TAG_COMPILER, "add_define: def exps");
memcpy(p->exps, exps, len);
p->exps[len] = 0;
p->flags = 0;
p->nargs = nargs;
h = defhash(name);
p->next = defns[h];
defns[h] = p;
}
}
void gen_op(tree_t *t, char *op1, char *op2) {
// Output operation
switch(t->attribute.opval) {
case OR:
case PLUS:
fprintf(yyout, "\taddl\t%s, %s\n", op1, op2);
break;
case MINUS:
fprintf(yyout, "\tsubl\t%s, %s\n", op1, op2);
break;
case AND:
case STAR:
fprintf(yyout, "\timull\t%s, %s\n", op1, op2);
break;
case SLASH:
case DIV:
fprintf(yyout, "\tmovl\t%s, %%eax\n\tmovl\t%%eax, -4(%%ebp)\n\tmovl\t%s, %%eax\n\tcltd\n", op1, op2);
fprintf(yyout, "\tidivl\t-4(%%ebp)\nmovl\t%%eax, %s\n", op2);
break;
case MOD:
fprintf(yyout, "\tmovl\t%s, %%eax\n\tmovl\t%%eax, -4(%%ebp)\n\tmovl\t%s, %%eax\n\tcltd\n", op1, op2);
fprintf(yyout, "\tidivl\t-4(%%ebp)\n\tmovl\t%%edx, %s\n", op2);
break;
case LT:
fprintf(yyout, "\tcmpl\t%s, %s\n\tjl\tsettrue%d\n", op1, op2, true_label);
fprintf(yyout, "\tmovl\t$0, %s\n\tjmp\tsetfalse%d\nsettrue%d:\n\tmovl\t$1, %s\nsetfalse%d:\n", op2, true_label, true_label, op2, true_label);
true_label++;
break;
case GT:
fprintf(yyout, "\tcmpl\t%s, %s\n\tjg\tsettrue%d\n", op1, op2, true_label);
fprintf(yyout, "\tmovl\t$0, %s\n\tjmp\tsetfalse%d\nsettrue%d:\n\tmovl\t$1, %s\nsetfalse%d:\n", op2, true_label, true_label, op2, true_label);
true_label++;
break;
case LE:
fprintf(yyout, "\tcmpl\t%s, %s\n\tjle\tsettrue%d\n", op1, op2, true_label);
fprintf(yyout, "\tmovl\t$0, %s\n\tjmp\tsetfalse%d\nsettrue%d:\n\tmovl\t$1, %s\nsetfalse%d:\n", op2, true_label, true_label, op2, true_label);
true_label++;
break;
case GE:
fprintf(yyout, "\tcmpl\t%s, %s\n\tjge\tsettrue%d\n", op1, op2, true_label);
fprintf(yyout, "\tmovl\t$0, %s\n\tjmp\tsetfalse%d\nsettrue%d:\n\tmovl\t$1, %s\nsetfalse%d:\n", op2, true_label, true_label, op2, true_label);
true_label++;
break;
case NE:
fprintf(yyout, "\tcmpl\t%s, %s\n\tjne\tsettrue%d\n", op1, op2, true_label);
fprintf(yyout, "\tmovl\t$0, %s\n\tjmp\tsetfalse%d\nsettrue%d:\n\tmovl\t$1, %s\nsetfalse%d:\n", op2, true_label, true_label, op2, true_label);
true_label++;
break;
case EQ:
fprintf(yyout, "\tcmpl\t%s, %s\n\tje\tsettrue%d\n", op1, op2, true_label);
fprintf(yyout, "\tmovl\t$0, %s\n\tjmp\tsetfalse%d\nsettrue%d:\n\tmovl\t$1, %s\nsetfalse%d:\n", op2, true_label, true_label, op2, true_label);
true_label++;
break;
default:
yywarn("operations not yet supported");
break;
}
}
/*
* Routine: MakeStringConstant(char *szText)
* Purpose: add an argument to the pre-existing list
* Algorithm:
* Data Structures:
*
* Params:
* Returns:
* Called By:
* Calls:
* Assumptions:
* Side Effects:
* TODO: None
*/
expr_t *
MakeVariableReference(char *szText, int nSuffix)
{
expr_t *pResult;
pResult = makeExpr();
AddBuffer(pResult->Value.pBuf, szText);
pResult->nFlags = EXPR_FL_SUBST | EXPR_FL_CHAR;
pResult->nSubElement = (nSuffix >= 1)?nSuffix:1;
if (!findSubstitution(pCurrentQuery, szText, &nSuffix))
yywarn("Substitution used before being defined");
return(pResult);
}
static void add_define P3(char *, name, int, nargs, char *, exps)
{
defn_t *p = lookup_definition(name);
int h;
if (p) {
if (p->flags & DEF_IS_UNDEFINED) {
p->exps = (char *)DREALLOC(p->exps, strlen(exps) + 1, TAG_COMPILER, "add_define: redef");
strcpy(p->exps, exps);
p->flags = 0;
p->nargs = nargs;
} else {
if (p->flags & DEF_IS_PREDEF) {
yyerror("Illegal to redefine predefined value.");
return;
}
if (nargs != p->nargs || strcmp(exps, p->exps)) {
char buf[200 + NSIZE];
sprintf(buf, "redefinition of #define %s\n", name);
yywarn(buf);
p->exps = (char *)DREALLOC(p->exps, strlen(exps) + 1, TAG_COMPILER, "add_define: redef");
strcpy(p->exps, exps);
p->nargs = nargs;
}
#ifndef LEXER
p->flags &= ~DEF_IS_NOT_LOCAL;
#endif
}
} else {
p = ALLOCATE(defn_t, TAG_COMPILER, "add_define: def");
p->name = (char *) DXALLOC(strlen(name) + 1, TAG_COMPILER, "add_define: def name");
strcpy(p->name, name);
p->exps = (char *) DXALLOC(strlen(exps) + 1, TAG_COMPILER, "add_define: def exps");
strcpy(p->exps, exps);
p->flags = 0;
p->nargs = nargs;
h = defhash(name);
p->next = defns[h];
defns[h] = p;
}
}
void gen_statement(tree_t *t) {
int local_if_label;
int local_while_label;
int local_for_label;
int num_args;
if (t->type == ARRAY || t->right->type == ARRAY || t->left->type == ARRAY) {
yyerror("Array access not supported");
}
switch(t->type) {
case ASSIGNOP:
// Generate code for expression
gen_label(t->right, 1);
gen_expression(t->right);
fprintf(yyout, "\tmovl\t%%ebx, %%eax\n");
// If this is actually a return statement, then return with correct value in %eax
if(!strcmp(t->left->attribute.variable->name, top_scope->curr->name))
fprintf(yyout, "\tjmp\tsubprog%send\n", top_scope->curr->name);
else {
// Generate code for assignment
gen_assignment(t->left);
}
break;
case IF:
local_if_label = if_label++;
//Generate code for expression
gen_label(t->left, 1);
gen_expression(t->left);
//Compare and jump accordingly
fprintf(yyout, "\tcmpl\t$1, %%ebx\n\tjge\tiftrue%d\n", local_if_label);
//Generate code for else first
if (t->right->right != NULL) {
gen_statement(t->right->right);
fprintf(yyout, "\tjmp\tifend%d\n", local_if_label);
}
//Generate code for true section
fprintf(yyout, "iftrue%d:\n", local_if_label);
gen_statement(t->right->left);
fprintf(yyout, "ifend%d:\n", local_if_label);
break;
case WHILE:
local_while_label = while_label++;
//Plant label for beginning of loop
fprintf(yyout, "beginwhile%d:\n", local_while_label);
//Generate code for expression
gen_label(t->left, 1);
gen_expression(t->left);
//Compare and jump to end if needed
fprintf(yyout, "\tcmpl\t$0, %%ebx\n\tje\tendwhile%d\n", local_while_label);
//Generate code for statements
gen_statement(t->right);
fprintf(yyout, "\tjmp\tbeginwhile%d\n", local_while_label);
fprintf(yyout, "endwhile%d:\n", local_while_label);
break;
case PROCEDURE:
if (!strcmp(t->left->attribute.variable->name, "read"))
gen_read(t->right);
else if (!strcmp(t->left->attribute.variable->name, "write"))
gen_write(t->right);
else if (t->right != NULL) {
// push arguments on the stack
num_args = gen_expression_list(t->right);
fprintf(yyout, "\tcall\tsubprog%s\n", t->left->attribute.variable->name);
// move the top of the stack below args
fprintf(yyout, "\taddl\t$%d, %%esp\n", 4*num_args);
}
else {
fprintf(yyout, "\tcall\tsubprog%s\n", t->left->attribute.variable->name);
}
break;
case COMMA:
// Generate left and right statements
if (t->left->type == ARRAY || t->right->type == ARRAY)
yyerror("Array access not supported");
else {
gen_statement(t->left);
gen_statement(t->right);
}
break;
case FOR:
local_for_label = for_label++;
// Generate assignment
gen_statement(t->left->left);
//Plant label for beginning
fprintf(yyout, "forloop%d:\n", local_for_label);
// Generate expression for TO value
gen_label(t->left->right, 1);
gen_expression(t->left->right);
//Compare and jump to end if needed
if (t->left->left->left->attribute.variable->local_or_parameter == LOCAL)
fprintf(yyout, "\tcmpl\t-%i(%%ebp), %%ebx\n\tjl\tforend%d\n",
t->left->left->left->attribute.variable->offset, local_for_label);
else
fprintf(yyout, "\tcmpl\t-%i(%%ebp), %%ebx\n\tjl\tforend%d\n",
t->left->left->left->attribute.variable->offset, local_for_label);
//Generate code for statements
gen_statement(t->right);
//Increment, jump to top then plant end label
fprintf(yyout, "\tincl\t-%i(%%ebp)\n\tjmp\tforloop%d\nforend%d:\n",
t->left->left->left->attribute.variable->offset,
local_for_label, local_for_label);
break;
default:
fprintf(stderr, "TYPE: %d\n", t->type);
yywarn("Statement not supported");
break;
}
}
void gen_expression(tree_t *t) {
char *reg;
// If the tree is actually a function, then take care of it here.
if (t->type == FUNCTION) {
// Push the arguments on the stack and call the function
int num_args = gen_expression_list(t->right);
fprintf(yyout, "\tcall\tsubprog%s\n", t->left->attribute.variable->name);
// Move the top of the stack back down below the arguments
fprintf(yyout, "\taddl\t$%d, %%esp\n", 4*num_args);
// Move the answer to the top of the register stack
fprintf(yyout, "\tmovl\t%%eax, %s\n", stack_top(registers));
}
// Case 0:
else if (t->right == NULL && t->left == NULL && t->label == 1) {
if (t->type == ID ) {
fprintf(yyout, "\tmovl\t%s, %s\n", find_variable(t), stack_top(registers));
}
else if (t->type == INUM) {
fprintf(yyout, "\tmovl\t$%i, %s\n", t->attribute.ival,
stack_top(registers));
}
else {
yywarn("Type not supported");
}
}
else {
// Case 1:
if (t->right->label == 0) {
// Go to left
gen_expression(t->left);
if (t->right->type == ID) {
gen_op(t, find_variable(t->right), stack_top(registers));
}
else if (t->right->type == INUM) {
sprintf(buff1, "$%i", t->right->attribute.ival);
gen_op(t, buff1, stack_top(registers));
}
else {
yywarn("Type not supported");
}
}
// Case 2:
else if (t->left->label >= 1 && t->right->label > t->left->label && t->left->label < NUM_REG) {
stack_swap(registers);
gen_expression(t->right);
reg = pop(registers);
gen_expression(t->left);
gen_op(t, reg, stack_top(registers));
push(registers, reg);
stack_swap(registers);
}
// Case 3:
else if (t->right->label >= 1 && t->left->label >= t->right->label && t->right->label < NUM_REG) {
gen_expression(t->left);
reg = pop(registers);
gen_expression(t->right);
gen_op(t, stack_top(registers), reg);
push(registers, reg);
}
// Case 4:
else {
yywarn("Temporaries not yet implemented");
}
}
}
parse_node_t *insert_pop_value P1(parse_node_t *, expr) {
parse_node_t *replacement;
if (!expr)
return 0;
if (expr->type == TYPE_NOVALUE) {
expr->type = TYPE_VOID;
return expr;
}
switch (expr->kind) {
case NODE_EFUN:
if (expr->v.number & NOVALUE_USED_FLAG) {
expr->v.number &= ~NOVALUE_USED_FLAG;
return expr;
}
break;
case NODE_TWO_VALUES:
/* (two-values expr1 expr2) where expr1 is already popped.
*
* instead of: (pop (two-values expr1 expr2))
* generated: (two-values expr (pop expr2))
*
* both of which generate the same code, but the second optimizes
* better in cases like: i++, j++
*
* we get: (two-values (inc i) (post-inc j))
* first: (pop (two-values (inc i) (post-inc j)))
* -> INC i; POST_INC j; POP
* second: (two-values (inc i) (inc j))
* -> INC i; INC j
*/
if ((expr->r.expr = insert_pop_value(expr->r.expr)))
return expr;
return expr->l.expr;
case NODE_IF:
/* a NODE_IF that gets popped is a (x ? y : z);
* propagate the pop in order to produce the same code as
* if (x) y; else z;
*/
expr->l.expr = insert_pop_value(expr->l.expr);
expr->r.expr = insert_pop_value(expr->r.expr);
if (!expr->l.expr && !expr->r.expr) {
/* if both branches do nothing, don't bother with the test ... */
return insert_pop_value(expr->v.expr);
}
return expr;
case NODE_TERNARY_OP:
switch (expr->r.expr->v.number) {
case F_NN_RANGE: case F_RN_RANGE: case F_RR_RANGE: case F_NR_RANGE:
expr->kind = NODE_TWO_VALUES;
expr->l.expr = insert_pop_value(expr->l.expr);
expr->r.expr->kind = NODE_TWO_VALUES;
expr->r.expr->l.expr = insert_pop_value(expr->r.expr->l.expr);
expr->r.expr->r.expr = insert_pop_value(expr->r.expr->r.expr);
if (!expr->l.expr) {
expr = expr->r.expr;
if (!expr->l.expr)
return expr->r.expr;
if (!expr->r.expr)
return expr->l.expr;
} else {
if (!expr->r.expr->l.expr) {
expr->r.expr = expr->r.expr->r.expr;
if (!expr->r.expr)
return expr->l.expr;
} else {
if (!expr->r.expr->r.expr)
expr->r.expr = expr->r.expr->l.expr;
}
}
return expr;
}
break;
/* take advantage of the fact that opcodes don't clash */
case NODE_CALL:
case NODE_BINARY_OP:
case NODE_UNARY_OP_1:
case NODE_UNARY_OP:
case NODE_OPCODE_1:
switch (expr->v.number) {
case F_AGGREGATE_ASSOC:
/* This has to be done specially b/c of the way mapping constants
are stored */
return throw_away_mapping(expr);
case F_AGGREGATE:
return throw_away_call(expr);
case F_PRE_INC: case F_POST_INC:
expr->v.number = F_INC;
return expr;
case F_PRE_DEC: case F_POST_DEC:
expr->v.number = F_DEC;
return expr;
case F_NOT: case F_COMPL: case F_NEGATE:
expr = insert_pop_value(expr->r.expr);
return expr;
case F_MEMBER:
expr = insert_pop_value(expr->r.expr);
return expr;
case F_LOCAL: case F_GLOBAL:
return 0;
case F_EQ: case F_NE: case F_GT: case F_GE: case F_LT: case F_LE:
yywarn("Value of conditional expression is unused");
/* FALLTHRU */
case F_OR: case F_XOR: case F_AND: case F_LSH: case F_RSH:
case F_ADD: case F_SUBTRACT: case F_MULTIPLY: case F_DIVIDE:
case F_MOD: case F_RE_RANGE: case F_NE_RANGE: case F_RINDEX:
case F_INDEX:
expr->kind = NODE_TWO_VALUES;
if ((expr->l.expr = insert_pop_value(expr->l.expr))) {
if ((expr->r.expr = insert_pop_value(expr->r.expr)))
return expr;
else
return expr->l.expr;
} else
return insert_pop_value(expr->r.expr);
break;
case F_ASSIGN:
if (IS_NODE(expr->r.expr, NODE_OPCODE_1, F_LOCAL_LVALUE)) {
int tmp = expr->r.expr->l.number;
expr->kind = NODE_UNARY_OP_1;
expr->r.expr = expr->l.expr;
expr->v.number = F_VOID_ASSIGN_LOCAL;
expr->l.number = tmp;
} else expr->v.number = F_VOID_ASSIGN;
return expr;
case F_ADD_EQ:
expr->v.number = F_VOID_ADD_EQ;
return expr;
}
break;
case NODE_PARAMETER:
case NODE_ANON_FUNC: /* some dweeb threw away one? */
case NODE_FUNCTION_CONSTRUCTOR:
return 0;
case NODE_NUMBER:
case NODE_STRING:
case NODE_REAL:
return 0;
}
CREATE_UNARY_OP(replacement, F_POP_VALUE, 0, expr);
return replacement;
}
int
main(int argc, char **argv)
{
int c;
int sts;
char *endnum;
iflag = isatty(0);
while ((c = pmgetopt_r(argc, argv, &opts)) != EOF) {
switch (c) {
case 'D': /* debug flag */
sts = __pmParseDebug(opts.optarg);
if (sts < 0) {
fprintf(stderr, "%s: unrecognized debug flag specification (%s)\n",
pmProgname, opts.optarg);
opts.errors++;
}
else
pmDebug |= sts;
break;
case 'e': /* echo input */
eflag++;
break;
case 'f': /* skip .dbpmdarc processing */
fflag++;
break;
case 'i': /* be interactive */
iflag = 1;
break;
case 'n': /* alternative name space file */
pmnsfile = opts.optarg;
break;
case 'q':
sts = (int)strtol(opts.optarg, &endnum, 10);
if (*endnum != '\0' || sts <= 0.0) {
pmprintf("%s: -q requires a positive numeric argument\n",
pmProgname);
opts.errors++;
} else {
_creds_timeout = sts;
}
break;
case 'U': /* run under alternate user account */
__pmSetProcessIdentity(opts.optarg);
break;
default:
case '?':
opts.errors++;
break;
}
}
if ((c = argc - opts.optind) > 0) {
if (c > 1)
opts.errors++;
else {
/* pid was specified */
if (primary) {
pmprintf("%s: you may not specify both -P and a pid\n",
pmProgname);
opts.errors++;
}
else {
pid = (int)strtol(argv[opts.optind], &endnum, 10);
if (*endnum != '\0') {
pmprintf("%s: pid must be a numeric process id\n",
pmProgname);
opts.errors++;
}
}
}
}
if (opts.errors) {
pmUsageMessage(&opts);
exit(1);
}
if (pmnsfile == PM_NS_DEFAULT) {
if ((sts = pmLoadNameSpace(pmnsfile)) < 0) {
fprintf(stderr, "%s: Cannot load default namespace: %s\n",
pmProgname, pmErrStr(sts));
exit(1);
}
}
else {
if ((sts = pmLoadASCIINameSpace(pmnsfile, 1)) < 0) {
fprintf(stderr, "%s: Cannot load namespace from \"%s\": %s\n",
pmProgname, pmnsfile, pmErrStr(sts));
exit(1);
}
}
/* initialize the "fake context" ... */
setup_context();
setlinebuf(stdout);
setlinebuf(stderr);
#ifdef HAVE_ATEXIT
atexit(cleanup);
#endif
for ( ; ; ) {
initmetriclist();
yyparse();
if (yywrap()) {
if (iflag)
putchar('\n');
break;
}
__pmSetInternalState(PM_STATE_PMCS);
switch (stmt_type) {
case OPEN:
profile_changed = 1;
break;
case CLOSE:
switch (connmode) {
case CONN_DSO:
closedso();
break;
case CONN_DAEMON:
closepmda();
break;
case NO_CONN:
yywarn("No PMDA currently opened");
break;
}
connmode = NO_CONN;
break;
case DESC:
switch (connmode) {
case CONN_DSO:
dodso(PDU_DESC_REQ);
break;
case CONN_DAEMON:
dopmda(PDU_DESC_REQ);
break;
case NO_CONN:
yywarn("No PMDA currently opened");
break;
}
break;
case FETCH:
switch (connmode) {
case CONN_DSO:
dodso(PDU_FETCH);
break;
case CONN_DAEMON:
dopmda(PDU_FETCH);
break;
case NO_CONN:
yywarn("No PMDA currently opened");
break;
}
break;
case INSTANCE:
switch (connmode) {
case CONN_DSO:
dodso(PDU_INSTANCE_REQ);
break;
case CONN_DAEMON:
dopmda(PDU_INSTANCE_REQ);
break;
case NO_CONN:
yywarn("No PMDA currently opened");
break;
}
break;
case STORE:
switch (connmode) {
case CONN_DSO:
dodso(PDU_RESULT);
break;
case CONN_DAEMON:
dopmda(PDU_RESULT);
break;
case NO_CONN:
yywarn("No PMDA currently opened");
break;
}
break;
case HELP:
dohelp(param.number, param.pmid);
break;
case WATCH:
break;
case DBG:
pmDebug = param.number;
break;
case QUIT:
goto done;
case STATUS:
dostatus();
break;
case INFO:
switch (connmode) {
case CONN_DSO:
dodso(PDU_TEXT_REQ);
break;
case CONN_DAEMON:
dopmda(PDU_TEXT_REQ);
break;
case NO_CONN:
yywarn("No PMDA currently opened");
break;
}
break;
case NAMESPACE:
if (cmd_namespace != NULL)
free(cmd_namespace);
cmd_namespace = strdup(param.name);
if (cmd_namespace == NULL) {
fprintf(stderr, "%s: No memory for new namespace\n",
pmProgname);
exit(1);
}
pmUnloadNameSpace();
strcpy(cmd_namespace, param.name);
if ((sts = pmLoadASCIINameSpace(cmd_namespace, 1)) < 0) {
fprintf(stderr, "%s: Cannot load namespace from \"%s\": %s\n",
pmProgname, cmd_namespace, pmErrStr(sts));
pmUnloadNameSpace();
if (pmnsfile == PM_NS_DEFAULT) {
fprintf(stderr, "%s: Reload default namespace\n",
pmProgname);
if ((sts = pmLoadNameSpace(pmnsfile)) < 0) {
fprintf(stderr,
"%s: Cannot load default namespace: %s\n",
pmProgname, pmErrStr(sts));
exit(1);
}
}
else {
fprintf(stderr, "%s: Reload namespace from \"%s\"\n",
pmProgname, pmnsfile);
if ((sts = pmLoadASCIINameSpace(pmnsfile, 1)) < 0) {
fprintf(stderr,
"%s: Cannot load namespace from \"%s\""
": %s\n",
pmProgname, pmnsfile, pmErrStr(sts));
exit(1);
}
}
}
break;
case EOL:
break;
case PMNS_NAME:
switch (connmode) {
case CONN_DSO:
dodso(PDU_PMNS_IDS);
break;
case CONN_DAEMON:
dopmda(PDU_PMNS_IDS);
break;
case NO_CONN:
yywarn("No PMDA currently opened");
break;
}
break;
case PMNS_PMID:
switch (connmode) {
case CONN_DSO:
dodso(PDU_PMNS_NAMES);
break;
case CONN_DAEMON:
dopmda(PDU_PMNS_NAMES);
break;
case NO_CONN:
yywarn("No PMDA currently opened");
break;
}
break;
case PMNS_CHILDREN:
switch (connmode) {
case CONN_DSO:
dodso(PDU_PMNS_CHILD);
break;
case CONN_DAEMON:
dopmda(PDU_PMNS_CHILD);
break;
case NO_CONN:
yywarn("No PMDA currently opened");
break;
}
break;
case PMNS_TRAVERSE:
switch (connmode) {
case CONN_DSO:
dodso(PDU_PMNS_TRAVERSE);
break;
case CONN_DAEMON:
dopmda(PDU_PMNS_TRAVERSE);
break;
case NO_CONN:
yywarn("No PMDA currently opened");
break;
}
break;
case ATTR:
switch (connmode) {
case CONN_DSO:
dodso(PDU_AUTH);
break;
case CONN_DAEMON:
dopmda(PDU_AUTH);
break;
case NO_CONN:
yywarn("No PMDA currently opened");
break;
}
break;
default:
printf("Unexpected result (%d) from parser?\n", stmt_type);
break;
}
__pmSetInternalState(PM_STATE_APPL);
}
done:
cleanup();
exit(0);
}
