static atom_p parse_symbol(parsebuf_p pb, char terminator, int print_mode) { char * symbol_start; char * symbol_stop; int symbol_length; uint_t symbol_address; static char symbol_buffer[128]; DEBUG(); if (parse_literal(pb, &symbol_start, &symbol_stop, terminator)) return NULL; if (symbol_start[0] != '@' || !(('a' <= symbol_start[1] && symbol_start[1] <= 'z') || ('A' <= symbol_start[1] && symbol_start[1] <= 'Z') || ('0' <= symbol_start[1] && symbol_start[1] <= '9') || symbol_start[1] == '_')) return NULL; symbol_length = symbol_stop - (++symbol_start); if (symbol_length > sizeof(symbol_buffer) - 1) return NULL; strncpy(symbol_buffer, symbol_start, symbol_length); symbol_buffer[symbol_length] = '\0'; symbol_address = splinter_get_symbol(symbol_buffer); if (!symbol_address) return NULL; DEBUG("parsed symbol atom [%s] -> [%lx]", symbol_buffer, symbol_address); return atom_alloc_plain(print_mode ? operator_hex : operator_value, symbol_address); }
static atom_p parse_variable(parsebuf_p pb, char terminator, int print_mode) { char * var_start; char * var_stop; char * var_value; int var_length; static char var_buffer[128]; DEBUG(); if (parse_literal(pb, &var_start, &var_stop, terminator)) return NULL; if (var_start[0] != '$' || !(('a' <= var_start[1] && var_start[1] <= 'z') || ('A' <= var_start[1] && var_start[1] <= 'Z') || ('0' <= var_start[1] && var_start[1] <= '9') || var_start[1] == '_')) return NULL; var_length = var_stop - (++var_start); if (var_length > sizeof(var_buffer) - 1) return NULL; strncpy(var_buffer, var_start, var_length); var_buffer[var_length] = '\0'; var_value = splinter_find_variable(var_buffer); if (!var_value) return NULL; var_length = strlen(var_value); DEBUG("parsed variable atom [%s] -> [%s]", var_buffer, var_value); return atom_alloc_string(print_mode ? operator_string : operator_value, var_value, var_value + var_length); }
/* * Name: parse_macro * Purpose: separate literals from keys in a macro definition * Date: June 5, 1992 * Passed: macro_key: key that we are a assigning a macro to * residue: pointer to macro defs * Notes: for each token in macro def, find out if it's a literal or a * function key. * a literal begins with a ". to put a " in a macro def, precede * a " with a ". */ void parse_macro( int macro_key, char *residue ) { int rc; char literal[1042]; char *l; int key_no; /* * reset any previous macro def. */ initialize_macro( macro_key ); while (residue != NULL) { /* * skip over any leading spaces. */ while (*residue == ' ') ++residue; /* * done if we hit a comment */ if (*residue == ';') residue = NULL; /* * check for a literal. */ else if (*residue == '\"') { rc = parse_literal( macro_key, residue, literal, &residue ); if (rc == OK) { l = literal; while (*l != '\0' && rc == OK) { rc = record_keys( macro_key, *l ); ++l; } } else { printf( "==> %s", line_in ); printf( "Literal not recognized: line %u : literal %s\n", line_no, literal ); } /* * check for a function key. */ } else { residue = parse_token( residue, literal ); key_no = search( literal, valid_keys, AVAIL_KEYS ); if (key_no != ERROR) record_keys( macro_key, key_no+256 ); else { printf( "==> %s", line_in ); printf( "Unrecognized key: line %u : key %s\n", line_no, literal ); } } } check_macro( macro_key ); }
void parse_operand(char *string, EOperandInfo *operand, int index, EShaderInstruction instruction) { int operidx = 0; char original_string[128]; memset(&original_string,0, sizeof(original_string)); bool negate = false; if(string[0] == '-') { string++; negate = true; } strcpy(original_string, string); char *num = find_first_nonalpha(string); char reg[32]; memset(®,0,sizeof(reg)); if(num != NULL) { //"vec1" char *accessor = strchr(num, '.'); if(accessor != NULL) { //"vec0.rgba" *(accessor) = 0; operidx = atoi(num); accessor++; char *non_alpha = find_first_nonalpha(string); if(non_alpha) { *non_alpha = 0; } EShaderRegister reg = find_register_by_name(string); operand->registers[index] = reg; operand->accessors[index] = parse_accessors(reg, accessor); operand->indexes[index] = operidx; } else { //"vec0" int regnum = atoi(num); operand->indexes[index] = regnum; operand->accessors[index] = 0;//EVectorFlags_Red|EVectorFlags_Blue|EVectorFlags_Green|EVectorFlags_Alpha; *num = 0; EShaderRegister reg = find_register_by_name(string); operand->registers[index] = reg; } } if(negate) { operand->accessors[index] |= EVectorFlags_Negate; } operand->registers[index] = find_register_by_name(string); if(instruction >= EShaderInstruction_BranchBegin && instruction <= EShaderInstruction_BranchEnd) { operand->jump_index = find_jump_index_by_name(original_string); //printf("read branch\n"); return; } if(operand->registers[index] == -1) { //literal value if(original_string[0] == '#' || original_string[0] == ';') { //skip marker definition } else { parse_literal(operand, index, original_string); //printf("some literal: %s\n",original_string); } } }
void parse() { ncomments = nchars = 0; p = line; line[0] = 0; for (next_char(); c > 0; next_char()) { while (c == ' ' || c == '\n') next_char(); if (c == '/') parse_comment(); else if (c == '"') parse_string(); else parse_literal(); } }
node_p tree_copy(const node_cp& source, CallFactory factory) { // Simply parse the sexpr. This isn't the most efficient but is // extremely simple. size_t i = 0; string sexpr = source->to_s(); if (sexpr.empty()) { return node_p(); } if (sexpr[0] == '(') { return parse_call(sexpr, i, factory); } return parse_literal(sexpr, i); }
std::pair< bool, bool > parser::parse(const char* begin, const char* end) { assert( !state_.empty() ); for ( ; begin != end && !state_.empty(); ) { switch ( main_state( state_.top() ) ) { case idle_parsing: begin = eat_white_space(begin, end); if ( begin != end ) { state_.top() = parse_idle(*begin); } break; case start_number_parsing: begin = parse_number(begin, end); break; case start_array_parsing: begin = parse_array(begin, end); break; case start_object_parsing: begin = parse_object(begin, end); break; case start_string_parsing: begin = parse_string(begin, end); break; case start_true_parsing: case start_false_parsing: case start_null_parsing: begin = parse_literal(begin, end); break; default: assert(!"should not happen"); } } // consume trailing whitespaces if ( state_.empty() ) begin = eat_white_space(begin, end); return std::make_pair( begin == end, state_.empty() ); }
static struct __operator * __find_closest_token(parsebuf_p pb, char terminator) { char * start, * stop; struct __operator *closest_operator = NULL; struct __operator *current_operator = operators; int closest_distance = -1, current_distance; parsebuf_t buf; DEBUG(); __parsebuf_snapshot(pb, &buf); if(parse_literal(pb, &start, &stop, terminator)) return NULL; for(; current_operator->token; current_operator++) { if((current_distance = __strings_distance(start, stop, current_operator->token)) == 0) { // A perfect match, return it DEBUG("found perfect match for [%s]", current_operator->token); closest_distance = current_distance; closest_operator = current_operator; break; } if(current_distance > 0) { if(closest_distance < 0 || current_distance > closest_distance) { closest_distance = current_distance; closest_operator = current_operator; } } } if (closest_distance > 0 && closest_distance < 3) { splinter_error_return(NULL, "%s ambiguous keyword @ %d:%d - %d:%d", buf.n, buf.l, buf.c, pb->l, pb->c); } if(closest_operator) { DEBUG("parsed keyword [%s] distance = %d", closest_operator->token, closest_distance); return closest_operator; } splinter_error_return(NULL, "%s invalid keyword @ %d:%d - %d:%d", buf.n, buf.l, buf.c, pb->l, pb->c); return NULL; }
/*----------------------------------------------------------------------*/ static ast_expression_t *parse_value(parse_state_t *p) { token_t *token = peek_token(p); if (token == NULL) { } else if (token->type == TK_INT_LITERAL || token->type == TK_FLOAT_LITERAL || token->type == TK_DOUBLE_LITERAL || token->type == TK_STRING_LITERAL) { return parse_literal(p); } else if (token->type == TK_IDENTIFIER) { next_token(p); if (test_token(peek_token(p), TK_LBRACKET)) { rewind_token(p); return parse_function_call(p); } else { rewind_token(p); return parse_variable(p); } } error(p, "value expected"); return NULL; /* unreachable */ }
static int parse_primary(struct peg_grammar_parser *pgp, struct peg_cursor *pc, int *prip) { struct peg_grammar *peg = pgp->peg; int pri; int rv; int match = -1; struct peg_cursor npc = *pc; int prefix = PEG_ATTR_NONE; int suffix = PEG_ATTR_NONE; int action = PEG_ACT_NONE; struct raw r = { 0, NULL }; struct peg_node *pn; if ( string_match(pgp, "&", &npc) ) prefix = PEG_ATTR_AND; else if ( string_match(pgp, "!", &npc) ) prefix = PEG_ATTR_NOT; if ( (rv = parse_id_and_not_arrow(pgp, &npc, &match)) != 0 ) { if ( rv < 0 ) goto err; } else if ( (rv = parse_paren_expr(pgp, &npc, &match)) != 0 ) { if ( rv < 0 ) goto err; } else if ( (rv = parse_literal(pgp, &npc, &match)) != 0 ) { if ( rv < 0 ) goto err; } else if ( (rv = parse_class(pgp, &npc, &match)) != 0 ) { if ( rv < 0 ) goto err; } else { if ( prefix == PEG_ATTR_NONE ) return 0; pgp->err = PEG_ERR_BAD_PRIMARY; pgp->eloc = *pc; return -1; } pri = peg_node_new(peg, PEG_PRIMARY, pc->line); if ( pri < 0 ) { pgp->err = PEG_ERR_NOMEM; goto err; } if ( string_match(pgp, "?", &npc) ) suffix = PEG_ATTR_QUESTION; else if ( string_match(pgp, "*", &npc) ) suffix = PEG_ATTR_STAR; else if ( string_match(pgp, "+", &npc) ) suffix = PEG_ATTR_PLUS; else suffix = PEG_ATTR_NONE; rv = parse_code(pgp, &npc, &r); if ( rv < 0 ) goto err; if ( rv > 0 ) { action = PEG_ACT_CODE; } else { rv = parse_action_label(pgp, &npc, &r); if ( rv < 0 ) goto err; if ( rv > 0 ) action = PEG_ACT_LABEL; } pn = NODE(peg, pri); pn->pn_next = -1; pn->pp_match = match; pn->pp_prefix = prefix; pn->pp_suffix = suffix; pn->pp_action = action; pn->pn_action_cb = NULL; pn->pp_code = r; *pc = npc; *prip = pri; return 1; err: peg_node_free(peg, match); return -1; }
static ZZJSON *parse_null(ZZJSON_CONFIG *config) { return parse_literal(config, (char *)"null", ZZJSON_NULL); }
static ZZJSON *parse_false(ZZJSON_CONFIG *config) { return parse_literal(config, (char *)"false", ZZJSON_FALSE); }
static ZZJSON *parse_true(ZZJSON_CONFIG *config) { return parse_literal(config, (char *)"true", ZZJSON_TRUE); }
/** * Constructs the expression tree. */ void Filter::parse(const char* exp, int32_t len, Node *node, bool debug) { if (debug) { std::cerr << "parsing \""; for (int32_t i=0; i<len; ++i) std::cerr << exp[i] ; std::cerr << "\" " << len << "\n"; } //****************************** //trim white spaces and brackets //****************************** while (*exp==' ') ++exp; while (exp[len-1]==' ') --len; trim_brackets(exp, len); //this is a literal if (is_literal(exp, len)) { //will not recurse any further return parse_literal(exp, len, node, debug); } //this is guaranteed to be decomposed unless there is an error in the expression else { const char* p = exp; //points to end of first part const char* q = exp; //points to start of second part const char* r = exp; //for iteration int32_t type = INT_MAX; while(r-exp!=len) { fwd_to_closing_bracket(r, len); int32_t oplen = -1; int32_t ctype = peek_op(r, len, oplen, debug); if(ctype!=-1) { if (ctype<type) { if (debug) std::cerr<< "\tupdating type\n"; type = ctype; p = r-1; q = r+oplen; } r += oplen-1; } ++r; } if (type==-1) { kstring_t s = {0,0,0}; kputsn(exp, len, &s); fprintf(stderr, "[%s:%d %s] expression not correct %s\n", __FILE__, __LINE__, __FUNCTION__, s.s); if (s.m) free(s.s); exit(1); } node->type = type; node->left = new Node(); parse(exp, p-exp+1, node->left, debug); node->right = new Node(); parse(q, len-(q-exp), node->right, debug); } }