HelenOS sources

/* [<][>][^][v][top][bottom][index][help] */
This source file includes following definitions.
stree_module_new
stree_modm_new
stree_csi_new
stree_csimbr_new
stree_ctor_new
stree_deleg_new
stree_enum_new
stree_embr_new
stree_fun_new
stree_var_new
stree_prop_new
stree_targ_new
stree_symbol_attr_new
stree_proc_new
stree_proc_arg_new
stree_fun_sig_new
stree_arg_attr_new
stree_stat_new
stree_vdecl_new
stree_if_new
stree_switch_new
stree_while_new
stree_for_new
stree_raise_new
stree_break_new
stree_return_new
stree_wef_new
stree_exps_new
stree_except_new
stree_if_clause_new
stree_when_new
stree_block_new
stree_expr_new
stree_assign_new
stree_binop_new
stree_unop_new
stree_new_new
stree_access_new
stree_call_new
stree_index_new
stree_as_new
stree_box_new
stree_nameref_new
stree_ident_new
stree_literal_new
stree_self_ref_new
stree_texpr_new
stree_taccess_new
stree_tapply_new
stree_tindex_new
stree_tliteral_new
stree_tnameref_new
stree_symbol_new
stree_program_new
stree_symbol_has_attr
stree_arg_has_attr
stree_is_csi_derived_from_csi
stree_symbol_is_static
stree_csi_find_targ
stree_enum_find_mbr
stree_csimbr_get_name
/*
 * Copyright (c) 2011 Jiri Svoboda
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * - Redistributions of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 * - Redistributions in binary form must reproduce the above copyright
 *   notice, this list of conditions and the following disclaimer in the
 *   documentation and/or other materials provided with the distribution.
 * - The name of the author may not be used to endorse or promote products
 *   derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

/** @file Stree (syntax tree) intermediate representation. */

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include "list.h"
#include "mytypes.h"

#include "stree.h"

/** Allocate new module.
 *
 * @return      New module
 */
stree_module_t *stree_module_new(void)
{
        stree_module_t *module;

        module = calloc(1, sizeof(stree_module_t));
        if (module == NULL) {
                printf("Memory allocation failed.\n");
                exit(1);
        }

        list_init(&module->members);
        return module;
}

/** Allocate new module member.
 *
 * @param mc    Module member class
 * @return      New module member
 */
stree_modm_t *stree_modm_new(modm_class_t mc)
{
        stree_modm_t *modm;

        modm = calloc(1, sizeof(stree_modm_t));
        if (modm == NULL) {
                printf("Memory allocation failed.\n");
                exit(1);
        }

        modm->mc = mc;
        return modm;
}

/** Allocate new CSI.
 *
 * @param cc    CSI class
 * @return      New CSI
 */
stree_csi_t *stree_csi_new(csi_class_t cc)
{
        stree_csi_t *csi;

        csi = calloc(1, sizeof(stree_csi_t));
        if (csi == NULL) {
                printf("Memory allocation failed.\n");
                exit(1);
        }

        csi->cc = cc;
        csi->ancr_state = ws_unvisited;
        csi->name = NULL;
        csi->base_csi = NULL;
        list_init(&csi->inherit);
        list_init(&csi->impl_if_ti);
        list_init(&csi->members);

        return csi;
}

/** Allocate new CSI member.
 *
 * @param cc    CSI member class
 * @return      New CSI member
 */
stree_csimbr_t *stree_csimbr_new(csimbr_class_t cc)
{
        stree_csimbr_t *csimbr;

        csimbr = calloc(1, sizeof(stree_csimbr_t));
        if (csimbr == NULL) {
                printf("Memory allocation failed.\n");
                exit(1);
        }

        csimbr->cc = cc;
        return csimbr;
}

/** Allocate new constructor.
 *
 * @return      New constructor
 */
