tree.c

C程序漏洞检查

            break;

        case TN_FIELD_LIST:
        case TN_DECL_LIST:
        case TN_DECLS:
        case TN_PARAM_LIST:
	case TN_IDENT_LIST:
            find_ident_name(n->lnode,def,container,find);
            find_ident_name(n->rnode,def,container,find);
            break;

        case TN_ELLIPSIS:
            break;

        case TN_PNTR:
            break;

        case TN_FUNC_DECL:
            find_ident_name(n->lnode,def,container,find);
            break;

	case TN_BIT_FIELD:	/* added gjh */
		break;

        default:
            fprintf(stderr,
                    "%s: parse error:%d: "
                    "unknown node type (%s) in find_ident_name\n",
                    progname, n->hdr.line, name_of_node(n->hdr.type));
            break;
        }
    }
    break;

    case IF_T:
    case FOR_T:
    case NONE_T:
    default:
        fprintf(stderr,
            "%s: parse error:%d: unknown node in find_ident_name: %s\n",
            progname, n->hdr.line, name_of_nodetype(n->hdr.which));
        break;
    }
}

/* Scan fct decl node n for identifier naming the new function. */

leafnode *
find_func_name(treenode *n)
{
	while (n && (n->hdr.which != LEAF_T))
	{	switch(n->hdr.which) {
		case NODE_T:
			switch(n->hdr.type) {
			case TN_DECL:
				n = n->rnode;
				break;
			case TN_FUNC_DECL:
				n = n->lnode;
				break;
			default:
				goto bad;
			}
			break;
		case FOR_T:
			if (n->hdr.type == TN_FUNC_DEF)
				n = ((for_node *) n)->test;
			break;
		default:
bad:			fprintf(stderr,
				"%s: error: bad node in find_func_name;\n"
				"	node: %s, type: %s\n",
				progname, name_of_nodetype(n->hdr.which),
				name_of_node(n->hdr.type));
			n = NULL;
			break;
	}	}

	return (leafnode*) n;
}

void
find_params(treenode *decl, FindFunction find)
{
	if (!decl)
		return;

	switch(decl->hdr.which) {
	case NODE_T:
	        switch(decl->hdr.type) {
		case TN_DECL:
			if (decl->rnode
			&&  decl->rnode->hdr.which == NODE_T
			&&  decl->rnode->hdr.type == TN_FUNC_DECL)
				find_params(decl->rnode, find);
			else
				find_ident_name(decl,decl,NULL,find);
			break;
	
		case TN_DECL_LIST:
		case TN_DECLS:
			find_params(decl->lnode,find);
			find_params(decl->rnode,find);
			break;

		case TN_IDENT_LIST:
		case TN_PARAM_LIST:
			find_ident_name(decl->lnode,decl->lnode,NULL,find);
			find_ident_name(decl->rnode,decl->rnode,NULL,find);
			break;
	
		case TN_FUNC_DECL:
			find_params(decl->rnode,find);
			break;
	
		default:
			fprintf(stderr, "%s: parse error:%d: "
				"unknown node type (%s) in find_params\n",
				progname, decl->hdr.line,
				name_of_node(decl->hdr.type));
			break;
		}
		break;

	case LEAF_T:
		if (0) {	leafnode *leaf = (leafnode *) decl;
			switch (leaf->hdr.type) {
			case TN_IDENT:
				printf("	%s\n", leaf->data.sval->str);
				break;
			default:
				printf("	<leaftype: %d>\n", leaf->hdr.type);
				break;
			}
		}
		find_ident_name(decl,decl,NULL,find);
		break;

	case IF_T:
	case FOR_T:
	case NONE_T:
	default:
		fprintf(stderr, "%s: parse error:%d: unknown node in find_params,"
			"  type: %s\n", progname, decl->hdr.line,
			name_of_nodetype(decl->hdr.which));
		break;
	}
}

void
find_components(treenode *decl, treenode *def,
                      treenode *container, FindFunction find)
{
    if (!decl)
        return;

    switch(decl->hdr.which)
    {
        case NODE_T:
        {
            switch(decl->hdr.type)
            {
            case TN_COMP_DECL:
            case TN_DECL:
                find_ident_name(decl,decl,container,find);
                break;

            case TN_DECL_LIST:
            case TN_DECLS:
                find_components(decl->lnode,def,container,find);
                find_components(decl->rnode,def,container,find);
                break;

            case TN_FIELD_LIST:
                find_components(decl->lnode,def,container,find);
                find_components(decl->rnode,def,container,find);
                break;

            case TN_FUNC_DECL:
                find_components(decl->rnode,def,container,find);
                break;

            default:
                fprintf(stderr,
                    "%s: parse error: "
                    "unknown node type (%s) in find_components\n",
                    progname, name_of_node(decl->hdr.type));
                break;
            }
        }
    break;

    case LEAF_T:
    case IF_T:
    case FOR_T:
    case NONE_T:
    default:
        fprintf(stderr,
         "%s: parse error: unknown node %s in find_components;\n"
         "  type is: %s\n", progname, print_ptr(decl), name_of_nodetype(decl->hdr.which));
        break;
    }
}

