static void dump_permissions (PermissionsData_t *p)
{
dbg_printf ("%4u", p->perm);
if (p->nusers != 1)
dbg_printf ("*%u", p->nusers);
dbg_printf (":\r\n Identity: %u\r\n", p->id);
if (p->perm_token) {
dbg_printf (" Permissions Token:\t");
token_dump (1, p->perm_token->data, p->perm_token->nusers, 0);
}
if (p->perm_creds) {
dbg_printf (" Permissions Credential:");
token_dump (1, p->perm_creds, 1, 1);
}
}
static struct dynarr *parse_specifier_qualifier_sc_internal(struct parser *parser, int mask) {
union token tok;
void *nd;
struct dynarr *darr = dynarr_init();
while (1) {
tok = lexer_next_token(parser->lexer);
if ((mask & INTERNAL_PARSE_SPECIFIER) && initiate_type_specifier(tok)) {
lexer_put_back(parser->lexer, tok);
nd = parse_type_specifier(parser);
} else if ((mask & INTERNAL_PARSE_QUALIFIER) && initiate_type_qualifier(tok)) {
nd = type_qualifier_init(tok.tok_tag);
} else if ((mask & INTERNAL_PARSE_STORAGE_CLASS) && initiate_storage_class_specifier(tok)) {
nd = storage_class_specifier_init(tok.tok_tag);
} else {
lexer_put_back(parser->lexer, tok);
break;
}
dynarr_add(darr, nd);
}
#if DEBUG
if (dynarr_size(darr) == 0) {
// lexer_dump_remaining(parser->lexer);
file_reader_dump_remaining(parser->lexer->cstream);
tok = lexer_next_token(parser->lexer); // this is putback
token_dump(tok);
}
#endif
assert(dynarr_size(darr) > 0);
return darr;
}
static void dump_identity (IdentityData_t *p)
{
dbg_printf ("%4u", p->id);
if (p->nusers != 1)
dbg_printf ("*%u", p->nusers);
dbg_printf (":\r\n");
if (p->id_token) {
dbg_printf (" Identity Token:\t");
token_dump (1, p->id_token->data, p->id_token->nusers, 0);
}
if (p->id_creds) {
dbg_printf (" Identity Credential:");
token_dump (1, p->id_creds, 1, 1);
}
if (p->perm_token) {
dbg_printf (" Permission Token:\t");
token_dump (1, p->perm_token->data, p->perm_token->nusers, 0);
}
if (p->perm_cred) {
dbg_printf (" Permission Credential:");
token_dump (1, p->perm_cred, 1, 1);
}
}
void dump_tokens(char *pass, tokens_t *f, tokens_t *l)
{
tokens_t *t;
printf("\n--------------------------------------------------------------------------------\n");
printf("%ld tokens at %s:\n%s ", l-f, pass, pass);
for (t=f; t != l; t++) {
token_dump(t);
if (t->ttype == TT_EOL) printf("\n%s ", pass);
}
printf("(END)\n\n");
}
static struct init_declarator_list *parse_init_declarator_list_with_la(struct parser *parser, struct declarator *declarator) {
assert(declarator != NULL);
struct dynarr *darr = dynarr_init();
struct init_declarator *init_declarator = parse_init_declarator_with_la(parser, declarator);
union token tok;
while (1) {
dynarr_add(darr, init_declarator);
tok = lexer_next_token(parser->lexer);
if (tok.tok_tag == TOK_COMMA) {
// go on for next init_declarator
} else if (tok.tok_tag == TOK_SEMICOLON) {
break;
} else {
file_reader_dump_remaining(parser->lexer->cstream);
token_dump(tok);
panic("expect ',' or ';'");
}
init_declarator = parse_init_declarator(parser);
}
return init_declarator_list_init(darr);
}
struct type_specifier *parse_struct_or_union_specifier(struct parser *parser) {
union token struct_union_tok = lexer_next_token(parser->lexer);
/*
* disable typedef is important here for the following case:
* typedef struct st st;
* struct st v; // we should not treat this st as TYPE_NAME
*/
int old_disable_typedef = lexer_push_config(parser->lexer, disable_typedef, 1);
union token tok = lexer_next_token(parser->lexer);
lexer_pop_config(parser->lexer, disable_typedef, old_disable_typedef);
char *name = NULL;
struct struct_declaration_list *struct_decl_list = NULL;
assert(struct_union_tok.tok_tag == TOK_STRUCT || struct_union_tok.tok_tag == TOK_UNION);
if (tok.tok_tag == TOK_IDENTIFIER) {
name = tok.id.s;
tok = lexer_next_token(parser->lexer);
}
if (name == NULL && tok.tok_tag != TOK_LBRACE) {
file_reader_dump_remaining(parser->lexer->cstream);
token_dump(tok);
panic("struct/union should be followed by a name or '{'");
}
if (tok.tok_tag == TOK_LBRACE) {
struct_decl_list = parse_struct_declaration_list(parser);
} else {
lexer_put_back(parser->lexer, tok);
}
struct type_specifier *ret = type_specifier_init(struct_union_tok.tok_tag);
ret->type_name = name;
ret->struct_decl_list = struct_decl_list;
return ret;
}
void token_list_dump(struct dynarr *darr) {
DYNARR_FOREACH_PLAIN_BEGIN(darr, union token *, each);
token_dump(*each);
DYNARR_FOREACH_END();
}