stree_ctor_t *stree_ctor_new(void)
{
        stree_ctor_t *ctor;

        ctor = calloc(1, sizeof(stree_ctor_t));
        if (ctor == NULL) {
                printf("Memory allocation failed.\n");
                exit(1);
        }

        return ctor;
}

/** Allocate new member delegate.
 *
 * @return      New member delegate
 */
stree_deleg_t *stree_deleg_new(void)
{
        stree_deleg_t *deleg;

        deleg = calloc(1, sizeof(stree_deleg_t));
        if (deleg == NULL) {
                printf("Memory allocation failed.\n");
                exit(1);
        }

        return deleg;
}

/** Allocate new enum.
 *
 * @return      New enum
 */
stree_enum_t *stree_enum_new(void)
{
        stree_enum_t *enum_d;

        enum_d = calloc(1, sizeof(stree_enum_t));
        if (enum_d == NULL) {
                printf("Memory allocation failed.\n");
                exit(1);
        }

        return enum_d;
}

/** Allocate new enum member.
 *
 * @return      New enum member
 */
stree_embr_t *stree_embr_new(void)
{
        stree_embr_t *embr;

        embr = calloc(1, sizeof(stree_embr_t));
        if (embr == NULL) {
                printf("Memory allocation failed.\n");
                exit(1);
        }

        return embr;
}

/** Allocate new member function.
 *
 * @return      New member function
 */
stree_fun_t *stree_fun_new(void)
{
        stree_fun_t *fun;

        fun = calloc(1, sizeof(stree_fun_t));
        if (fun == NULL) {
                printf("Memory allocation failed.\n");
                exit(1);
        }

        return fun;
}

/** Allocate new member variable.
 *
 * @return      New member variable
 */
stree_var_t *stree_var_new(void)
{
        stree_var_t *var;

        var = calloc(1, sizeof(stree_var_t));
        if (var == NULL) {
                printf("Memory allocation failed.\n");
                exit(1);
        }

        return var;
}

/** Allocate new property.
 *
 * @return      New property
 */
stree_prop_t *stree_prop_new(void)
{
        stree_prop_t *prop;

        prop = calloc(1, sizeof(stree_prop_t));
        if (prop == NULL) {
                printf("Memory allocation failed.\n");
                exit(1);
        }

        return prop;
}

/** Allocate new type argument.
 *
 * @return      New type argument
 */
stree_targ_t *stree_targ_new(void)
{
        stree_targ_t *targ;

        targ = calloc(1, sizeof(stree_targ_t));
        if (targ == NULL) {
                printf("Memory allocation failed.\n");
                exit(1);
        }

        return targ;
}

/** Allocate new symbol attribute.
 *
 * @param sac   Symbol attribute class
 * @return      New symbol attribute
 */
stree_symbol_attr_t *stree_symbol_attr_new(symbol_attr_class_t sac)
{
        stree_symbol_attr_t *symbol_attr;

        symbol_attr = calloc(1, sizeof(stree_symbol_attr_t));
        if (symbol_attr == NULL) {
                printf("Memory allocation failed.\n");
                exit(1);
        }

        symbol_attr->sac = sac;
        return symbol_attr;
}

/** Allocate new procedure.
 *
 * @return      New procedure
 */
stree_proc_t *stree_proc_new(void)
{
        stree_proc_t *proc;

        proc = calloc(1, sizeof(stree_proc_t));
        if (proc == NULL) {
                printf("Memory allocation failed.\n");
                exit(1);
        }

        return proc;
}

/** Allocate new procedure argument.
 *
 * @return      New procedure argument
 */
stree_proc_arg_t *stree_proc_arg_new(void)
{
        stree_proc_arg_t *proc_arg;

        proc_arg = calloc(1, sizeof(stree_proc_arg_t));
        if (proc_arg == NULL) {
                printf("Memory allocation failed.\n");
                exit(1);
        }

        return proc_arg;
}

/** Allocate new function signature.
 *
 * @return      New procedure argument
 */
