prnttree.c

C程序漏洞检查

              indented(level);
            enum_list_cnt++;
            do_recur(root->lnode, level);
            if (root->rnode)
              strcat(PBuf, ",\n");
            indented(level);
            do_recur(root->rnode, level);
            if (--enum_list_cnt == 0)
              strcat(PBuf, "\n");
            break;

        case TN_FIELD_LIST:
            do_recur(root->lnode, level);
            do_recur(root->rnode, level);
            break;

        case TN_PARAM_LIST:
            do_recur(root->lnode, level);
            if (root->rnode)
              strcat(PBuf, ",");
            do_recur(root->rnode, level);
            break;

        case TN_IDENT_LIST:
            do_recur(root->lnode, level);
            do_recur(root->rnode, level);
            break;

        case TN_TYPE_LIST:
            do_recur(root->lnode, level);
            do_recur(root->rnode, level);
            break;

        case TN_DECL:
            if (decl_cnt == 0)
              indented(level);
            decl_cnt++;
            do_recur(root->lnode, level);
            do_recur(root->rnode, level);
            if (--decl_cnt == 0)
            {  strcat(PBuf, ";");
	       if (can_flush) strcat(PBuf, "\n");
	    }
            break;

        case TN_DECL_LIST:
            do_recur(root->lnode, level);
            if ((root->rnode
	    && (root->rnode->hdr.type == TN_IDENT))
            || (root->rnode->lnode
            && ((root->rnode->lnode->hdr.type == TN_IDENT)
            || (root->rnode->lnode->hdr.type == TN_PNTR))) )
              strcat(PBuf, ",");
            do_recur(root->rnode, level);
            break;

        case TN_DECLS:
            do_recur(root->lnode, level);
            if ((root->rnode && (root->rnode->hdr.type == TN_IDENT))
            || (root->rnode->lnode
            && ((root->rnode->lnode->hdr.type == TN_IDENT)
            || (root->rnode->lnode->hdr.type == TN_PNTR))) )
              strcat(PBuf, ",");
            do_recur(root->rnode, level);
            break;

        case TN_STEMNT_LIST:
            do_recur(root->lnode, level);
            if (root->lnode
            && (!just_left_blk)
            && (root->lnode->hdr.type != TN_STEMNT_LIST))
                strcat(PBuf, ";\n");

            if (root->rnode != NULL) {
                do_recur(root->rnode, level);
                if (!just_left_blk)
                    strcat(PBuf, ";\n");
            }
            break;

        case TN_STEMNT:
            if (root->rnode
	    && (root->rnode->hdr.type == TN_LABEL))
              indented(level-1);
            else
              indented(level);
            do_recur(root->lnode, level);
            do_recur(root->rnode, level);
            break;

        case TN_COMP_DECL:
            indented(level);
            do_recur(root->lnode, level);
            do_recur(root->rnode, level);
            strcat(PBuf, ";");
	    if (can_flush) strcat(PBuf, "\n");
            break;

        case TN_BIT_FIELD:
            do_recur(root->lnode, level);
            strcat(PBuf, ":");
            do_recur(root->rnode, level);
            break;

        case TN_PNTR:
            strcat(PBuf, "*");
            do_recur(root->lnode, level);
            do_recur(root->rnode, level);
            break;

        case TN_TYPE_NME:
            do_recur(root->lnode, level);
            do_recur(root->rnode, level);
            break;

        case TN_INIT_LIST:
            do_recur(root->lnode, level);
            strcat(PBuf, ",");
            do_recur(root->rnode, level);
            break;

        case TN_INIT_BLK:
            strcat(PBuf, "{");
            do_recur(root->lnode, level);
            strcat(PBuf, ",");
            do_recur(root->rnode, level);
            strcat(PBuf, "}");
            break;

        case TN_OBJ_DEF:
            leaf = (leafnode *) root;
            strcat(PBuf, toksym(leaf->hdr.tok,1));
            do_recur(root->lnode, level);
            strcat(PBuf, " {\n");
            do_recur(root->rnode, level+1);
            strcat(PBuf, "}");
            break;

        case TN_OBJ_REF:
            leaf = (leafnode *) root;
            strcat(PBuf, toksym(leaf->hdr.tok,1));
            do_recur(root->lnode, level);
            strcat(PBuf, " ");
            do_recur(root->rnode, level);
            break;

        case TN_CAST:
            decl_cnt++;    /* Not really, it's a hack. */
            strcat(PBuf, "(");
            do_recur(root->lnode, level);
            strcat(PBuf, ")");
            decl_cnt--;
            do_recur(root->rnode, level);
            break;

        case TN_JUMP:
            strcat(PBuf, toksym(root->hdr.tok,1));
            if ((root->hdr.tok == RETURN)
	    || (root->hdr.tok == GOTO))
               do_recur(root->lnode, level);
            break;

        case TN_SWITCH:
            strcat(PBuf, "switch (");
            do_recur(root->lnode, level);
            strcat(PBuf, ")\n");
            do_recur(root->rnode, level+1);
            break;

        case TN_INDEX:
            do_recur(root->lnode, level);
            strcat(PBuf, "[");
            do_recur(root->rnode, level);
            strcat(PBuf, "]");
            break;

        case TN_DEREF:
            strcat(PBuf, "*");
            do_recur(root->lnode, level);
            if (root->rnode && (root->rnode->hdr.type == TN_IDENT))
              do_recur(root->rnode, level);
            else
            { strcat(PBuf, "(");
              do_recur(root->rnode, level);
              strcat(PBuf, ")");
            }
            break;

        case TN_SELECT:
            do_recur(root->lnode, level);
            strcat(PBuf, (root->hdr.tok == ARROW)? "->" : ".");
            do_recur(root->rnode, level);
            break;

        case TN_ASSIGN:
            do_recur(root->lnode, level);
            strcat(PBuf, toksym(root->hdr.tok,1));
            do_recur(root->rnode, level);
            break;

        case TN_EXPR:
            switch (root->hdr.tok) {
              case CASE:
                strcat(PBuf, toksym(root->hdr.tok,1));
                do_recur(root->lnode, level);
                do_recur(root->rnode, level);
                break;

              case SIZEOF:
                strcat(PBuf, toksym(root->hdr.tok,0));
                strcat(PBuf, "(");
                do_recur(root->lnode, level);
                do_recur(root->rnode, level);
                strcat(PBuf, ")");
                break;

              case INCR:
              case DECR:
                do_recur(root->lnode, level);
                strcat(PBuf, toksym(root->hdr.tok,1));
                do_recur(root->rnode, level);
                break;

              case B_AND:
                if (root->lnode == NULL) {
                  strcat(PBuf, toksym(root->hdr.tok,1));
                  strcat(PBuf, "(");
                  do_recur(root->rnode, level);
                  strcat(PBuf, ")");
                  break;
                }

              default:
                strcat(PBuf, "(");
                do_recur(root->lnode, level);
                strcat(PBuf, toksym(root->hdr.tok,1));
                do_recur(root->rnode, level);
                strcat(PBuf, ")");
                break;
            }
            break;

        case TN_WHILE:
            strcat(PBuf, "while (");
            do_recur(root->lnode, level);
            strcat(PBuf, ")\n");
            do_recur(root->rnode, level+1);
            break;

        case TN_DOWHILE:
            strcat(PBuf, "do\n");
            do_recur(root->rnode, level+1);
            if ((root->rnode->hdr.type == TN_STEMNT)
                    && (root->rnode->rnode->hdr.type != TN_BLOCK))
                strcat(PBuf, ";");
            strcat(PBuf, "\n");
            indented(level);
            strcat(PBuf, "while (");
            do_recur(root->lnode, level);
            strcat(PBuf, ")");
            break;

        case TN_LABEL:
            do_recur(root->lnode, level);
            if (root->lnode && (root->lnode->hdr.type != TN_LABEL))
              strcat(PBuf, ":\n");
            do_recur(root->rnode, level);
            break;

        case TN_EMPTY:
        default:
            fprintf(stderr, "%s: Unknown type of tree node (%d).\n",
		progname, root->hdr.type);
            break;
        }
        break;
    }
}

char *
buf_recur(treenode *root)
{
	strcpy(PBuf, "");
	do_recur(root, 0);
	return PBuf;
}

void
print_recur(treenode *root, FILE *fp)
{
	can_flush = fp;
	strcpy(PBuf, "");
	do_recur(root, 0);
	fprintf(fp, "%s", PBuf);
	can_flush = (FILE *) 0;
}