void SiteCounts::add_sequence( Sequence const& sequence, bool use_abundance )
{
if( use_abundance ) {
add_sequence( sequence.sites(), static_cast<CountsIntType>( sequence.abundance() ));
} else {
add_sequence( sequence.sites(), 1 );
}
}
GBamRecord::GBamRecord(const char* qname, int32_t gseq_tid,
int pos, bool reverse, const char* qseq,
const char* cigar, const char* quals):iflags(0), exons(1),
clipL(0), clipR(0), mapped_len(0) {
novel=true;
bam_header=NULL;
b=bam_init1();
if (pos<=0 || gseq_tid<0) {
b->core.pos=-1; //unmapped
b->core.flag |= BAM_FUNMAP;
gseq_tid=-1;
}
else b->core.pos=pos-1; //BAM is 0-based
b->core.tid=gseq_tid;
b->core.qual=255;
b->core.mtid=-1;
b->core.mpos=-1;
int l_qseq=strlen(qseq);
//this may not be accurate, setting CIGAR is the correct way
//b->core.bin = bam_reg2bin(b->core.pos, b->core.pos+l_qseq-1);
b->core.l_qname=strlen(qname)+1; //includes the \0 at the end
memcpy(realloc_bdata(b, b->core.l_qname), qname, b->core.l_qname);
set_cigar(cigar); //this will also set core.bin
add_sequence(qseq, l_qseq);
add_quals(quals); //quals must be given as Phred33
if (reverse) { b->core.flag |= BAM_FREVERSE ; }
}
relation_transformer_fn * sieve_relation_plugin::mk_rename_fn(const relation_base & r0,
unsigned cycle_len, const unsigned * permutation_cycle) {
if(&r0.get_plugin()!=this) {
return 0;
}
const sieve_relation & r = static_cast<const sieve_relation &>(r0);
unsigned sig_sz = r.get_signature().size();
unsigned_vector permutation;
add_sequence(0, sig_sz, permutation);
permutate_by_cycle(permutation, cycle_len, permutation_cycle);
bool inner_identity;
unsigned_vector inner_permutation;
collect_sub_permutation(permutation, r.m_sig2inner, inner_permutation, inner_identity);
svector<bool> result_inner_cols = r.m_inner_cols;
permutate_by_cycle(result_inner_cols, cycle_len, permutation_cycle);
relation_signature result_sig;
relation_signature::from_rename(r.get_signature(), cycle_len, permutation_cycle, result_sig);
relation_transformer_fn * inner_fun =
get_manager().mk_permutation_rename_fn(r.get_inner(), inner_permutation);
if(!inner_fun) {
return 0;
}
return alloc(transformer_fn, inner_fun, result_sig, result_inner_cols.c_ptr());
}
Constraint_list *prepare_cl_for_moca ( Constraint_list *CL)
{
int a, b, c;
int tot_l, l;
char **name, **seq;
Sequence *NS=NULL;
/*Prepare the constraint list*/
CL->do_self=1;
CL->get_dp_cost=moca_slow_get_dp_cost;
CL->evaluate_residue_pair=moca_residue_pair_extended_list;
/*Prepare the moca parameters*/
(CL->moca)->evaluate_domain=evaluate_moca_domain;
(CL->moca)->cache_cl_with_domain=cache_cl_with_moca_domain;
(CL->moca)->make_nol_aln=make_moca_nol_aln;
/*Prepare the packing of the sequences*/
for ( a=0, b=1; a< (CL->S)->nseq; a++)b+=strlen ( (CL->S)->seq[a])+1;
seq =declare_char ( 1,b+1);
name=declare_char( 1,30);
CL->packed_seq_lu =declare_int ( b, 2);
for (tot_l=1,a=0; a< (CL->S)->nseq; a++)
{
strcat (seq[0], (CL->S)->seq[a]);
strcat (seq[0], "X");
l=strlen((CL->S)->seq[a]);
for ( c=1; c<= l; c++, tot_l++)
{
CL->packed_seq_lu[tot_l][0]=a;
CL->packed_seq_lu[tot_l][1]=c;
}
CL->packed_seq_lu[tot_l++][0]=UNDEFINED;
}
sprintf ( name[0], "catseq");
NS=fill_sequence_struc(1, seq, name, NULL);
CL->S=add_sequence (NS, CL->S, 0);
free_char( seq, -1);
free_char(name, -1);
free_sequence (NS, NS->nseq);
return CL;
}
static error_t
opt_handler (int key, char *arg, struct argp_state *state)
{
switch (key)
{
case ARG_FOLDER:
mh_set_current_folder (arg);
break;
case ARG_SEQUENCE:
add_sequence (arg);
break;
case ARG_ADD:
case ARG_DELETE:
case ARG_LIST:
action = key;
break;
case ARG_PUBLIC:
if (is_true (arg))
seq_flags &= ~SEQ_PRIVATE;
else
seq_flags |= SEQ_PRIVATE;
break;
case ARG_NOPUBLIC:
seq_flags |= SEQ_PRIVATE;
break;
case ARG_ZERO:
if (is_true (arg))
seq_flags |= SEQ_ZERO;
else
seq_flags &= ~SEQ_ZERO;
break;
case ARG_NOZERO:
seq_flags &= ~SEQ_ZERO;
break;
default:
return ARGP_ERR_UNKNOWN;
}
return 0;
}
GBamRecord::GBamRecord(const char* qname, int32_t samflags, int32_t g_tid,
int pos, int map_qual, const char* cigar, int32_t mg_tid, int mate_pos,
int insert_size, const char* qseq, const char* quals,
GVec<char*>* aux_strings):iflags(0), exons(1) {
novel=true;
bam_header=NULL;
b=bam_init1();
b->core.tid=g_tid;
b->core.pos = (pos<=0) ? -1 : pos-1; //BAM is 0-based
b->core.qual=map_qual;
int l_qseq=strlen(qseq);
b->core.l_qname=strlen(qname)+1; //includes the \0 at the end
memcpy(realloc_bdata(b, b->core.l_qname), qname, b->core.l_qname);
set_cigar(cigar); //this will also set core.bin
add_sequence(qseq, l_qseq);
add_quals(quals); //quals must be given as Phred33
set_flags(samflags);
set_mdata(mg_tid, (int32_t)(mate_pos-1), (int32_t)insert_size);
if (aux_strings!=NULL) {
for (int i=0;i<aux_strings->Count();i++) {
add_aux(aux_strings->Get(i));
}
}
}
consensus_data * generate_consensus( char ** input_seq,
unsigned int n_seq,
unsigned min_cov,
unsigned K,
double min_idt) {
unsigned int j;
unsigned int seq_count;
unsigned int aligned_seq_count;
kmer_lookup * lk_ptr;
seq_array sa_ptr;
seq_addr_array sda_ptr;
kmer_match * kmer_match_ptr;
aln_range * arange;
alignment * aln;
align_tags_t ** tags_list;
//char * consensus;
consensus_data * consensus;
double max_diff;
max_diff = 1.0 - min_idt;
seq_count = n_seq;
//printf("XX n_seq %d\n", n_seq);
//for (j=0; j < seq_count; j++) {
// printf("seq_len: %u %u\n", j, strlen(input_seq[j]));
//};
fflush(stdout);
tags_list = calloc( seq_count, sizeof(align_tags_t *) );
lk_ptr = allocate_kmer_lookup( 1 << (K * 2) );
sa_ptr = allocate_seq( (seq_coor_t) strlen( input_seq[0]) );
sda_ptr = allocate_seq_addr( (seq_coor_t) strlen( input_seq[0]) );
add_sequence( 0, K, input_seq[0], strlen(input_seq[0]), sda_ptr, sa_ptr, lk_ptr);
//mask_k_mer(1 << (K * 2), lk_ptr, 16);
aligned_seq_count = 0;
for (j=1; j < seq_count; j++) {
//printf("seq_len: %ld %u\n", j, strlen(input_seq[j]));
kmer_match_ptr = find_kmer_pos_for_seq(input_seq[j], strlen(input_seq[j]), K, sda_ptr, lk_ptr);
#define INDEL_ALLOWENCE_0 6
arange = find_best_aln_range(kmer_match_ptr, K, K * INDEL_ALLOWENCE_0, 5); // narrow band to avoid aligning through big indels
//printf("1:%ld %ld %ld %ld\n", arange_->s1, arange_->e1, arange_->s2, arange_->e2);
//arange = find_best_aln_range2(kmer_match_ptr, K, K * INDEL_ALLOWENCE_0, 5); // narrow band to avoid aligning through big indels
//printf("2:%ld %ld %ld %ld\n\n", arange->s1, arange->e1, arange->s2, arange->e2);
#define INDEL_ALLOWENCE_1 0.10
if (arange->e1 - arange->s1 < 100 || arange->e2 - arange->s2 < 100 ||
abs( (arange->e1 - arange->s1 ) - (arange->e2 - arange->s2) ) >
(int) (0.5 * INDEL_ALLOWENCE_1 * (arange->e1 - arange->s1 + arange->e2 - arange->s2))) {
free_kmer_match( kmer_match_ptr);
free_aln_range(arange);
continue;
}
//printf("%ld %s\n", strlen(input_seq[j]), input_seq[j]);
//printf("%ld %s\n\n", strlen(input_seq[0]), input_seq[0]);
#define INDEL_ALLOWENCE_2 150
aln = align(input_seq[j]+arange->s1, arange->e1 - arange->s1 ,
input_seq[0]+arange->s2, arange->e2 - arange->s2 ,
INDEL_ALLOWENCE_2, 1);
if (aln->aln_str_size > 500 && ((double) aln->dist / (double) aln->aln_str_size) < max_diff) {
tags_list[aligned_seq_count] = get_align_tags( aln->q_aln_str,
aln->t_aln_str,
aln->aln_str_size,
arange, j,
0);
aligned_seq_count ++;
}
/***
for (k = 0; k < tags_list[j]->len; k++) {
printf("%ld %d %c\n", tags_list[j]->align_tags[k].t_pos,
tags_list[j]->align_tags[k].delta,
tags_list[j]->align_tags[k].q_base);
}
***/
free_aln_range(arange);
free_alignment(aln);
free_kmer_match( kmer_match_ptr);
}
if (aligned_seq_count > 0) {
consensus = get_cns_from_align_tags( tags_list, aligned_seq_count, strlen(input_seq[0]), min_cov );
} else {
// allocate an empty consensus sequence
consensus = calloc( 1, sizeof(consensus_data) );
consensus->sequence = calloc( 1, sizeof(char) );
consensus->eqv = calloc( 1, sizeof(unsigned int) );
}
//free(consensus);
free_seq_addr_array(sda_ptr);
free_seq_array(sa_ptr);
free_kmer_lookup(lk_ptr);
for (j=0; j < aligned_seq_count; j++) {
free_align_tags(tags_list[j]);
}
free(tags_list);
return consensus;
}
static RD_BOOL
xkeymap_read(char *mapname)
{
FILE *fp;
char line[KEYMAP_MAX_LINE_LENGTH];
unsigned int line_num = 0;
unsigned int line_length = 0;
char *keyname, *p;
char *line_rest;
uint8 scancode;
uint16 modifiers;
fp = xkeymap_open(mapname);
if (fp == NULL)
{
error("Failed to open keymap %s\n", mapname);
return False;
}
/* FIXME: More tolerant on white space */
while (fgets(line, sizeof(line), fp) != NULL)
{
line_num++;
/* Replace the \n with \0 */
p = strchr(line, '\n');
if (p != NULL)
*p = 0;
line_length = strlen(line);
/* Completely empty line */
if (strspn(line, " \t\n\r\f\v") == line_length)
{
continue;
}
/* Include */
if (str_startswith(line, "include "))
{
if (!xkeymap_read(line + sizeof("include ") - 1))
return False;
continue;
}
/* map */
if (str_startswith(line, "map "))
{
g_keylayout = strtoul(line + sizeof("map ") - 1, NULL, 16);
DEBUG_KBD(("Keylayout 0x%x\n", g_keylayout));
continue;
}
/* compose */
if (str_startswith(line, "enable_compose"))
{
DEBUG_KBD(("Enabling compose handling\n"));
g_enable_compose = True;
continue;
}
/* sequence */
if (str_startswith(line, "sequence"))
{
add_sequence(line + sizeof("sequence") - 1, mapname);
continue;
}
/* keyboard_type */
if (str_startswith(line, "keyboard_type "))
{
g_keyboard_type = strtol(line + sizeof("keyboard_type ") - 1, NULL, 16);
DEBUG_KBD(("keyboard_type 0x%x\n", g_keyboard_type));
continue;
}
/* keyboard_subtype */
if (str_startswith(line, "keyboard_subtype "))
{
g_keyboard_subtype =
strtol(line + sizeof("keyboard_subtype ") - 1, NULL, 16);
DEBUG_KBD(("keyboard_subtype 0x%x\n", g_keyboard_subtype));
continue;
}
/* keyboard_functionkeys */
if (str_startswith(line, "keyboard_functionkeys "))
{
g_keyboard_functionkeys =
strtol(line + sizeof("keyboard_functionkeys ") - 1, NULL, 16);
DEBUG_KBD(("keyboard_functionkeys 0x%x\n", g_keyboard_functionkeys));
continue;
}
/* Comment */
if (line[0] == '#')
{
continue;
}
/* Normal line */
keyname = line;
p = strchr(line, ' ');
if (p == NULL)
{
error("Bad line %d in keymap %s\n", line_num, mapname);
continue;
}
else
{
*p = 0;
}
/* scancode */
p++;
scancode = strtol(p, &line_rest, 16);
/* flags */
/* FIXME: Should allow case-insensitive flag names.
Fix by using lex+yacc... */
modifiers = 0;
if (strstr(line_rest, "altgr"))
{
MASK_ADD_BITS(modifiers, MapAltGrMask);
}
if (strstr(line_rest, "shift"))
{
MASK_ADD_BITS(modifiers, MapLeftShiftMask);
}
if (strstr(line_rest, "numlock"))
{
MASK_ADD_BITS(modifiers, MapNumLockMask);
}
if (strstr(line_rest, "localstate"))
{
MASK_ADD_BITS(modifiers, MapLocalStateMask);
}
if (strstr(line_rest, "inhibit"))
{
MASK_ADD_BITS(modifiers, MapInhibitMask);
}
add_to_keymap(keyname, scancode, modifiers, mapname);
if (strstr(line_rest, "addupper"))
{
/* Automatically add uppercase key, with same modifiers
plus shift */
for (p = keyname; *p; p++)
*p = toupper((int) *p);
MASK_ADD_BITS(modifiers, MapLeftShiftMask);
add_to_keymap(keyname, scancode, modifiers, mapname);
}
}
fclose(fp);
return True;
}
static int
seq_init (struct msgs *mp, char *name, char *field)
{
unsigned int i;
int j, k, is_current;
char *cp, **ap;
/*
* Check if this is "cur" sequence,
* so we can do some special things.
*/
is_current = !strcmp (current, name);
/*
* Search for this sequence name to see if we've seen
* it already. If we've seen this sequence before,
* then clear the bit for this sequence from all the
* mesages in this folder.
*/
for (i = 0; i < svector_size (mp->msgattrs); i++) {
if (!strcmp (svector_at (mp->msgattrs, i), name)) {
for (j = mp->lowmsg; j <= mp->hghmsg; j++)
clear_sequence (mp, i, j);
break;
}
}
/*
* If we've already seen this sequence name, just free the
* name string. Else add it to the list of sequence names.
*/
if (svector_at (mp->msgattrs, i)) {
free (name);
} else {
svector_push_back (mp->msgattrs, name);
}
/*
* Split up the different message ranges at whitespace
*/
for (ap = brkstring (field, " ", "\n"); *ap; ap++) {
if ((cp = strchr(*ap, '-')))
*cp++ = '\0';
if ((j = m_atoi (*ap)) > 0) {
k = cp ? m_atoi (cp) : j;
/*
* Keep mp->curmsg and "cur" sequence in synch. Unlike
* other sequences, this message doesn't need to exist.
* Think about the series of command (rmm; next) to
* understand why this can be the case. But if it does
* exist, we will still set the bit flag for it like
* other sequences.
*/
if (is_current)
mp->curmsg = j;
/*
* We iterate through messages in this range
* and flip on bit for this sequence.
*/
for (; j <= k; j++) {
if (j >= mp->lowmsg && j <= mp->hghmsg && does_exist(mp, j))
add_sequence (mp, i, j);
}
}
}
free (field); /* free string containing message ranges */
return i;
}
void SiteCounts::add_sequences( SequenceSet const& sequences, bool use_abundances )
{
for( auto const& seq : sequences ) {
add_sequence( seq, use_abundances );
}
}
int processFileLine(option_block *opts, char *line, int line_len)
{
FILE *t;
char *f;
int state;
int lno;
char *delim;
int sze;
switch(line[0])
{
case '/':
if(line[1] != '/')
break;
case ';':
case '#':
case 0:
case '\n':
return 0;
case '\r':
if(line[1] == '\n')
return 0;
break;
}
/*not a comment, regular state*/
#ifndef NOPLUGIN
if(!strncasecmp("plugin", line, 6))
{
delim = strstr(line, " ");
if(delim == NULL)
{
file_error("plugin line with no file specified. abort!", opts);
}
plugin_load(delim, opts);
return 0;
}
#endif
if(!strncasecmp("literal", line, 7))
{
delim = strstr(line, "=");
if(delim == NULL)
{
file_error("literal string not assigned!", opts);
}
sze = strlen(delim+1);
if(sze == 0)
{
file_error("literal string is null!", opts);
}
add_literal(opts, delim+1, sze);
return 0;
}
if(!strncasecmp("++", line, 2))
{
set_bsym_increment(opts, line+2);
return 0;
}
if(!strncasecmp("sequence", line, 7))
{
delim = strstr(line, "=");
if(delim == NULL)
{
file_error("sequence string not assigned!", opts);
}
sze = strlen(delim+1);
if(sze == 0)
{
file_error("sequence string is null!", opts);
}
add_sequence(opts, delim+1, sze);
return 0;
}
if(!strncasecmp("reppol", line, 6))
{
delim = strstr(line, "=");
if(delim == NULL)
file_error("replacement policy not specified.", opts);
f = delim+1;
if(!strncasecmp(f, "always", 6))
{
opts->repl_pol = 1;
}
else if(!strncasecmp(f, "once", 5))
{
opts->repl_pol = 2;
}
else
file_error("replacement policy not recognized.", opts);
return 0;
}
if(!strncasecmp("reqwait", line, 7))
{
delim = strstr(line, "=");
if(delim == NULL)
file_error("request wait string not assigned!", opts);
sze = strlen(delim+1);
if(sze == 0)
file_error("request wait string is null!", opts);
opts->reqw_inms = atoi(delim+1);
return 0;
}
if(!strncasecmp("lineterm", line, 8))
{
delim = strstr(line, "=");
if(delim == NULL)
file_error("lineterm value not assigned!", opts);
sze = strlen(delim+1);
state = strlen(line) - sze;
if(sze)
{
if((line[state] == '\\') ||
(line[state] == '0'))
{
if(line[state] == 'x')
sze = ascii_to_bin(line+state);
}
memcpy(opts->line_term, line+state, sze);
}
opts->line_terminator_size = sze;
return 0;
}
if(!strncasecmp("maxseqlen", line, 9))
{
delim = strstr(line, "=");
if(delim == NULL)
file_error("max seq len not assigned!", opts);
sze = strlen(delim+1);
if(sze == 0)
file_error("max seq len is null!", opts);
opts->mseql = atoi(delim+1);
return 0;
}
if(!strncasecmp("seqstep", line, 7))
{
delim = strstr(line, "=");
if(delim == NULL)
file_error("seq step not assigned!", opts);
sze = strlen(delim+1);
if(sze == 0)
file_error("seq step is null!", opts);
opts->seqstep = atoi(delim+1);
return 0;
}
if(!strncasecmp("endcfg", line, 6))
return 1;
if(!strncasecmp("include", line, 7))
{
delim = strstr(line, " ");
if(delim == NULL)
file_error("include not assigned!", opts);
sze = strlen(delim+1);
if(sze == 0)
file_error("include is null!", opts);
t = opts->fp;
f = malloc(strlen(opts->pFilename));
if(f == NULL)
{
file_error("unable to include file - out of memory.", opts);
}
/*yeah yeah...not safe. So fuzz it, already!*/
strcpy(f, opts->pFilename);
state = opts->state;
strncpy(opts->pFilename, delim+1, MAX_FILENAME_SIZE-1);
/*setup for inner parse.*/
opts->state = INIT_READ;
lno = opts->lno;
/*do inner parse.*/
read_config(opts);
strcpy(opts->pFilename, f);
opts->state = state;
opts->lno = lno;
opts->fp = t;
free(f);
return 0;
}
if(line[0] == '$')
{
delim = strstr(line+1, "=");
if(delim == NULL)
{
file_error("symbol not assigned!", opts);
}
sze = strlen(delim+1);
if(sze == 0)
{
file_error("symbol is null!", opts);
}
add_symbol(line+1, (delim - (line+1)), delim+1, sze, opts, 0);
return 0;
} else if (line[0] == '!')
{
/*binary stuff*/
delim = strstr(line+1, "=");
if(delim == NULL)
{
file_error("binary symbol not assigned!", opts);
}
sze = strlen(delim+1);
if(sze == 0)
{
file_error("binary symbol is null!", opts);
}
sze = ascii_to_bin(delim+1);
if(sze < 0)
{
file_error("binary text is invalid!", opts);
}
add_b_symbol(line+1, (delim - (line+1)), delim+1, sze, opts);
return 0;
} else if (line[0] == '|')
{
delim = strstr(line+1, "=");
if(delim == NULL)
{
file_error("symbol not assigned!", opts);
}
sze = strlen(delim+1);
if(sze == 0)
{
file_error("symbol is null!", opts);
}
add_subst_symbol(line+1, (delim - (line+1)), delim+1, sze, opts, 0);
return 0;
}
#ifndef NOPLUGIN
if(g_plugin != NULL &&
((g_plugin->capex() & PLUGIN_PROVIDES_LINE_OPTS) ==
PLUGIN_PROVIDES_LINE_OPTS))
{
return g_plugin->config(opts, line, line_len);
}
#endif
fprintf(stderr, "[%s]\n", line);
file_error("invalid config file.", opts);
return 1;
}
AST_Decl *UTL_Scope::call_add()
{
AST_Decl *result = NULL;
AST_Decl *decl;
UTL_ScopeActiveIterator *i;
UTL_Scope *scope;
i = new UTL_ScopeActiveIterator(this, UTL_Scope::IK_decls);
while (!(i->is_done()))
{
decl = i->item();
scope = 0;
switch (decl->node_type())
{
case AST_Decl::NT_argument:
result = add_argument(AST_Argument::narrow_from_decl(decl));
break;
case AST_Decl::NT_array:
result = add_array(AST_Array::narrow_from_decl(decl));
break;
case AST_Decl::NT_attr:
result = add_attribute(AST_Attribute::narrow_from_decl(decl));
break;
case AST_Decl::NT_const:
result = add_constant(AST_Constant::narrow_from_decl(decl));
break;
case AST_Decl::NT_enum:
scope = AST_Enum::narrow_from_decl(decl);
result = add_enum(AST_Enum::narrow_from_decl(decl));
break;
case AST_Decl::NT_enum_val:
result = add_enum_val(AST_EnumVal::narrow_from_decl(decl));
break;
case AST_Decl::NT_except:
scope = AST_Exception::narrow_from_decl(decl);
result = add_exception(AST_Exception::narrow_from_decl(decl));
break;
case AST_Decl::NT_field:
result = add_field(AST_Field::narrow_from_decl(decl));
break;
case AST_Decl::NT_interface:
scope = AST_Interface::narrow_from_decl(decl);
result = add_interface(AST_Interface::narrow_from_decl(decl));
break;
case AST_Decl::NT_interface_fwd:
result = add_interface_fwd(AST_InterfaceFwd::narrow_from_decl(decl));
break;
case AST_Decl::NT_module:
scope = AST_Module::narrow_from_decl(decl);
result = add_module(AST_Module::narrow_from_decl(decl));
break;
case AST_Decl::NT_op:
result = add_operation(AST_Operation::narrow_from_decl(decl));
scope = AST_Operation::narrow_from_decl(decl);
break;
case AST_Decl::NT_pre_defined:
result =
add_predefined_type(AST_PredefinedType::narrow_from_decl(decl));
break;
case AST_Decl::NT_sequence:
result = add_sequence(AST_Sequence::narrow_from_decl(decl));
break;
case AST_Decl::NT_string:
result = add_string(AST_String::narrow_from_decl(decl));
break;
case AST_Decl::NT_struct:
result = add_structure(AST_Structure::narrow_from_decl(decl));
scope = AST_Structure::narrow_from_decl(decl);
break;
case AST_Decl::NT_typedef:
result = add_typedef(AST_Typedef::narrow_from_decl(decl));
break;
case AST_Decl::NT_union:
result = add_union(AST_Union::narrow_from_decl(decl));
scope = AST_Union::narrow_from_decl(decl);
break;
case AST_Decl::NT_union_branch:
result = add_union_branch(AST_UnionBranch::narrow_from_decl(decl));
break;
// case AST_Decl::NT_opaque:
// result = add_opaque(AST_Opaque::narrow_from_decl(decl));
// break;
case AST_Decl::NT_value:
result = add_valuetype (AST_Value::narrow_from_decl (decl));
scope = AST_Value::narrow_from_decl (decl);
break;
case AST_Decl::NT_value_fwd:
result = add_valuetype_fwd(AST_ValueFwd::narrow_from_decl(decl));
break;
case AST_Decl::NT_state_member:
result = add_state_member(AST_StateMember::narrow_from_decl(decl));
break;
default:
return NULL;
}
if (scope)
scope->call_add();
i->next();
}
delete i;
return result;
}