stree_fun_sig_t *stree_fun_sig_new(void)
{
        stree_fun_sig_t *fun_sig;

        fun_sig = calloc(1, sizeof(stree_fun_sig_t));
        if (fun_sig == NULL) {
                printf("Memory allocation failed.\n");
                exit(1);
        }

        return fun_sig;
}

/** Allocate new procedure argument attribute.
 *
 * @param       Argument attribute class
 * @return      New procedure argument attribute
 */
stree_arg_attr_t *stree_arg_attr_new(arg_attr_class_t aac)
{
        stree_arg_attr_t *arg_attr;

        arg_attr = calloc(1, sizeof(stree_arg_attr_t));
        if (arg_attr == NULL) {
                printf("Memory allocation failed.\n");
                exit(1);
        }

        arg_attr->aac = aac;
        return arg_attr;
}

/** Allocate new statement.
 *
 * @param sc    Statement class
 * @return      New statement
 */
stree_stat_t *stree_stat_new(stat_class_t sc)
{
        stree_stat_t *stat;

        stat = calloc(1, sizeof(stree_stat_t));
        if (stat == NULL) {
                printf("Memory allocation failed.\n");
                exit(1);
        }

        stat->sc = sc;
        return stat;
}

/** Allocate new local variable declaration.
 *
 * @return      New local variable declaration
 */
stree_vdecl_t *stree_vdecl_new(void)
{
        stree_vdecl_t *vdecl_s;

        vdecl_s = calloc(1, sizeof(stree_vdecl_t));
        if (vdecl_s == NULL) {
                printf("Memory allocation failed.\n");
                exit(1);
        }

        return vdecl_s;
}

/** Allocate new @c if statement.
 *
 * @return      New @c if statement
 */
stree_if_t *stree_if_new(void)
{
        stree_if_t *if_s;

        if_s = calloc(1, sizeof(stree_if_t));
        if (if_s == NULL) {
                printf("Memory allocation failed.\n");
                exit(1);
        }

        return if_s;
}

/** Allocate new @c switch statement.
 *
 * @return      New @c if statement
 */
stree_switch_t *stree_switch_new(void)
{
        stree_switch_t *switch_s;

        switch_s = calloc(1, sizeof(stree_switch_t));
        if (switch_s == NULL) {
                printf("Memory allocation failed.\n");
                exit(1);
        }

        return switch_s;
}

/** Allocate new @c while statement.
 *
 * @return      New @c while statement
 */
stree_while_t *stree_while_new(void)
{
        stree_while_t *while_s;

        while_s = calloc(1, sizeof(stree_while_t));
        if (while_s == NULL) {
                printf("Memory allocation failed.\n");
                exit(1);
        }

        return while_s;
}

/** Allocate new @c for statement.
 *
 * @return      New @c for statement
 */
stree_for_t *stree_for_new(void)
{
        stree_for_t *for_s;

        for_s = calloc(1, sizeof(stree_for_t));
        if (for_s == NULL) {
                printf("Memory allocation failed.\n");
                exit(1);
        }

        return for_s;
}

/** Allocate new @c raise statement.
 *
 * @return      New @c raise statement
 */
stree_raise_t *stree_raise_new(void)
{
        stree_raise_t *raise_s;

        raise_s = calloc(1, sizeof(stree_raise_t));
        if (raise_s == NULL) {
                printf("Memory allocation failed.\n");
                exit(1);
        }

        return raise_s;
}

/** Allocate new @c break statement.
 *
 * @return      New @c break statement
 */
stree_break_t *stree_break_new(void)
{
        stree_break_t *break_s;

        break_s = calloc(1, sizeof(stree_break_t));
        if (break_s == NULL) {
                printf("Memory allocation failed.\n");
                exit(1);
        }

        return break_s;
}

/** Allocate new @c return statement.
 *
 * @return      New @c return statement
 */
