static bool
addrtype_mt_v1(const struct sk_buff *skb, struct xt_action_param *par)
{
struct net *net = dev_net(par->in ? par->in : par->out);
const struct xt_addrtype_info_v1 *info = par->matchinfo;
const struct iphdr *iph;
const struct net_device *dev = NULL;
bool ret = true;
if (info->flags & XT_ADDRTYPE_LIMIT_IFACE_IN)
dev = par->in;
else if (info->flags & XT_ADDRTYPE_LIMIT_IFACE_OUT)
dev = par->out;
#if defined(CONFIG_IP6_NF_IPTABLES) || defined(CONFIG_IP6_NF_IPTABLES_MODULE)
if (par->family == NFPROTO_IPV6)
return addrtype_mt6(net, dev, skb, info);
#endif
iph = ip_hdr(skb);
if (info->source)
ret &= match_type(net, dev, iph->saddr, info->source) ^
(info->flags & XT_ADDRTYPE_INVERT_SOURCE);
if (ret && info->dest)
ret &= match_type(net, dev, iph->daddr, info->dest) ^
!!(info->flags & XT_ADDRTYPE_INVERT_DEST);
return ret;
}
static int match(const struct sk_buff *skb,
const struct net_device *in, const struct net_device *out,
const struct xt_match *match, const void *matchinfo,
int offset, unsigned int protoff, int *hotdrop)
{
const struct ipt_addrtype_info *info = matchinfo;
const struct iphdr *iph = skb->nh.iph;
int ret = 1;
if (info->source)
ret &= match_type(iph->saddr, info->source)^info->invert_source;
if (info->dest)
ret &= match_type(iph->daddr, info->dest)^info->invert_dest;
return ret;
}
// Grammar match: argument = type argument [= const_value]
bool match_argument(TokenState& state, Argument *ptr_argument)
{
Type type;
if (!match_type(state, &type))
{
state.error_msg += "Expect type for argument.\n";
return false;
}
simple::string name;
if (!match_ident_name(state, &name))
{
state.error_msg += "Expect name for argument.\n";
return false;
}
bool has_default = false;
simple::string token;
if (state.peek_token(&token) && token == "=")
{
if (!match_constant(state))
{
state.error_msg += "Expect constant as default value of argument.\n";
return false;
}
}
ptr_argument->type = type;
ptr_argument->has_default = has_default;
ptr_argument->name = name;
return true;
}
/*
parse_int
Matches a valid integer expression by looking ahead one token
Parameters: none
Return: none
*/
void parse_int(Tree &cst){
cst.add_branch_node("int");
std::vector<Token>::iterator next_token = std::next(curr_token, 1);
if(!(next_token -> type).compare("plus")){
match_type("digit", cst);
match("+", cst);
parse_expr(cst);
}
else{
match_type("digit", cst);
}
cst.kill_all_children();
}
Parsed parse_thrift(const std::string& filename, Parsed& parsed)
{
std::ifstream in(filename);
std::string ns;
std::vector<std::string> types;
for (std::string s; std::getline(in, s); )
{
auto ret_ns = match_ns(s);
if (ret_ns)
{
assert(ns.empty());
assert(types.empty());
ns = *ret_ns;
continue;
}
auto ret_type = match_type(s);
if (ret_type)
{
types.push_back(*ret_type);
continue;
}
}
std::copy(begin(types), end(types), std::back_inserter(parsed[ns]));
return parsed;
}
/*
* parse top level declarations
*/
long dodcls (long stclass, TAG_SYMBOL *mtag, int is_struct)
{
long err;
struct type t;
blanks();
if (match_type(&t, NO, YES)) {
if (t.type == CSTRUCT && t.otag == -1)
t.otag = define_struct(t.sname, stclass, !!(t.flags & F_STRUCT));
else if (t.type == CENUM) {
if (t.otag == -1)
t.otag = define_enum(t.sname, stclass);
t.type = enum_types[t.otag].base;
}
err = declglb(t.type, stclass, mtag, t.otag, is_struct);
}
else if (stclass == PUBLIC)
return (0);
else
err = declglb(CINT, stclass, mtag, NULL_TAG, is_struct);
if (err == 2) /* function */
return (1);
else if (err) {
kill();
return (0);
}
else
ns();
return (1);
}
static bool
addrtype_mt_v0(const struct sk_buff *skb, const struct xt_match_param *par)
{
const struct ipt_addrtype_info *info = par->matchinfo;
const struct iphdr *iph = ip_hdr(skb);
bool ret = true;
if (info->source)
ret &= match_type(NULL, iph->saddr, info->source) ^
info->invert_source;
if (info->dest)
ret &= match_type(NULL, iph->daddr, info->dest) ^
info->invert_dest;
return ret;
}
void dotypedef (void)
{
struct type t;
if (!match_type(&t, YES, NO)) {
error("unknown type");
kill();
return;
}
if (t.type == CENUM) {
if (t.otag == -1) {
if (user_short_enums)
warning(W_GENERAL,
"typedef to undefined enum; "
"assuming base type int");
t.type = CINT;
}
else
t.type = enum_types[t.otag].base;
}
if (!symname(t.sname)) {
error("invalid type name");
kill();
return;
}
typedefs = realloc(typedefs, (typedef_ptr + 1) * sizeof(struct type));
typedefs[typedef_ptr++] = t;
ns();
}
static bool
addrtype_mt_v0(const struct sk_buff *skb, struct xt_action_param *par)
{
struct net *net = dev_net(par->in ? par->in : par->out);
const struct xt_addrtype_info *info = par->matchinfo;
const struct iphdr *iph = ip_hdr(skb);
bool ret = true;
if (info->source)
ret &= match_type(net, NULL, iph->saddr, info->source) ^
info->invert_source;
if (info->dest)
ret &= match_type(net, NULL, iph->daddr, info->dest) ^
info->invert_dest;
return ret;
}
static bool
set_match_type( int argc, char *argv[] ) {
int i;
const char *service_name;
for ( i = 1; i < argc; i++ ) {
if ( ( service_name = match_type( LLDP_PACKET_IN, argv[ i ] ) ) != NULL ) {
register_dl_type_filter( ETH_ETHTYPE_LLDP, OFP_DEFAULT_PRIORITY, service_name );
}
else if ( ( service_name = match_type( ANY_PACKET_IN, argv[ i ] ) ) != NULL ) {
register_any_filter( 0, service_name );
}
else {
return false;
}
}
return true;
}
/*
parse_char_list
Checks the current token for a char and recursively iterates the next tokens
for chars
Parameters: none
Return: none
*/
void parse_char_list(Tree &cst){
cst.add_branch_node("char_list");
if (!(curr_token -> type).compare("identifier")){
match_type("identifier", cst);
parse_char_list(cst);
}
else if(!(curr_token -> type).compare("keyword")){
match_type("keyword", cst);
parse_char_list(cst);
}
else if (!(curr_token -> type).compare("space")){
match(" ", cst);
parse_char_list(cst);
}
else{
// ε production, do nothing
}
cst.kill_all_children();
}
static bool
addrtype_mt_v0(const struct sk_buff *skb, const struct net_device *in,
const struct net_device *out, const struct xt_match *match,
const void *matchinfo, int offset, unsigned int protoff,
bool *hotdrop)
{
const struct ipt_addrtype_info *info = matchinfo;
const struct iphdr *iph = ip_hdr(skb);
bool ret = true;
if (info->source)
ret &= match_type(NULL, iph->saddr, info->source) ^
info->invert_source;
if (info->dest)
ret &= match_type(NULL, iph->daddr, info->dest) ^
info->invert_dest;
return ret;
}
static bool
set_match_type( int argc, char *argv[], services *services ) {
create_list( &services->arp_or_unicast );
create_list( &services->broadcast );
int i;
char *service_name;
for ( i = 1; i < argc; i++ ) {
if ( ( service_name = match_type( ARP_OR_UNICAST, argv[ i ] ) ) != NULL ) {
append_to_tail( &services->arp_or_unicast, service_name );
}
else if ( ( service_name = match_type( BROADCAST, argv[ i ] ) ) != NULL ) {
append_to_tail( &services->broadcast, service_name );
}
else {
return false;
}
}
return true;
}
match_string::match_type
match_string::match(part_iterator &begin, const part_iterator &end) const {
bool matches = false;
if (begin != end) {
std::string bit = *begin;
matches = bit == str;
++begin;
}
if (!matches) { throw error(); }
return match_type();
}
static bool
addrtype_mt_v1(const struct sk_buff *skb, const struct xt_match_param *par)
{
const struct ipt_addrtype_info_v1 *info = par->matchinfo;
const struct iphdr *iph = ip_hdr(skb);
const struct net_device *dev = NULL;
bool ret = true;
if (info->flags & IPT_ADDRTYPE_LIMIT_IFACE_IN)
dev = par->in;
else if (info->flags & IPT_ADDRTYPE_LIMIT_IFACE_OUT)
dev = par->out;
if (info->source)
ret &= match_type(dev, iph->saddr, info->source) ^
(info->flags & IPT_ADDRTYPE_INVERT_SOURCE);
if (ret && info->dest)
ret &= match_type(dev, iph->daddr, info->dest) ^
!!(info->flags & IPT_ADDRTYPE_INVERT_DEST);
return ret;
}
match_name::match_type
match_name::match(part_iterator &begin, const part_iterator &end) const {
if (begin != end) {
try {
std::string bit = *begin++;
return match_type(bit);
} catch (std::exception &e) {
throw error();
}
}
throw error();
}
/*
parse_bool
Matches a valid boolean expression by looking ahead one token
Parameters: none
Return: none
*/
void parse_bool(Tree &cst){
cst.add_branch_node("boolean");
if(!(curr_token -> type).compare("open_paren")){
match_type("open_paren", cst);
parse_expr(cst);
match(boolop, cst);
parse_expr(cst);
match(")", cst);
}
else{
match(boolval, cst);
}
cst.kill_all_children();
}
match_int::match_type
match_int::match(part_iterator &begin, const part_iterator &end) const {
if (begin != end) {
try {
std::string bit = *begin;
int x = boost::lexical_cast<int>(bit);
++begin;
return match_type(x);
} catch (std::exception &e) {
throw error();
}
}
throw error();
}
static bool
addrtype_mt_v1(const struct sk_buff *skb, const struct net_device *in,
const struct net_device *out, const struct xt_match *match,
const void *matchinfo, int offset, unsigned int protoff,
bool *hotdrop)
{
const struct ipt_addrtype_info_v1 *info = matchinfo;
const struct iphdr *iph = ip_hdr(skb);
const struct net_device *dev = NULL;
bool ret = true;
if (info->flags & IPT_ADDRTYPE_LIMIT_IFACE_IN)
dev = in;
else if (info->flags & IPT_ADDRTYPE_LIMIT_IFACE_OUT)
dev = out;
if (info->source)
ret &= match_type(dev, iph->saddr, info->source) ^
(info->flags & IPT_ADDRTYPE_INVERT_SOURCE);
if (ret && info->dest)
ret &= match_type(dev, iph->daddr, info->dest) ^
(info->flags & IPT_ADDRTYPE_INVERT_DEST);
return ret;
}
// Grammar match
bool match_prototype(TokenState& state, Prototype *ptr_prototype)
{
Type ret_type;
if (! match_type(state, &ret_type))
{
state.error_msg += "Expected return type for prototype.\n";
return false;
}
simple::string fun_name;
if (!match_ident_name(state, &fun_name))
{
state.error_msg += "Expected function name.\n";
return false;
}
if (!match_word(state, "("))
{
state.error_msg += "Missed ( after function name.\n";
return false;
}
ArgumentsList argument_list;
if (!match_arguments_list(state, &argument_list))
return false;
// Skip ;
simple::string token;
if (state.peek_token(&token) && token == ";")
state.skip();
if (state.peek_token(&token))
{
state.error_msg.snprintf("There are some words(\"%s\") following prototype.", 256,
token.c_str());
return false;
}
ptr_prototype->fun_name = simple::move(fun_name);
ptr_prototype->ret_type = simple::move(ret_type);
ptr_prototype->arguments_list = simple::move(argument_list);
return true;
}
match_osm_id::match_type match_osm_id::match(part_iterator &begin,
const part_iterator &end) const {
if (begin != end) {
try {
std::string bit = *begin;
// note that osm_id_t is actually unsigned, so we lose a bit of
// precision here, but it's OK since IDs are postgres 'bigint' types
// which are also signed, so element 2^63 is unlikely to exist.
int64_t x = boost::lexical_cast<int64_t>(bit);
if (x > 0) {
++begin;
return match_type(x);
}
} catch (std::exception &e) {
throw error();
}
}
throw error();
}
vm_offset_t
db_disasm(vm_offset_t loc, bool altfmt)
{
struct riscv_op *op;
InstFmt i;
int j;
i.word = db_get_value(loc, INSN_SIZE, 0);
/* First match opcode */
for (j = 0; riscv_opcodes[j].name != NULL; j++) {
op = &riscv_opcodes[j];
if (op->opcode == i.RType.opcode) {
if (match_type(i, op, loc))
break;
}
}
db_printf("\n");
return(loc + INSN_SIZE);
}
static int read_file_list(const char * path, solist_t files, solist_t dirs)
{
int ret;
struct dirent **namelist;
strobj_t sobj = NULL;
const char * errmsg;
struct stat st;
char buf[1024];
//d_dbg("%s: path = %s\n",__func__, path);
ret = scandir(path, &namelist, 0, alphasort);
if (ret < 0) perror("scandir");
else
{
while (ret > 0)
{
ret--;
errmsg = NULL;
#if 1//marco, use lstat to retrieve the file type of the files under 'path'
//in previous version, we use d_type to know the file_type but some filesystem
//doesn't support it, so the values will always 0 and become DT_UNKNOWN
sprintf(buf,"%s/%s",path,namelist[ret]->d_name);
lstat(buf, &st);
if (S_ISLNK(st.st_mode))
{
errmsg = "link";
goto ERR;
}
else if (S_ISREG(st.st_mode) || S_ISDIR(st.st_mode))
{
if (namelist[ret]->d_name[0]=='.')
{
errmsg = "hidden";
goto ERR;
// break;
}
if (S_ISREG(st.st_mode) && !match_type(namelist[ret]->d_name))
{
errmsg = "unmatch";
goto ERR;
// break;
}
sobj = sobj_new();
if (sobj)
{
sobj_add_string(sobj, path);
sobj_add_char(sobj, '/');
sobj_add_string(sobj, namelist[ret]->d_name);
verbose("Found %s file - '%s'\n",
( S_ISDIR(st.st_mode)) ? "DT_DIR":"DT_REG",
sobj_get_string(sobj));
solist_add( (S_ISDIR(st.st_mode))?dirs : files, sobj);
}
else
{
verbose("Memory allocation failed !!\n");
}
}
else
{
errmsg = "UNKNOWN FILE TYPE";
}
ERR:
#else
switch (namelist[ret]->d_type)
{
case DT_UNKNOWN: errmsg = "DT_UNKNOWN"; break;
case DT_FIFO: errmsg = "DT_FIFO"; break;
case DT_CHR: errmsg = "DT_CHR"; break;
case DT_BLK: errmsg = "DT_BLK"; break;
case DT_LNK: errmsg = "DT_LNK"; break;
case DT_SOCK: errmsg = "DT_SOCK"; break;
case DT_WHT: errmsg = "DT_WHT"; break;
case DT_DIR:
case DT_REG:
if (namelist[ret]->d_name[0]=='.')
{
errmsg = "hidden";
break;
}
if (namelist[ret]->d_type==DT_REG && !match_type(namelist[ret]->d_name))
{
errmsg = "unmatch";
break;
}
sobj = sobj_new();
if (sobj)
{
sobj_add_string(sobj, path);
sobj_add_char(sobj, '/');
sobj_add_string(sobj, namelist[ret]->d_name);
verbose("Found %s file - '%s'\n",
(namelist[ret]->d_type==DT_DIR) ? "DT_DIR":"DT_REG",
sobj_get_string(sobj));
solist_add((namelist[ret]->d_type == DT_DIR) ?
dirs : files, sobj);
}
else
{
verbose("Memory allocation failed !!\n");
}
break;
}
#endif
if (errmsg && o_verbose > 1)
{
verbose("Ignoring %s file - '%s'\n",
errmsg, namelist[ret]->d_name);
}
free(namelist[ret]);
}
free(namelist);
}
//d_dbg("%s: return %d\n",__func__,ret);
return ret;
}
void l_scan (SOURCE_FILE * sf)
{
int r = 1,in_sub = FALSE;
int block_stack[STACK_SIZE],block_size = 0;
list_init(&list_sub);
list_init(&list_var);
list_init(&list_array);
while(r)
{
r = l_get_line(sf);
pline = line;
l_get_token ();
// skip empty line
if (token_type==TT_LINE_END) continue;
// check command
if (IS_KEYWORD(token_type))
{
if (token_type==KEY_SUB)
{
USER_SUB * sub;
if(in_sub)
{
merror_msg("sub procedure can not be nested");
}
in_sub = TRUE;
match_type(TT_ID);
sub = (USER_SUB*)calloc(sizeof(USER_SUB),1);
sub->name = s_strdup(token);
sub->pos = sf->pos;
list_push(&list_sub,sub);
match_type(TT_LINE_END);
push_block(B_SUB);
continue;
}
else if (token_type==KEY_END)
{
if (block_size<=0 || block_top==B_REPEAT)
merror_illegal_token();
match_type(TT_LINE_END);
if(pop_block==B_SUB)
{
in_sub = FALSE;
}
continue;
}
else if(token_type==KEY_VAR)
{
while(1)
{
match_type(TT_ID);
l_get_token();
if (token_type==TT_END) break;
else if (token_type==TT_COM) continue;
else merror_illegal_token();
}
}
if (!in_sub) merror_illegal_token();
if(token_type==KEY_IF)
{
match_exp(pline);
match_type(TT_LINE_END);
push_block(B_IF);
}
else if (token_type==KEY_ELSEIF)
{
if (block_size<=0 || block_top!=B_IF)
merror_illegal_token();
match_exp(pline);
match_type(TT_LINE_END);
}
else if (token_type==KEY_ELSE)
{
if (block_size<=0 || !(block_top==B_IF || block_top==B_CASE))
merror_illegal_token();
match_type(TT_LINE_END);
}
else if (token_type==KEY_WHILE)
{
match_exp(pline);
match_type(TT_LINE_END);
push_block(B_WHILE);
}
else if (token_type==KEY_FOR)
{
// 'for' ID '=' EXP 'to' EXP
match_type(TT_ID);
match_type(OPR_EQ);
match_exp(pline);
match_str("to");
match_exp(pline);
l_get_token();
if (token_type!=TT_LINE_END)
{
if (!str_eq(token,"step"))
merror_expect("step");
match_exp(pline);
match_type(TT_LINE_END);
}
push_block(B_FOR);
}
else if (token_type==KEY_CASE)
{
match_type(TT_ID);
match_type(TT_LINE_END);
push_block(B_CASE);
}
else if (token_type==KEY_REPEAT)
{
match_type(TT_LINE_END);
push_block(B_REPEAT);
}
else if (token_type==KEY_UNTIL)
{
if (block_size<=0 || block_top!=B_REPEAT)
merror_illegal_token();
match_exp(pline);
match_type(TT_LINE_END);
pop_block;
}
else if (token_type==KEY_WHEN)
{
if (block_size<=0 || block_top!=B_CASE)
merror_illegal_token();
match_exp(pline);
match_type(TT_LINE_END);
}
else if (token_type==KEY_GOSUB)
{
match_type(TT_ID);
match_type(TT_LINE_END);
}
else if (token_type==KEY_EXIT)
{
match_type(TT_LINE_END);
}
else if (token_type==KEY_BREAK)
{
match_type(TT_LINE_END);
}
else if (token_type==KEY_RETURN)
{
match_type(TT_LINE_END);
}
else if (token_type==KEY_DIM)
{
while(1)
{
match_type (TT_ID);
match_type (TT_LBK);
match_exp (pline);
match_type (TT_RBK);
l_get_token();
if (token_type==TT_COM) continue;
else if (token_type==TT_LINE_END) break;
else merror_illegal_token();
}
}
}
else if (token_type==TT_ID)
{
if (!in_sub) merror_illegal_token();
if (str_eq(token,"print"))
{
while(1)
{
l_get_token();
if(token_type!=TT_STRING)
{
l_put_back();
match_exp(pline);
}
l_get_token();
if(token_type==TT_LINE_END) break;
else if (token_type==TT_COM) continue;
else merror_expect(",");
}
}
else if (str_eq(token,"input"))
{
while(1)
{
match_type(TT_ID);
l_get_token();
if(token_type==TT_LINE_END) break;
else if (token_type==TT_COM) continue;
else merror_expect(",");
}
}
else
{ // match: [var][=][exp]
l_get_token();
if (token_type==OPR_EQ)
{
match_exp(pline);
match_type(TT_LINE_END);
}
else
{
if (token_type!=TT_LBK)merror_expect("(");
match_exp(pline);
match_type(TT_RBK);
match_type(OPR_EQ);
match_exp(pline);
match_type(TT_LINE_END);
}
}
}
else
merror_illegal_token ();
}
if (block_size>0)
merror_msg("incompleted '%s' block!",BLOCK_NAME[block_top]);
}
match_begin::match_type
match_begin::match(part_iterator &begin, const part_iterator &end) const {
return match_type();
}
bool MethodIG::Arg::parse( iglexer& lex, bool argname )
{
//arg: [ifc_in|ifc_out|ifc_inout|] [const] type
//type: [class[<templarg>]::]* type[<templarg>] [[*|&] [const]]*
int io = lex.matches_either("ifc_in","ifc_out","ifc_inout","ifc_ret");
if(!io) io=1;
//ifc_return(ifcname)
if(io == 4) {
lex.match('(');
match_type(lex, ifctarget);
lex.match(')');
io = 2;
}
binarg = (io&1) != 0;
boutarg = (io&2) != 0;
bvolatile = lex.matches("ifc_volatile");
bconst = lex.matches("const");
benum = lex.matches("enum");
if(lex.matches("unsigned"))
type << "unsigned" << ' ';
match_type(lex, type);
int isPR=0,wasPR;
int isCV=0;
while((wasPR = lex.matches_either('*', '&')))
{
isPR = wasPR;
if(bconst) {
//const is a part of the inner type
type.ins(0, "const ");
bconst = 0;
}
type << lex.last().value();
if((isCV = lex.matches_either("const", "volatile")))
type << ' ' << lex.last().value();
}
if(isCV == 1) //ends with const
bconst = true;
if(isCV)
type.resize(isCV==1 ? 6 : 9); //strip the last const and volatile
bptr = isPR == 1;
bref = isPR == 2;
if(boutarg && ((!bptr && !bref && !ifctarget) || type.begins_with("const "))) {
lex.set_err() << "out argument must be a ref or ptr and cannot be const\n";
}
basetype = type;
if(isPR)
basetype.shift_end(-1);
if(basetype.begins_with("const ")) basetype.shift_start(6);
else if(basetype.ends_with(" const")) basetype.shift_end(-6);
//special handling for strings and tokens
if(type == "const char*") {
basetype = "coid::charstr";
base2arg = ".c_str()";
}
else if(basetype == "token" || basetype == "coid::token") {
basetype = "coid::charstr";
}
biref = basetype.begins_with("iref<");
if(biref) {
token bs = basetype;
bs.shift_start(5);
bs.cut_right_back('>');
do {
token p = bs.cut_left("::", false);
fulltype << p;
if(bs)
fulltype << '_';
}
while(bs);
}
else if(ifctarget)
lex.set_err() << "ifc_ret argument must be an iref<>\n";
if(ifctarget) {
type.swap(ifctarget);
type.ins(0, "iref<");
type.append('>');
basetype.set(type.ptr()+5, type.ptre()-1);
//remove iref from ifctarget
ifctarget.del(0, 5);
ifctarget.del(-1, 1);
}
if(!argname)
return lex.no_err();
lex.match(lex.IDENT, name, "expecting argument name");
//match array
if(lex.matches('[') )
size << lex.next_as_block(lex.SQUARE);
bnojs = false;
//match default value
if(lex.matches('=')) {
//match everything up to a comma or a closing parenthesis
lex.enable(lex.SQUARE, true);
lex.enable(lex.ROUND, true);
do {
const lexer::lextoken& tok = lex.next();
if( tok == lex.SQUARE || tok == lex.ROUND ) {
lex.complete_block();
defval << tok.leading_token(lex) << tok << tok.trailing_token(lex);
continue;
}
if( tok == ',' || tok == ')' || tok.end() ) {
lex.push_back();
break;
}
defval << tok;
}
while(1);
lex.enable(lex.SQUARE, false);
lex.enable(lex.ROUND, false);
bnojs = name.first_char() == '_';
}
return lex.no_err();
}
/*
parse_identifier
Matches a valid variable name
Parameters: none
Return: none
*/
void parse_identifier(Tree &cst){
cst.add_branch_node("identifier");
match_type("identifier", cst);
cst.kill_all_children();
}