#define    SHOW(X)    #X

char*
name_of_node(tn_t val)
{
    switch (val)
    {
    case TN_EMPTY:
        return SHOW(TN_EMPTY);

    case TN_FUNC_DEF:
        return SHOW(TN_FUNC_DEF);
    case TN_FUNC_DECL:
        return SHOW(TN_FUNC_DECL);
    case TN_FUNC_CALL:
        return SHOW(TN_FUNC_CALL);
    case TN_BLOCK:
        return SHOW(TN_BLOCK);
    case TN_DECL:
        return SHOW(TN_DECL);
    case TN_ARRAY_DECL:
        return SHOW(TN_ARRAY_DECL);

    case TN_TRANS_LIST:
        return SHOW(TN_TRANS_LIST);
    case TN_DECL_LIST:
        return SHOW(TN_DECL_LIST);
    case TN_DECLS:
        return SHOW(TN_DECLS);
    case TN_STEMNT_LIST:
        return SHOW(TN_STEMNT_LIST);
    case TN_EXPR_LIST:
        return SHOW(TN_EXPR_LIST);
    case TN_NAME_LIST:
        return SHOW(TN_NAME_LIST);
    case TN_ENUM_LIST:
        return SHOW(TN_ENUM_LIST);
    case TN_FIELD_LIST:
        return SHOW(TN_FIELD_LIST);
    case TN_PARAM_LIST:
        return SHOW(TN_PARAM_LIST);
    case TN_IDENT_LIST:
        return SHOW(TN_IDENT_LIST);

    case TN_COMP_DECL:
        return SHOW(TN_COMP_DECL);
    case TN_BIT_FIELD:
        return SHOW(TN_BIT_FIELD);
    case TN_PNTR:
        return SHOW(TN_PNTR);

    case TN_TYPE_LIST:
        return SHOW(TN_TYPE_LIST);
    case TN_TYPE_NME:
        return SHOW(TN_TYPE_NME);

    case TN_INIT_LIST:
        return SHOW(TN_INIT_LIST);
    case TN_INIT_BLK:
        return SHOW(TN_INIT_BLK);

    case TN_OBJ_DEF:
        return SHOW(TN_OBJ_DEF);
    case TN_OBJ_REF:
        return SHOW(TN_OBJ_REF);

    case TN_CAST:
        return SHOW(TN_CAST);
    case TN_IF:
        return SHOW(TN_IF);
    case TN_ASSIGN:
        return SHOW(TN_ASSIGN);
    case TN_JUMP:
        return SHOW(TN_JUMP);
    case TN_FOR:
        return SHOW(TN_FOR);
    case TN_WHILE:
        return SHOW(TN_WHILE);
    case TN_DOWHILE:
        return SHOW(TN_DOWHILE);
    case TN_SWITCH:
        return SHOW(TN_SWITCH);
    case TN_LABEL:
        return SHOW(TN_LABEL);
    case TN_STEMNT:
        return SHOW(TN_STEMNT);

    case TN_INDEX:
        return SHOW(TN_INDEX);
    case TN_DEREF:
        return SHOW(TN_DEREF);
    case TN_SELECT:
        return SHOW(TN_SELECT);

    case TN_EXPR:
        return SHOW(TN_EXPR);
    case TN_COND_EXPR:
        return SHOW(TN_COND_EXPR);

    case TN_COMMENT:
        return SHOW(TN_COMMENT);
    case TN_CPP:
        return SHOW(TN_CPP);

    case TN_ELLIPSIS:
        return SHOW(TN_ELLIPSIS);
    case TN_IDENT:
        return SHOW(TN_IDENT);
    case TN_TYPE:
        return SHOW(TN_TYPE);
    case TN_STRING:
        return SHOW(TN_STRING);

    case TN_INT:
        return SHOW(TN_INT);

    case TN_REAL:
        return SHOW(TN_REAL);

    default:
        return "<Unknown Node Name>";
    }
}

char*
name_of_nodetype(node_type val)
{
    switch (val)
    {
    case NONE_T:
        return SHOW(NONE_T);
    case LEAF_T:
        return SHOW(LEAF_T);
    case IF_T:
        return SHOW(IF_T);
    case FOR_T:
        return SHOW(FOR_T);
    case NODE_T:
        return SHOW(NODE_T);
    default:
        return "<Unknown Node Type>";
    }
}
#undef SHOW