stree_return_t *stree_return_new(void)
{
        stree_return_t *return_s;

        return_s = calloc(1, sizeof(stree_return_t));
        if (return_s == NULL) {
                printf("Memory allocation failed.\n");
                exit(1);
        }

        return return_s;
}

/** Allocate new with-except-finally statement.
 *
 * @return      New with-except-finally statement.
 */
stree_wef_t *stree_wef_new(void)
{
        stree_wef_t *wef_s;

        wef_s = calloc(1, sizeof(stree_wef_t));
        if (wef_s == NULL) {
                printf("Memory allocation failed.\n");
                exit(1);
        }

        return wef_s;
}

/** Allocate new expression statement.
 *
 * @return      New expression statement
 */
stree_exps_t *stree_exps_new(void)
{
        stree_exps_t *exp_s;

        exp_s = calloc(1, sizeof(stree_exps_t));
        if (exp_s == NULL) {
                printf("Memory allocation failed.\n");
                exit(1);
        }

        return exp_s;
}

/** Allocate new @c except clause.
 *
 * @return      New @c except clause
 */
stree_except_t *stree_except_new(void)
{
        stree_except_t *except_c;

        except_c = calloc(1, sizeof(stree_except_t));
        if (except_c == NULL) {
                printf("Memory allocation failed.\n");
                exit(1);
        }

        return except_c;
}

/** Allocate new @c if/elif clause.
 *
 * @return      New @c if/elif clause
 */
stree_if_clause_t *stree_if_clause_new(void)
{
        stree_if_clause_t *if_clause;

        if_clause = calloc(1, sizeof(stree_if_clause_t));
        if (if_clause == NULL) {
                printf("Memory allocation failed.\n");
                exit(1);
        }

        return if_clause;
}

/** Allocate new @c when clause.
 *
 * @return      New @c when clause
 */
stree_when_t *stree_when_new(void)
{
        stree_when_t *when_c;

        when_c = calloc(1, sizeof(stree_when_t));
        if (when_c == NULL) {
                printf("Memory allocation failed.\n");
                exit(1);
        }

        return when_c;
}

/** Allocate new statement block.
 *
 * @return      New statement block
 */
stree_block_t *stree_block_new(void)
{
        stree_block_t *block;

        block = calloc(1, sizeof(stree_block_t));
        if (block == NULL) {
                printf("Memory allocation failed.\n");
                exit(1);
        }

        return block;
}

/** Allocate new expression.
 *
 * @param ec    Expression class
 * @return      New expression
 */
stree_expr_t *stree_expr_new(expr_class_t ec)
{
        stree_expr_t *expr;

        expr = calloc(1, sizeof(stree_expr_t));
        if (expr == NULL) {
                printf("Memory allocation failed.\n");
                exit(1);
        }

        expr->ec = ec;
        return expr;
}

/** Allocate new assignment.
 *
 * @param ac    Assignment class
 * @return      New assignment
 */
stree_assign_t *stree_assign_new(assign_class_t ac)
{
        stree_assign_t *assign;

        assign = calloc(1, sizeof(stree_assign_t));
        if (assign == NULL) {
                printf("Memory allocation failed.\n");
                exit(1);
        }

        assign->ac = ac;
        return assign;
}

/** Allocate new binary operation.
 *
 * @return      New binary operation
 */
stree_binop_t *stree_binop_new(binop_class_t bc)
{
        stree_binop_t *binop;

        binop = calloc(1, sizeof(stree_binop_t));
        if (binop == NULL) {
                printf("Memory allocation failed.\n");
                exit(1);
        }

        binop->bc = bc;
        return binop;
}

/** Allocate new unary operation.
 *
 * @param uc    Unary operation class
 * @return      New unary operation
 */
stree_unop_t *stree_unop_new(unop_class_t uc)
{
        stree_unop_t *unop;

        unop = calloc(1, sizeof(stree_unop_t));
        if (unop == NULL) {
                printf("Memory allocation failed.\n");
                exit(1);
        }

        unop->uc = uc;
        return unop;
}

/** Allocate new @c new operation.
 *
 * @return      New @c new operation
 */
stree_new_t *stree_new_new(void)
{
        stree_new_t *new_op;

        new_op = calloc(1, sizeof(stree_new_t));
        if (new_op == NULL) {
                printf("Memory allocation failed.\n");
                exit(1);
        }

        return new_op;
}

/** Allocate new .
 *
 * @return      New
 */
stree_access_t *stree_access_new(void)
{
        stree_access_t *access;

        access = calloc(1, sizeof(stree_access_t));
        if (access == NULL) {
                printf("Memory allocation failed.\n");
                exit(1);
        }

        return access;
}

/** Allocate new function call operation.
 *
 * @return      New function call operation
 */
stree_call_t *stree_call_new(void)
{
        stree_call_t *call;

        call = calloc(1, sizeof(stree_call_t));
        if (call == NULL) {
                printf("Memory allocation failed.\n");
                exit(1);
        }

        return call;
}

/** Allocate new indexing operation.
 *
 * @return      New indexing operation
 */
stree_index_t *stree_index_new(void)
{
        stree_index_t *index;

        index = calloc(1, sizeof(stree_index_t));
        if (index == NULL) {
                printf("Memory allocation failed.\n");
                exit(1);
        }

        return index;
}

/** Allocate new as conversion.
 *
 * @return      New as conversion
 */
stree_as_t *stree_as_new(void)
{
        stree_as_t *as_expr;

        as_expr = calloc(1, sizeof(stree_as_t));
        if (as_expr == NULL) {
                printf("Memory allocation failed.\n");
                exit(1);
        }

        return as_expr;
}

/** Allocate new boxing operation.
 *
 * @return      New boxing operation
 */
stree_box_t *stree_box_new(void)
{
        stree_box_t *box_expr;

        box_expr = calloc(1, sizeof(stree_box_t));
        if (box_expr == NULL) {
                printf("Memory allocation failed.\n");
                exit(1);
        }

        return box_expr;
}

/** Allocate new name reference operation.
 *
 * @return      New name reference operation
 */
stree_nameref_t *stree_nameref_new(void)
{
        stree_nameref_t *nameref;

        nameref = calloc(1, sizeof(stree_nameref_t));
        if (nameref == NULL) {
                printf("Memory allocation failed.\n");
                exit(1);
        }

        return nameref;
}

/** Allocate new identifier.
 *
 * @return      New identifier
 */
stree_ident_t *stree_ident_new(void)
{
        stree_ident_t *ident;

        ident = calloc(1, sizeof(stree_ident_t));
        if (ident == NULL) {
                printf("Memory allocation failed.\n");
                exit(1);
        }

        return ident;
}

/** Allocate new literal.
 *
 * @param ltc   Literal class
 * @return      New literal
 */
stree_literal_t *stree_literal_new(literal_class_t ltc)
{
        stree_literal_t *literal;

        literal = calloc(1, sizeof(stree_literal_t));
        if (literal == NULL) {
                printf("Memory allocation failed.\n");
                exit(1);
        }

        literal->ltc = ltc;
        return literal;
}

/** Allocate new @c self reference.
 *
 * @return      New @c self reference
 */
stree_self_ref_t *stree_self_ref_new(void)
{
        stree_self_ref_t *self_ref;

        self_ref = calloc(1, sizeof(stree_self_ref_t));
        if (self_ref == NULL) {
                printf("Memory allocation failed.\n");
                exit(1);
        }

        return self_ref;
}

/** Allocate new type expression
 *
 * @return      New type expression
 */
stree_texpr_t *stree_texpr_new(texpr_class_t tc)
{
        stree_texpr_t *texpr;

        texpr = calloc(1, sizeof(stree_texpr_t));
        if (texpr == NULL) {
                printf("Memory allocation failed.\n");
                exit(1);
        }

        texpr->tc = tc;
        return texpr;
}

/** Allocate new type access operation.
 *
 * @return      New type access operation
 */
stree_taccess_t *stree_taccess_new(void)
{
        stree_taccess_t *taccess;

        taccess = calloc(1, sizeof(stree_taccess_t));
        if (taccess == NULL) {
                printf("Memory allocation failed.\n");
                exit(1);
        }

        return taccess;
}

/** Allocate new type application operation.
 *
 * @return      New type application operation
 */
stree_tapply_t *stree_tapply_new(void)
{
        stree_tapply_t *tapply;

        tapply = calloc(1, sizeof(stree_tapply_t));
        if (tapply == NULL) {
                printf("Memory allocation failed.\n");
                exit(1);
        }

        return tapply;
}

/** Allocate new type indexing operation.
 *
 * @return      New type indexing operation
 */
stree_tindex_t *stree_tindex_new(void)
{
        stree_tindex_t *tindex;

        tindex = calloc(1, sizeof(stree_tindex_t));
        if (tindex == NULL) {
                printf("Memory allocation failed.\n");
                exit(1);
        }

        return tindex;
}

/** Allocate new type literal.
 *
 * @return      New type literal
 */
stree_tliteral_t *stree_tliteral_new(tliteral_class_t tlc)
{
        stree_tliteral_t *tliteral;

        tliteral = calloc(1, sizeof(stree_tliteral_t));
        if (tliteral == NULL) {
                printf("Memory allocation failed.\n");
                exit(1);
        }

        tliteral->tlc = tlc;
        return tliteral;
}

/** Allocate new type name reference.
 *
 * @return      New type name reference
 */
stree_tnameref_t *stree_tnameref_new(void)
{
        stree_tnameref_t *tnameref;

        tnameref = calloc(1, sizeof(stree_tnameref_t));
        if (tnameref == NULL) {
                printf("Memory allocation failed.\n");
                exit(1);
        }

        return tnameref;
}

/** Allocate new symbol.
 *
 * @return      New symbol
 */
stree_symbol_t *stree_symbol_new(symbol_class_t sc)
{
        stree_symbol_t *symbol;

        symbol = calloc(1, sizeof(stree_symbol_t));
        if (symbol == NULL) {
                printf("Memory allocation failed.\n");
                exit(1);
        }

        symbol->sc = sc;
        list_init(&symbol->attr);

        return symbol;
}

/** Allocate new program.
 *
 * @return      New program
 */
stree_program_t *stree_program_new(void)
{
        stree_program_t *program;

        program = calloc(1, sizeof(stree_program_t));
        if (program == NULL) {
                printf("Memory allocation failed.\n");
                exit(1);
        }

        return program;
}

/** Determine if @a symbol has attribute of class @a sac.
 *
 * @param symbol        Symbol
 * @param sac           Symbol attribute class
 * @return              @c b_true if yes, @c b_false if no
 */
bool_t stree_symbol_has_attr(stree_symbol_t *symbol, symbol_attr_class_t sac)
{
        list_node_t *node;
        stree_symbol_attr_t *attr;

        node = list_first(&symbol->attr);
        while (node != NULL) {
                attr = list_node_data(node, stree_symbol_attr_t *);
                if (attr->sac == sac)
                        return b_true;

                node = list_next(&symbol->attr, node);
        }

        return b_false;
}

/** Determine if argument @a arg has attribute of class @a aac.
 *
 * @param arg           Formal procedure argument
 * @param aac           Argument attribute class
 * @return              @c b_true if yes, @c b_false if no.
 */
bool_t stree_arg_has_attr(stree_proc_arg_t *arg, arg_attr_class_t aac)
{
        list_node_t *node;
        stree_arg_attr_t *attr;

        node = list_first(&arg->attr);
        while (node != NULL) {
                attr = list_node_data(node, stree_arg_attr_t *);
                if (attr->aac == aac)
                        return b_true;

                node = list_next(&arg->attr, node);
        }

        return b_false;
}

/** Determine wheter @a a is derived (transitively) from @a b.
 *
 * XXX This does not work right with generics.
 *
 * @param a     Derived CSI.
 * @param b     Base CSI.
 * @return      @c b_true if @a a is equal to or directly or indirectly
 *              derived from @a b.
 */
bool_t stree_is_csi_derived_from_csi(stree_csi_t *a, stree_csi_t *b)
{
        stree_csi_t *csi;

        csi = a;
        while (csi != NULL) {
                if (csi == b)
                        return b_true;

                csi = csi->base_csi;
        }

        /* We went all the way to the root and did not find b. */
        return b_false;
}

/** Determine if @a symbol is static.
 *
 * @param symbol        Symbol
 * @return              @c b_true if symbol is static, @c b_false otherwise
 */
bool_t stree_symbol_is_static(stree_symbol_t *symbol)
{
        /* Module-wide symbols are static. */
        if (symbol->outer_csi == NULL)
                return b_true;

        /* Symbols with @c static attribute are static. */
        if (stree_symbol_has_attr(symbol, sac_static))
                return b_true;

        switch (symbol->sc) {
        case sc_csi:
        case sc_deleg:
        case sc_enum:
                return b_true;
        case sc_ctor:
        case sc_fun:
        case sc_var:
        case sc_prop:
                break;
        }

        return b_false;
}

/** Search for CSI type argument of the given name.
 *
 * @param csi           CSI to look in
 * @param ident         Identifier of the type argument
 * @return              Type argument declaration or @c NULL if not found
 */
stree_targ_t *stree_csi_find_targ(stree_csi_t *csi, stree_ident_t *ident)
{
        list_node_t *targ_n;
        stree_targ_t *targ;

        targ_n = list_first(&csi->targ);
        while (targ_n != NULL) {
                targ = list_node_data(targ_n, stree_targ_t *);
                if (targ->name->sid == ident->sid)
                        return targ;

                targ_n = list_next(&csi->targ, targ_n);
        }

        /* No match */
        return NULL;
}

/** Search for enum member of the given name.
 *
 * @param enum_d        Enum to look in
 * @param ident         Identifier of the enum member
 * @return              Enum member declaration or @c NULL if not found
 */
stree_embr_t *stree_enum_find_mbr(stree_enum_t *enum_d, stree_ident_t *ident)
{
        list_node_t *embr_n;
        stree_embr_t *embr;

        embr_n = list_first(&enum_d->members);
        while (embr_n != NULL) {
                embr = list_node_data(embr_n, stree_embr_t *);
                if (embr->name->sid == ident->sid)
                        return embr;

                embr_n = list_next(&enum_d->members, embr_n);
        }

        /* No match */
        return NULL;
}

/** Get CSI member name.
 *
 * @param csimbr        CSI member
 * @return              Member name
 */
stree_ident_t *stree_csimbr_get_name(stree_csimbr_t *csimbr)
{
        stree_ident_t *mbr_name;

        /* Keep compiler happy. */
        mbr_name = NULL;

        switch (csimbr->cc) {
        case csimbr_csi:
                mbr_name = csimbr->u.csi->name;
                break;
        case csimbr_ctor:
                mbr_name = csimbr->u.ctor->name;
                break;
        case csimbr_deleg:
                mbr_name = csimbr->u.deleg->name;
                break;
        case csimbr_enum:
                mbr_name = csimbr->u.enum_d->name;
                break;
        case csimbr_fun:
                mbr_name = csimbr->u.fun->name;
                break;
        case csimbr_var:
                mbr_name = csimbr->u.var->name;
                break;
        case csimbr_prop:
                mbr_name = csimbr->u.prop->name;
                break;
        }

        return mbr_name;
}
/* [<][>][^][v][top][bottom][index][help] */
HelenOS homepage, sources at GitHub
HelenOS sources

root/uspace/app/sbi/src/stree.c

DEFINITIONS
