static char *copy_and_expand_variables(const char *path, int len) { char *dst, *result; const char *src; int length = 0; int backslash; /* first determine the length of the expanded string */ backslash = 0; for (src = path; src < path + len; src++) { if (!backslash && *src == '\\' && src + 1 < path + len) { backslash = 1; continue; } if (!backslash && *src == '$') { src++; length += strlen(parse_variable(&src, path + len)); src--; } else length++; backslash = 0; } /* allocate a string of the appropriate length */ result = malloc(length + 1); assert_always(result != NULL, "Out of memory in variable expansion!"); /* now actually generate the string */ backslash = 0; for (src = path, dst = result; src < path + len; src++) { if (!backslash && *src == '\\' && src + 1 < path + len) { backslash = 1; continue; } if (!backslash && *src == '$') { src++; dst += sprintf(dst, "%s", parse_variable(&src, path + len)); src--; } else *dst++ = *src; backslash = 0; } /* NULL terminate and return */ *dst = 0; return result; }
/** * Parse the string expression 's' (that contains only string values) and return its * resulting value in 'value'. * Return a pointer behind the last character of the expression. * Return NULL if a syntax error occurred. */ char *parse_string_expression(char *s, char **value) { unsigned int var_name; variable *var; unsigned char var_type; unsigned char token; s = skip_whitespace(s); token = next_token(s); if (token == TOKEN_STRING) { if (s = parse_string(s, parsebuf)) { *value = parsebuf; return s; } else { syntax_error_invalid_string(); } } else if (token == TOKEN_VAR_STRING) { s = parse_variable(s, &var_name, &var_type); var = find_variable(var_name, VAR_TYPE_STRING, NULL); if (var) { *value = get_string_variable_value(var); return s; } else { syntax_error_msg("Variable not found"); } } else { syntax_error(); } return NULL; }
/** строка с подстановками */ int parse_subst(char *text,char **endptr,Tag *toptag) { char *p; char *s; Tag *tag; tag=NULL; if (text[0]!='\"') return 1; s=text; if (toptag) tag=mark(STRING,text,s,toptag); mark_len(NULL,1,s,&s,tag); // открывающая кавычка while(*s) { p=s; s+=strcspn(s,"\\$[{\""); if (p!=s) mark(CHARS,p,s,tag); switch (*s) { case '\\' : parse_escape(s,&s,tag);break; case '$' : parse_variable(s,&s,tag);break; case '[' : parse_command(s,&s,tag);break; } if (s[0]=='\"') { mark_len(NULL,1,s,&s,tag); // закрывающая кавычка break; } if (p==s) break; } if (endptr) (*endptr)=s; return 0; }
/** слово: список в скобках {} подстановка выражения в скобках [] */ int parse_word(char *text,char **endptr,Tag *toptag) { char *p,*s; Tag *tag; tag=NULL; s=text; if (s==NULL || isblank(*s)||strchr(EXPTERM,*s)) return 1; if (toptag) tag=mark(WORD,text,text,toptag); while(*s) { p=s; switch(*s) { case '{' : parse_list(s,&s,tag);break; case '[' : parse_command(s,&s,tag);break; case '\'': parse_string(s,&s,tag);break; case '\"': parse_subst(s,&s,tag);break; case '$' : parse_variable(s,&s,tag);break; default: if (s[0]=='#' && s[1]!='#' && s[1]!='!') { parse_macro(s,&s,tag); } else if (s[0]=='#' && s[1]=='?' && s[2]=='>') { parse_print(s,&s,tag); } else if ((s[0]=='-' && isdigit(s[1])) || isdigit(*s)) parse_numeric(s,&s,tag); else mark_cspn(CHARS,BLANK EXPTERM "(",s,&s,tag); } if (strchr(BLANK EXPTERM,*s)) break; if (p==s) break; } if (endptr) *endptr=s; return 0; }
/** текст выводимый на консоль **/ int parse_print(char *text,char **endptr,Tag *toptag) { char *s,*p; Tag *tag; TRACE(""); tag=NULL; if (text[0]!='#'||text[1]!='?'||text[2]!='>') return 1; s=text; if (toptag) tag=mark(PRINT,text,text,toptag); mark_len(NULL,3,s,&s,tag); // открывающая группа #?> while(*s) { p=s; mark_cspn(CHARS,"<$[\\",s,&s,tag); // фрагмент до кавычки ' или esc if (s[0]=='\\') parse_escape(s,&s,tag); // esc if (s[0]=='$') parse_variable(s,&s,tag);// подстановка переменных if (s[0]=='[') parse_command(s,&s,tag); // полстановка команд if (s[0]=='<') { if (s[1]=='?' && s[2]=='#') { mark_len(NULL,3,s,&s,tag); // закрывающая группа <?# break; } else { mark_len(NULL,1,s,&s,tag); } } if (p==s) break; } if (endptr) (*endptr)=s; return 0; }
/** * Parse the number term 's' and return its resulting value in 'value'. * Return a pointer behind the last character of the expression. * Return NULL if a syntax error occurred. */ char *parse_number_term(char *s, int *value) { unsigned char token; s = skip_whitespace(s); token = next_token(s); if (token == TOKEN_DIGITS || token == TOKEN_PLUS || token == TOKEN_MINUS) { if (s = parse_integer(s, value)) { return s; } else { syntax_error_invalid_number(); } } else if (token == TOKEN_VAR_NUMBER) { unsigned int var_name; unsigned char var_type; variable *var; s = parse_variable(s, &var_name, &var_type); var = find_variable(var_name, VAR_TYPE_INTEGER, NULL); if (var) { *value = get_integer_variable_value(var); return s; } else { syntax_error_msg("Variable not found"); } } else { syntax_error(); } return NULL; }
void task4_6::solution::process_line( std::string line ) { int eq_pos = line.find("="); const std::string& value_name = line.substr( 0, eq_pos-1 ); line = line.substr( eq_pos + 2 ); if( value.count( value_name ) ) throw std::logic_error( "such variable '"+value_name+"' already exists ("+boost::lexical_cast< std::string >( line_index )+")" ); std::stack< char > operations; std::stack< double > numbers; double result = 0; for( size_t i = 0; i < line.length(); i++) if( line[i] != ' ' ) if( line[i] == '(' ) operations.push('('); else if( line[i] ==')' ) { while( !operations.empty() && operations.top() != '(' ) { process_operation( numbers, operations.top() ); operations.pop(); } if( operations.empty() ) throw std::logic_error("not correct expression at "+boost::lexical_cast< std::string >( line_index )+" line"); operations.pop(); } else if( is_operation( line[i] ) ) { while( !operations.empty() && get_priority( operations.top() ) >= get_priority( line[i] ) ) { process_operation( numbers, operations.top() ); operations.pop(); } operations.push( line[i] ); } else { std::string operand; while (i < line.length() && line[i]!=' ' && !is_operation(line[i]) && line[i]!='(' && line[i]!=')') operand += line[i++]; --i; double to_push; parse_variable ( operand, to_push ); numbers.push ( to_push ); } while ( !operations.empty() ) { process_operation( numbers, operations.top() ); operations.pop(); } result = numbers.top(); value[ value_name ] = result; }
// factor = number | string_literal | "(" expression ")" | // variable | "this" | "null" | "true" | "false" | // "{" object_literal "}" | // "[" array_literal "]" | // function_definition | // function_call static enum v7_err parse_factor(struct v7 *v7) { int old_sp = v7_sp(v7); if (*v7->cursor == '(') { TRY(match(v7, '(')); TRY(parse_expression(v7)); TRY(match(v7, ')')); } else if (*v7->cursor == '\'' || *v7->cursor == '"') { TRY(parse_string_literal(v7)); } else if (*v7->cursor == '{') { TRY(parse_object_literal(v7)); } else if (is_alpha(*v7->cursor) || *v7->cursor == '_') { TRY(parse_identifier(v7)); if (test_token(v7, "this", 4)) { inc_stack(v7, 1); v7_top(v7)[-1] = &v7->scopes[v7->current_scope]; } else if (test_token(v7, "null", 4)) { TRY(v7_make_and_push(v7, V7_NULL)); } else if (test_token(v7, "true", 4)) { TRY(v7_make_and_push(v7, V7_BOOL)); v7_top(v7)[-1]->v.num = 1; } else if (test_token(v7, "false", 5)) { TRY(v7_make_and_push(v7, V7_BOOL)); v7_top(v7)[-1]->v.num = 0; } else if (test_token(v7, "function", 8)) { TRY(parse_function_definition(v7, NULL, 0)); } else if (test_token(v7, "delete", 6)) { TRY(parse_delete(v7)); } else { TRY(parse_variable(v7)); } } else { TRY(parse_num(v7)); } if (*v7->cursor == '(') { TRY(parse_function_call(v7)); } // Don't leave anything on stack if no execution flag is set if (v7->no_exec) { inc_stack(v7, old_sp - v7->sp); } return V7_OK; }
exparser::return_type exparser::loop(const std::string& s) { if (s.empty()) return return_false; if (debug) std::cout << "PARSING : " << s << std::endl; if (debug) std::cerr << "Try parenthesis" << std::endl; return_type parenthesis = parse_parenthesis(s); if (parenthesis) return parenthesis; if (debug) std::cerr << "Try constant" << std::endl; return_type constant = parse_constant(s); if (constant) return constant; if (debug) std::cerr << "Try variable" << std::endl; return_type variable = parse_variable(s); if (variable) return variable; if (debug) std::cerr << "Try plus" << std::endl; return_type plus = parse_plus(s); if (plus) return plus; if (debug) std::cerr << "Try minus" << std::endl; return_type minus = parse_minus(s); if (minus) return minus; if (debug) std::cerr << "Try multiply" << std::endl; return_type multiply = parse_multiply(s); if (multiply) return multiply; if (debug) std::cerr << "Try divide" << std::endl; return_type divide = parse_divide(s); if (divide) return divide; if (debug) std::cerr << "Try poewr" << std::endl; return_type power = parse_power(s); if (power) return power; if (debug) std::cerr << "Try function" << std::endl; return_type function = parse_function(s); if (function) return function; return return_false; }
core_option_manager_t *core_option_new(const char *conf_path, const struct retro_variable *vars) { const struct retro_variable *var; core_option_manager_t *opt = (core_option_manager_t*) calloc(1, sizeof(*opt)); if (!opt) return NULL; size_t size = 0; if (*conf_path) opt->conf = config_file_new(conf_path); if (!opt->conf) opt->conf = config_file_new(NULL); strlcpy(opt->conf_path, conf_path, sizeof(opt->conf_path)); if (!opt->conf) goto error; for (var = vars; var->key && var->value; var++) size++; opt->opts = (struct core_option*)calloc(size, sizeof(*opt->opts)); if (!opt->opts) goto error; opt->size = size; size = 0; for (var = vars; var->key && var->value; size++, var++) { if (!parse_variable(opt, size, var)) goto error; } return opt; error: core_option_free(opt); return NULL; }
/** * Assign a value to a variable or delete the variable if no assignment is given. * List all variables if no arguments are given. */ void cmd_let(char *args) { unsigned char token; unsigned int var_name; unsigned char var_type; skip_whitespace(args); if (*args == '\0') { print_all_variables(); print_ready(); return; } if (args = parse_variable(args, &var_name, &var_type)) { if (next_token(args) == TOKEN_ASSIGN) { token = next_token(args); args = consume_token(args, token); switch (var_type) { case VAR_TYPE_INTEGER: { int value; if (parse_number_expression(args, &value)) { create_variable(var_name, var_type, &value); } break; } case VAR_TYPE_STRING: { char *value; if (parse_string_expression(args, &value)) { create_variable(var_name, var_type, value); } break; } } } else { if (*args == '\0') { delete_variable(var_name, var_type); } } } else { syntax_error(); } }
object& parse() { line_ = column_ = 0; if (parsed) delete parsed; parsed = 0; while (iss_.good()) { skipws(); char_type c = iss_.peek(); if (c == '{') { parsed = parse_object(); break; } else if (isalpha(c)) { parsed = new object(); while (iss_.good()) { parsed->add<shaun>(parse_variable()); skipws(); } break; } else { PARSE_ERROR(root must be an object); } forward(); } PARSE_ASSERT(parsed, what ?); return *parsed; }
/*----------------------------------------------------------------------*/ 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 */ }
/** * Set the cursor to a specific screen position. * AT <x>,<y> */ void cmd_at(char *args) { int x; int y; unsigned char token; args = parse_number_expression(args, &x); if (!args || x < 0 || x > 39) { syntax_error_invalid_argument(); return; } args = consume_token(args, TOKEN_COMMA); if (! args) { return; } args = parse_number_expression(args, &y); if (!args || y < 0 || y > 3) { syntax_error_invalid_argument(); return; } if (next_token(args) == TOKEN_COMMA) { args = consume_token(args, TOKEN_COMMA); if ((token = next_token(args)) == TOKEN_VAR_STRING) { unsigned int var_name; unsigned char var_type; if (args = parse_variable(args, &var_name, &var_type)) { char c = lcd_getc(x, y); sprintf (print_buffer, "%c", c); create_variable(var_name, VAR_TYPE_STRING, print_buffer); } } else { syntax_error_invalid_token(token); } } else { lcd_goto(x, y); } }
/** * Input a variable from the keyboard. * INPUT <variable> [ONERROR <command] */ void cmd_input(char *args) { unsigned int var_name; unsigned char var_type; args = parse_variable(args, &var_name, &var_type); if (args) { if (var_type == VAR_TYPE_STRING) { char *line = readline(INTERRUPTIBLE); create_variable(var_name, var_type, line); } else if (var_type == VAR_TYPE_INTEGER) { for (;;) { int value = 0; char *line = readline(INTERRUPTIBLE); if (is_interrupted()) { break; } if (parse_integer(line, &value)) { create_variable(var_name, var_type, &value); break; } else { if (next_token(args) == TOKEN_ONERROR) { args = consume_token(args, TOKEN_ONERROR); execute(args); break; } else { syntax_error_invalid_number(); lcd_puts("Enter again: "); } } } } else { syntax_error_invalid_argument(); } } else { syntax_error_invalid_argument(); } }
static void handle_variable (const char *pair) { char *name; char *value; JBVariable *variable; GError *err = NULL; if (! parse_variable(pair, &name, &value)) jb_error("invalid variable specification \"%s\"", pair); variable = jb_variable_get_variable(name); if (variable == NULL || (variable->flags & JB_VARIABLE_USER_SETTABLE) == 0) jb_error("unknown variable \"%s\"", name); if (! jb_variable_set_from_string(variable, value, &err)) jb_error("invalid value \"%s\" for %s variable \"%s\": %s", value, variable->type->name, name, err->message); variable->user_set = TRUE; }
/* See SMTSolver::parse_evidence() */ void YicesSolver::parse_evidence() { /* Look for text like "(= v36 0b01101111111111111101011110110100)" or * "(= (m95 0b01000000000000011100111111110100) 0b00000000000000000100111100000100)". The text is free-form, with any * white space appearing in place of the SPC characters shown. */ evidence.clear(); const char *s = output_text.c_str(); char *rest = NULL; struct Error { Error(const char *at, const std::string &mesg): at(at), mesg(mesg) {} const char *at; std::string mesg; }; try { while (*s) { // "(= " while (isspace(*s)) ++s; if (!*s) break; if ('('!=*s++) throw Error(s-1, "left paren expected (1)"); while (isspace(*s)) ++s; if ('='!=*s++) throw Error(s-1, "'=' operator expected (2)"); if (!isspace(*s++)) throw Error(s-1, "'=' operator expected (3)"); // variable or function-apply while (isspace(*s)) ++s; if ('('==*s) { ++s; // memory variable, like "m95" errno = 0; (void) parse_variable(s, &rest, 'm'); if (errno || s==rest) throw Error(s, "memory variable expected (5)"); s = rest; // memory address, like 0b01000000000000011100111111110100 uint64_t addr = rose_strtoull(s, &rest, 0); if (errno || s==rest) throw Error(s, "memory address expected (6)"); s = rest; // right paren while (isspace(*s)) ++s; if (')'!=*s++) throw Error(s, "')' expected after memory address (7)"); // memory value while (isspace(*s)) ++s; if (0!=strncmp(s, "0b", 2) || !strchr("01", s[2])) throw Error(s, "binary constant expected for memory value (8)"); s += 2; uint64_t val = rose_strtoull(s, &rest, 2); if (errno || s==rest) throw Error(s, "memory value expected (9)"); size_t nbits = rest-s; s = rest; std::string addr_name = StringUtility::addrToString(addr); if (evidence.find(addr_name) != evidence.end()) throw Error(s, addr_name + " appears more than once (10)"); evidence[addr_name] = std::pair<size_t, uint64_t>(nbits, val); } else { // bitvector variable name errno = 0; uint64_t vnum = parse_variable(s, &rest, 'v'); if (errno || s==rest) throw Error(s, "bitvector variable expected (11)"); s = rest; // bitvector value while (isspace(*s)) ++s; if (0!=strncmp(s, "0b", 2) || !strchr("01", s[2])) throw Error(s, "binary constant expected for bitvector variable (12)"); s += 2; uint64_t val = rose_strtoull(s, &rest, 2); if (errno || s==rest) throw Error(s, "bitvector value expected (13)"); size_t nbits = rest-s; s = rest; std::string vname = "v" + StringUtility::numberToString(vnum); ASSERT_require(evidence.find(vname)==evidence.end()); evidence[vname] = std::pair<size_t, uint64_t>(nbits, val); } // ')' closing the '=' operator if (')'!=*s++) throw Error(s-1, "expected ')' to close '=' operator (14)"); } } catch (const Error &err) { std::cerr <<"YicesSolver::parse_evidence: " <<err.mesg <<" at char position " <<(err.at-output_text.c_str()) <<"\n" <<"YicesSolver::parse_evidence: before \"" <<std::string(err.at).substr(0, 20) <<"\"...\n" <<"YicesSolver::parse_evidence: entire evidence string follows...\n" <<output_text.c_str(); } }
cgc_ssize_t cgc_tokenize(char *str, struct token *tokens) { int ret; char c; struct token *token = tokens; while ((c = *str++)) { if (c == '_' || cgc_islower(c)) { if ((ret = parse_variable(str - 1, token)) < 0) return ret; str += ret - 1; token++; continue; } if (cgc_isdigit(c)) { if ((ret = parse_constant(str - 1, token)) < 0) return ret; str += ret - 1; token++; continue; } switch (c) { case '=': token->type = TOK_ASSIGNMENT; break; case '+': token->type = TOK_ADD; break; case '-': token->type = TOK_SUBTRACT; break; case '*': token->type = TOK_MULTIPLY; break; case '/': token->type = TOK_DIVIDE; break; case '~': token->type = TOK_NEGATE; break; case '&': token->type = TOK_ADDRESS_OF; break; case '$': token->type = TOK_DEREFERENCE; break; case '(': token->type = TOK_LEFT_PARENTHESIS; break; case ')': token->type = TOK_RIGHT_PARENTHESIS; break; case ' ': continue; default: return EXIT_FAILURE; } token++; } return token - tokens; }
static void ide_source_snippet_parser_do_part (IdeSourceSnippetParser *parser, const gchar *line) { const gchar *dollar; gchar *str; gchar *inner; gchar *name; glong n; g_assert (line); g_assert (*line == '\t'); line++; again: if (!*line) return; if (!(dollar = strchr (line, '$'))) { ide_source_snippet_parser_do_part_simple (parser, line); return; } /* * Parse up to the next $ as a simple. * If it is $N or ${N} then it is a linked chunk w/o tabstop. * If it is ${N:""} then it is a chunk w/ tabstop. * If it is ${blah|upper} then it is a non-tab stop chunk performing * some sort of of expansion. */ g_assert (dollar >= line); if (dollar != line) { str = g_strndup (line, (dollar - line)); ide_source_snippet_parser_do_part_simple (parser, str); g_free (str); line = dollar; } parse_dollar: inner = NULL; if (!parse_variable (line, &n, &inner, &line, &name)) { ide_source_snippet_parser_do_part_simple (parser, line); return; } #if 0 g_printerr ("Parse Variable: N=%d inner=\"%s\"\n", n, inner); g_printerr (" Left over: \"%s\"\n", line); #endif ide_source_snippet_parser_flush_chunk (parser); if (inner) { ide_source_snippet_parser_do_part_n (parser, n, inner); g_free (inner); inner = NULL; } else if (n == -2 && name) ide_source_snippet_parser_do_part_named (parser, name); else ide_source_snippet_parser_do_part_linked (parser, n); g_free (name); if (line) { if (*line == '$') { goto parse_dollar; } else goto again; } }
/* * DO statement * Handles DO;, DO CASE, DO WHILE, and iterative DO */ void parse_do(TOKEN *first_token) { TOKEN token; int token_class; int case_line; char case_statement[MAX_TOKEN_LENGTH]; char case_output[MAX_CASE_STATEMENT_SIZE]; char var_string[MAX_TOKEN_LENGTH]; char *temp_out_string, *temp_out_string1; DECL_MEMBER *var_decl; DECL_ID *var_decl_id; /* Create new context */ new_context(DO, (TOKEN *) NULL); out_white_space(first_token); /* Determine what kind of DO statement */ token_class = get_token(&token); switch (token_class) { case END_OF_LINE : /* DO; */ out_white_space(&token); out_char('{'); /* } for dumb vi */ parse_to_end(); break; case IDENTIFIER : /* DO counter = start TO limit BY step */ out_str("for"); out_must_white(&token); out_char('('); /* Put full variable in var_string */ var_string[0] = '\0'; temp_out_string = out_string; out_string = var_string; token_class = parse_variable(&token, &var_decl, &var_decl_id); out_string = temp_out_string; /* Check for '=' */ if ((token_class != OPERATOR) || (token.token_type != EQUAL)) { parse_error("Missing '='"); pop_context(); return; } /* Send <ident> '=' <expr> */ out_str(var_string); out_token(&token); token_class = parse_expression(&token); if ((token_class != RESERVED) || (token.token_type != TO)) { parse_error("Missing TO"); pop_context(); return; } /* Send <ident> <= <limit> */ out_str("; "); out_str(var_string); out_str(" <="); token_class = parse_expression(&token); out_str("; "); /* Parse increment */ if ((token_class == RESERVED) && (token.token_type == BY)) { /* Send <ident> += <step> */ out_str(var_string); out_str(" +="); token_class = parse_expression(&token); } else { /* Send <ident>++ */ out_str(var_string); out_str("++"); } out_str(") {"); /* } for dumb vi */ out_white_space(&token); if (token_class != END_OF_LINE) { parse_error("BY or ';' expected"); pop_context(); return; } parse_to_end(); break; case RESERVED : switch (token.token_type) { case CASE : /* DO CASE <expr>; */ out_str("switch ("); if (parse_expression(&token) != END_OF_LINE) { parse_error("';' expected"); pop_context(); return; } out_white_space(&token); out_str(") {"); /* } for dumb vi */ case_line = 0; while (1) { /* Place case statement in out_string */ temp_out_string1 = out_string; case_output[0] = '\0'; out_string = case_output; (void) snprintf(case_statement, sizeof(case_statement), "case %d :", case_line++); token_class = parse_new_statement(); if (token_class == END_OF_FILE) { parse_error("Premature end-of-file"); exit(1); } if (token_class == END) { out_string = temp_out_string1; out_str(case_output); break; } out_string = temp_out_string1; out_white_space(first_token); out_str(case_statement); out_str(case_output); out_white_space(first_token); out_str("break;\n"); } break; case WHILE : /* DO WHILE <expr>; */ out_str("while ("); if (parse_expression(&token) != END_OF_LINE) { parse_error("';' expected"); pop_context(); return; } out_white_space(&token); out_str(") {"); /* } for dumb vi */ parse_to_end(); break; default: parse_error("Illegal DO clause"); pop_context(); return; } break; } /* End of context */ pop_context(); }
/* * Parse statement starting with an identifier. * Possibilities include: * Assignment * Procedure statement */ void parse_identifier(TOKEN *first_token) { TOKEN token, next_token; TOKEN param_token, attrib_token, type_token; int token_class, next_token_class; DECL *decl_list, *extra_decl_list; PARAM_LIST *param_list, *param_ptr; DECL_MEMBER *decl_ptr; DECL_ID *decl_id; BOOLEAN extern_proc, got_type, interrupt_proc; char *tmp_text_ptr; /* Check for label or procedure */ tmp_text_ptr = text_ptr; token_class = get_token(&token); if (token_class == LABEL) { /* Determine if label or procedure definition */ next_token_class = get_token(&next_token); if ((next_token_class == RESERVED) && (next_token.token_type == PROCEDURE)) { /* * Procedure - Check for parameter list */ param_list = NULL; token_class = get_token(¶m_token); if (token_class == LEFT_PAREN) { /* Yes - get parameter list */ get_param_list(¶m_list); /* Get token after parameter list */ token_class = get_token(&attrib_token); } else /* No param list - save as attribute */ token_copy(¶m_token, &attrib_token); out_white_space(first_token); extern_proc = FALSE; interrupt_proc = FALSE; got_type = (token_class == RESERVED) && (attrib_token.token_type >= BYTE) && (attrib_token.token_type <= SELECTOR); if (got_type) { /* * Process [ <type> ] */ token_copy(&attrib_token, &type_token); token_class = get_token(&attrib_token); } while (token_class == RESERVED) { if (attrib_token.token_type == INTERRUPT) { /* * Process [ <interrupt> ] */ interrupt_proc = TRUE; token_class = get_token(&attrib_token); if (token_class == NUMERIC) /* Interrupt number */ token_class = get_token(&attrib_token); } else /* * Process [ EXTERNAL | { [ PUBLIC ] [ REENTRANT ] } ] */ if (attrib_token.token_type == EXTERNAL) { out_str("extern"); out_must_white(&attrib_token); extern_proc = TRUE; token_class = get_token(&attrib_token); } else if ((attrib_token.token_type == PUBLIC) || (attrib_token.token_type == REENTRANT)) { do { if (attrib_token.token_type == PUBLIC) { /* Ignore for now */ token_class = get_token(&attrib_token); } else if (attrib_token.token_type == REENTRANT) { /* Ignore for now */ token_class = get_token(&attrib_token); } else break; } while (token_class == RESERVED); } else break; } if (token_class != END_OF_LINE) { parse_error("';' expected"); return; } if (interrupt_proc && !extern_proc) parse_warning("INTERRUPT procedure declared"); /* Create declaration for procedure */ get_element_ptr(&decl_ptr); get_var_ptr(&decl_ptr->name_list); /* Type = PROCEDURE */ get_token_ptr(&decl_ptr->type); token_copy(&next_token, decl_ptr->type); /* Name = procedure name */ get_token_ptr(&decl_ptr->name_list->name); token_copy(first_token, decl_ptr->name_list->name); /* Flag if parameter list */ if (param_list) decl_ptr->initialization = DATA; /* Add it to context */ add_to_context(decl_ptr); if (got_type) { /* Output procedure type */ out_token_name(&type_token); out_must_white(&type_token); } /* Output procedure name */ out_token_name(first_token); if (extern_proc) { out_str("()"); if (param_list) /* Parse parameter declarations */ parse_param_list(param_list, &decl_list, &extra_decl_list); out_char(';'); /* Eat closing 'END [<proc name>];' */ token_class = get_token(&token); if ((token_class != RESERVED) || (token.token_type != END)) { parse_error("END expected"); return; } out_white_space(&token); token_class = get_token(&token); if (token_class == IDENTIFIER) { token_class = get_token(&token); } if (token_class != END_OF_LINE) { parse_error("';' expected"); } return; } else if (param_list) { out_token(¶m_token); /* Output parameter list */ param_ptr = param_list; while (param_ptr) { out_token(¶m_ptr->param); param_ptr = param_ptr->next_param; if (param_ptr) out_char(','); } out_char(')'); /* Parse parameter declarations */ parse_param_list(param_list, &decl_list, &extra_decl_list); /* Output declarations */ if (decl_list) { out_decl(decl_list); /* Add declarations to context */ add_decl_to_context(decl_list); } out_str("\n{"); /* } for dumb vi */ if (extra_decl_list) { out_decl(extra_decl_list); /* Add declarations to context */ add_decl_to_context(extra_decl_list); } /* Discard declarations */ free_decl(decl_list); free_decl(extra_decl_list); } else /* No parameter list */ out_str("()\n{"); /* } for dumb vi */ /* Create new context */ new_context(PROCEDURE, first_token); /* Parse statements to END */ parse_to_end(); /* Pop procedure context */ pop_context(); } else { /* * Label - add label name */ out_token(first_token); /* Add colon */ out_token(&token); /* Is this a defined label or a module? */ if (find_symbol(first_token, &decl_ptr, &decl_id)) { if (decl_ptr->type->token_class == LABEL) { /* Label - new context */ new_context(MODULE, first_token); parse_statement(&next_token); pop_context(); } else { parse_error("Illegal label name"); return; } } else parse_statement(&next_token); } return; } /* Assignment statement */ text_ptr = tmp_text_ptr; token_copy(first_token, &token); token_class = parse_variable(&token, &decl_ptr, &decl_id); /* Check for multiple assignments */ while (token_class == COMMA) { /* Print ' =' instead of ',' */ out_str(" ="); out_white_space(&token); /* Get identifier part of next assignment variable */ token_class = get_token(&token); if (token_class != IDENTIFIER) { parse_error("Illegal assignment"); return; } /* Parse remainder of variable (if any) */ token_class = parse_variable(&token, &decl_ptr, &decl_id); } if (token_class == OPERATOR) { if (token.token_type != EQUAL) { parse_error("Illegal use of identifier"); return; } out_token(&token); /* Check for POINTER assignment */ if (decl_ptr->type->token_type == POINTER) { /* Yes - cast it */ out_str(" ("); out_str(TYPE_POINTER); out_str(" *) "); } if (parse_expression(&token) != END_OF_LINE) parse_error("';' expected"); else out_token(&token); return; } else if (token_class != LABEL) { parse_error("Illegal use of identifier"); return; } }
static atom_p parse_list(parsebuf_p pb, expression_callback_t out, int indentation) { int c, i, terminator; atom_p first, prev, curr; struct __operator * operator; parsebuf_t buf; DEBUG(); // Grab the opening parenthesis, or whatever it is __consume_whitespace(pb); __parsebuf_snapshot(pb, &buf); if((c = __parsebuf_next(pb)) == '(') { terminator = ')'; } else if(c == '[') { terminator = ']'; } else if(c == '<') { terminator = '>'; } else if(c == '{') { terminator = '}'; } else { splinter_error_return(NULL, "%s invalid list opening @ %d:%d", buf.n, buf.l, buf.c); } __consume_whitespace(pb); if ((operator = __find_closest_token(pb, terminator)) == NULL) return NULL; __parse_out_indentation(out, indentation); __parse_out_char(out, c); __parse_out_string(out, operator->token, (int)strlen(operator->token)); for(first = prev = curr = NULL; 1;) { __consume_whitespace(pb); i = pb->i; __parse_out_char(out, '\n'); if((c = __parsebuf_next(pb)) <= 0) { splinter_error_set("%s missing list closing @ %d:%d", buf.n, pb->l, pb->c); return atom_free(first); } else if(c == terminator) { if ((curr = atom_alloc_list(operator->exec_call, first)) == NULL) { return atom_free(first); } __parse_out_indentation(out, indentation); __parse_out_char(out, terminator); return curr; } else if(c == '0' && (__parsebuf_peek(pb) == 'x' || __parsebuf_peek(pb) == 'X')) { __parsebuf_prev(pb); curr = parse_hex(pb, operator->mode); if (curr != NULL) __parse_out_line(out, pb->s + i, pb->i - i, indentation + 2); } else if('0' <= c && c <= '9') { __parsebuf_prev(pb); curr = (c == '0') ? parse_oct(pb, operator->mode) : parse_uint(pb, operator->mode); if (curr != NULL) __parse_out_line(out, pb->s + i, pb->i - i, indentation + 2); } else if(c == '-' && ('0' <= __parsebuf_peek(pb) && __parsebuf_peek(pb) <= '9')) { __parsebuf_prev(pb); curr = parse_int(pb, operator->mode); if (curr != NULL) __parse_out_line(out, pb->s + i, pb->i - i, indentation + 2); } else if(c == '(' || c == '[' || c == '<' || c == '{') { __parsebuf_prev(pb); curr = parse_list(pb, out, indentation + 2); } else if(c == '\'') { curr = parse_string(pb, '\'', operator->mode); if (curr != NULL) __parse_out_line(out, pb->s + i, pb->i - i, indentation + 2); } else if(c == '"') { curr = parse_string(pb, '"', operator->mode); if (curr != NULL) __parse_out_line(out, pb->s + i, pb->i - i, indentation + 2); } else if (c == '$') { __parsebuf_prev(pb); curr = parse_variable(pb, terminator, operator->mode); if (curr != NULL) __parse_out_line(out, (char *)curr->data, strlen((char *)curr->data), indentation + 2); } else if (c == '@') { __parsebuf_prev(pb); curr = parse_symbol(pb, terminator, operator->mode); if (curr != NULL) __parse_out_line(out, pb->s + i, pb->i - i, indentation + 2); } else { curr = NULL; } if(curr == NULL) { return atom_free(first); } if(first == NULL) { first = prev = curr; } else { prev->next = curr; prev = curr; } } }
int cmd_t_test (struct lexer *lexer, struct dataset *ds) { bool ok; const struct dictionary *dict = dataset_dict (ds); struct tt tt; int mode_count = 0; /* Variables pertaining to the paired mode */ const struct variable **v1 = NULL; size_t n_v1; const struct variable **v2 = NULL; size_t n_v2; size_t n_pairs = 0; vp *pairs = NULL; /* One sample mode */ double testval = SYSMIS; /* Independent samples mode */ const struct variable *gvar; union value gval0; union value gval1; bool cut = false; tt.wv = dict_get_weight (dict); tt.dict = dict; tt.confidence = 0.95; tt.exclude = MV_ANY; tt.missing_type = MISS_ANALYSIS; tt.n_vars = 0; tt.vars = NULL; tt.mode = MODE_undef; lex_match (lexer, T_EQUALS); for (; lex_token (lexer) != T_ENDCMD; ) { lex_match (lexer, T_SLASH); if (lex_match_id (lexer, "TESTVAL")) { mode_count++; tt.mode = MODE_SINGLE; lex_match (lexer, T_EQUALS); lex_force_num (lexer); testval = lex_number (lexer); lex_get (lexer); } else if (lex_match_id (lexer, "GROUPS")) { mode_count++; cut = false; tt.mode = MODE_INDEP; lex_match (lexer, T_EQUALS); if (NULL == (gvar = parse_variable (lexer, dict))) goto parse_failed; if (lex_match (lexer, T_LPAREN)) { value_init (&gval0, var_get_width (gvar)); parse_value (lexer, &gval0, gvar); cut = true; if (lex_match (lexer, T_COMMA)) { value_init (&gval1, var_get_width (gvar)); parse_value (lexer, &gval1, gvar); cut = false; } lex_force_match (lexer, T_RPAREN); } else { value_init (&gval0, 0); value_init (&gval1, 0); gval0.f = 1.0; gval1.f = 2.0; cut = false; } if ( cut == true && var_is_alpha (gvar)) { msg (SE, _("When applying GROUPS to a string variable, two " "values must be specified.")); goto parse_failed; } } else if (lex_match_id (lexer, "PAIRS")) { bool with = false; bool paired = false; if (tt.n_vars > 0) { msg (SE, _("VARIABLES subcommand may not be used with PAIRS.")); goto parse_failed; } mode_count++; tt.mode = MODE_PAIRED; lex_match (lexer, T_EQUALS); if (!parse_variables_const (lexer, dict, &v1, &n_v1, PV_NO_DUPLICATE | PV_NUMERIC)) goto parse_failed; if ( lex_match (lexer, T_WITH)) { with = true; if (!parse_variables_const (lexer, dict, &v2, &n_v2, PV_NO_DUPLICATE | PV_NUMERIC)) goto parse_failed; if (lex_match (lexer, T_LPAREN) && lex_match_id (lexer, "PAIRED") && lex_match (lexer, T_RPAREN)) { paired = true; if (n_v1 != n_v2) { msg (SE, _("PAIRED was specified but the number of variables " "preceding WITH (%zu) did not match the number " "following (%zu)."), n_v1, n_v2); goto parse_failed; } } } { int i; if ( !with ) n_pairs = (n_v1 * (n_v1 - 1)) / 2.0; else if ( paired ) n_pairs = n_v1; else n_pairs = n_v1 * n_v2; pairs = xcalloc (n_pairs, sizeof *pairs); if ( with) { int x = 0; if (paired) { for (i = 0 ; i < n_v1; ++i) { vp *pair = &pairs[i]; (*pair)[0] = v1[i]; (*pair)[1] = v2[i]; } } else { for (i = 0 ; i < n_v1; ++i) { int j; for (j = 0 ; j < n_v2; ++j) { vp *pair = &pairs[x++]; (*pair)[0] = v1[i]; (*pair)[1] = v2[j]; } } } } else { int x = 0; for (i = 0 ; i < n_v1; ++i) { int j; for (j = i + 1 ; j < n_v1; ++j) { vp *pair = &pairs[x++]; (*pair)[0] = v1[i]; (*pair)[1] = v1[j]; } } } } } else if (lex_match_id (lexer, "VARIABLES")) { if ( tt.mode == MODE_PAIRED) { msg (SE, _("VARIABLES subcommand may not be used with PAIRS.")); goto parse_failed; } lex_match (lexer, T_EQUALS); if (!parse_variables_const (lexer, dict, &tt.vars, &tt.n_vars, PV_NO_DUPLICATE | PV_NUMERIC)) goto parse_failed; } else if ( lex_match_id (lexer, "MISSING")) { lex_match (lexer, T_EQUALS); while (lex_token (lexer) != T_ENDCMD && lex_token (lexer) != T_SLASH) { if (lex_match_id (lexer, "INCLUDE")) { tt.exclude = MV_SYSTEM; } else if (lex_match_id (lexer, "EXCLUDE")) { tt.exclude = MV_ANY; } else if (lex_match_id (lexer, "LISTWISE")) { tt.missing_type = MISS_LISTWISE; } else if (lex_match_id (lexer, "ANALYSIS")) { tt.missing_type = MISS_ANALYSIS; } else { lex_error (lexer, NULL); goto parse_failed; } lex_match (lexer, T_COMMA); } } else if (lex_match_id (lexer, "CRITERIA")) { lex_match (lexer, T_EQUALS); if ( lex_force_match_id (lexer, "CIN")) if ( lex_force_match (lexer, T_LPAREN)) { lex_force_num (lexer); tt.confidence = lex_number (lexer); lex_get (lexer); lex_force_match (lexer, T_RPAREN); } } else { lex_error (lexer, NULL); goto parse_failed; } } if ( mode_count != 1) { msg (SE, _("Exactly one of TESTVAL, GROUPS and PAIRS subcommands " "must be specified.")); goto parse_failed; } if (tt.n_vars == 0 && tt.mode != MODE_PAIRED) { lex_sbc_missing ("VARIABLES"); goto parse_failed; } /* Deal with splits etc */ { struct casereader *group; struct casegrouper *grouper = casegrouper_create_splits (proc_open (ds), dict); while (casegrouper_get_next_group (grouper, &group)) { if ( tt.mode == MODE_SINGLE) { if ( tt.missing_type == MISS_LISTWISE ) group = casereader_create_filter_missing (group, tt.vars, tt.n_vars, tt.exclude, NULL, NULL); one_sample_run (&tt, testval, group); } else if ( tt.mode == MODE_PAIRED) { if ( tt.missing_type == MISS_LISTWISE ) { group = casereader_create_filter_missing (group, v1, n_v1, tt.exclude, NULL, NULL); group = casereader_create_filter_missing (group, v2, n_v2, tt.exclude, NULL, NULL); } paired_run (&tt, n_pairs, pairs, group); } else /* tt.mode == MODE_INDEP */ { if ( tt.missing_type == MISS_LISTWISE ) { group = casereader_create_filter_missing (group, tt.vars, tt.n_vars, tt.exclude, NULL, NULL); group = casereader_create_filter_missing (group, &gvar, 1, tt.exclude, NULL, NULL); } indep_run (&tt, gvar, cut, &gval0, &gval1, group); } } ok = casegrouper_destroy (grouper); ok = proc_commit (ds) && ok; } free (pairs); free (v1); free (v2); free (tt.vars); return ok ? CMD_SUCCESS : CMD_FAILURE; parse_failed: return CMD_FAILURE; }
static xtk_widget_t* create_skinned_list(xtk_widget_t *win, skin_t *skin, tcconf_section_t *sec, tchash_table_t *parameters) { int x, y; int width, height; int i=0; char *action = NULL; widget_data_t *wd = tcallocdz(sizeof(*wd), NULL, widgetdata_free); xtk_widget_t *l; int disable = 0; int alpha = 0xff, calpha = 0xff; char *font, *color, *ccolor = NULL; tcconf_section_t *bfnt = NULL; tcconf_section_t *fig = NULL; int rows, spacing; int xs, ys; i += tcconf_getvalue(sec, "position", "%d %d", &x, &y); i += tcconf_getvalue(sec, "size", "%d %d", &width, &height); if((bfnt = tcconf_getsection(sec, "bitmap"))){ tcconf_setvalue(bfnt, "path", "%s", skin->path); i++; } else if(tcconf_getvalue(sec, "font", "%s", &font) == 1){ i++; } i += tcconf_getvalue(sec, "color", "%s %d", &color, &alpha) > 0; i += tcconf_getvalue(sec, "spacing", "%d", &spacing); i += tcconf_getvalue(sec, "rows", "%d", &rows); if(i != 8){ return NULL; } tcconf_getvalue(sec, "current-color", "%s %d", &ccolor, &calpha); fig = tcconf_getsection(sec, "background_figure"); tcconf_getvalue(sec, "action", "%s", &action); wd->action = action; wd->skin = tcref(skin); wd->values = calloc(1, sizeof(char *)); l = xtk_widget_list_create(win, x, y, width, height); if(tcconf_getvalue(sec, "scroll", "%d %d", &xs, &ys) == 2) { xtk_widget_list_set_scroll(l, xs, ys); } if(fig != NULL) { tcconf_setvalue(fig, "position", "%d %d", 0, 0); tcconf_setvalue(fig, "size", "%d %d", width, height); image_t *img = draw_figure(fig); xtk_widget_list_set_image(l, img); tcfree(img); tcfree(fig); } xtk_widget_list_set_data(l, wd); xtk_widget_list_set_action(l, lookup_action); if(l) { void *c = NULL; char *value, *variable; if(bfnt){ xtk_widget_list_set_bitmapfont(l, bfnt); tcfree(bfnt); } else { xtk_widget_list_set_font(l, font); free(font); } xtk_widget_list_set_color(l, color, alpha); free(color); if(ccolor) { xtk_widget_list_set_current_color(l, ccolor, calpha); free(ccolor); } xtk_widget_list_set_spacing(l, spacing); xtk_widget_list_set_rows(l, rows); while(i = tcconf_nextvalue(sec, "value", &c, "%s %s", &variable, &value), c) { if(i == 2) { if(strcmp(variable, "current_position") == 0) { int *val = NULL, *def = NULL; int p; save_varcb(l, list_set_current, "integer", value); register_varwidget(l, list_set_current, "integer", value); parse_variable("integer", value, (void *)&val, (void *)&def); if(!val) { if(def) { p = *def; tcfree(def); } val = &p; } list_set_current(l, val); } else if(strcmp(variable, "number_of_entries") == 0) { int *val = NULL, *def = NULL; int p; save_varcb(l, list_set_number_of_entries, "integer", value); register_varwidget(l, list_set_number_of_entries, "integer", value); parse_variable("integer", value, (void *)&val, (void *)&def); if(!val) { if(def) { p = *def; tcfree(def); } val = &p; } list_set_number_of_entries(l, val); } else if(strcmp(variable, "entries") == 0) { void *val = NULL; save_varcb(l, list_set_entries, "string_array", value); register_varwidget(l, list_set_entries, "string_array", value); parse_variable("string_array", value, &val, NULL); if(val) { list_set_entries(l, val); tcfree(val); } } free(value); free(variable); } } l->on_destroy = destroy_skinned_list; if(disable) xtk_widget_disable(l); } return l; }
int git_config_parse( git_config_parser *parser, git_config_parser_section_cb on_section, git_config_parser_variable_cb on_variable, git_config_parser_comment_cb on_comment, git_config_parser_eof_cb on_eof, void *data) { git_parse_ctx *ctx; char *current_section = NULL, *var_name, *var_value; int result = 0; ctx = &parser->ctx; skip_bom(ctx); for (; ctx->remain_len > 0; git_parse_advance_line(ctx)) { const char *line_start = parser->ctx.line; size_t line_len = parser->ctx.line_len; char c; if (git_parse_peek(&c, ctx, GIT_PARSE_PEEK_SKIP_WHITESPACE) < 0 && git_parse_peek(&c, ctx, 0) < 0) continue; switch (c) { case '[': /* section header, new section begins */ git__free(current_section); current_section = NULL; if ((result = parse_section_header(parser, ¤t_section)) == 0 && on_section) { result = on_section(parser, current_section, line_start, line_len, data); } break; case '\n': /* comment or whitespace-only */ case ' ': case '\t': case ';': case '#': if (on_comment) { result = on_comment(parser, line_start, line_len, data); } break; default: /* assume variable declaration */ if ((result = parse_variable(parser, &var_name, &var_value)) == 0 && on_variable) { result = on_variable(parser, current_section, var_name, var_value, line_start, line_len, data); } break; } if (result < 0) goto out; } if (on_eof) result = on_eof(parser, current_section, data); out: git__free(current_section); return result; }
int process_POST(unsigned short data_index, unsigned short data_len) { int i=0; int j; char value[200]; char to[50], subject[50], message[200]; #if debug_web_processpost printf("POST: DataIndex %d - Data Len %d\r\n", data_index, data_len); #endif while(i < data_len) { if (rx_buf[data_index+i]=='\r') { if (rx_buf[data_index+i+1]=='\n' && rx_buf[data_index+i+2]=='\r' && rx_buf[data_index+i+3]=='\n') { i += 4; break; }else { i += 4; } }else { i++; } } #if debug_web_processpost j = i; printf("POST data: "); while(j < data_len) { printf("%c", rx_buf[data_index+j]); j++; } printf("\r\n"); #endif if (parse_variable(&rx_buf[data_index+i], "mail", data_len-i, value)) { if (!memcmp(value, "Send", 4)) { if (parse_variable(&rx_buf[data_index+i], "to", data_len-i, value)) { strcpy(to, value); } if (parse_variable(&rx_buf[data_index+i], "subject", data_len-i, value)) { strcpy(subject, value); } if (parse_variable(&rx_buf[data_index+i], "message", data_len-i, value)) { memcpy(message,value,200); } // smtp_sendmail(to, subject, message,0,0); return 1; } } #if 1 if (parse_variable(&rx_buf[data_index+i], "options", data_len-i, value)) { if (!strcmp(value, "Start")) { if (state == STOP) { state = STARTED; app_process(); } } cycle = 0; if (parse_variable(&rx_buf[data_index+i], "cycle", data_len-i, value)) { if (!strcmp(value, "Cycle")) cycle = 1; } autorefresh = 0; if (parse_variable(&rx_buf[data_index+i], "autorefresh", data_len-i, value)) { if (!strcmp(value, "Autorefresh")) autorefresh = 1; } if (parse_variable(&rx_buf[data_index+i], "refreshtime", data_len-i, value)) { if (value[1]==0) { value[1] = value[0]; value[0] = 0x30; } refreshtime = (value[0]-0x30)*10 + (value[1]-0x30); } return 1; } if (parse_variable(&rx_buf[data_index+i], "send", data_len-i, value)) { if (!memcmp(value, "Cancel", 6)) return 0; } led_enable = 0; if (parse_variable(&rx_buf[data_index+i], "led", data_len-i, value)) { if (!strcmp(value, "on")) { led_enable = 1; ledappOn(); printf("jack lee led on\n"); } else { ledappOff(); printf("jack lee led off\n"); } } if (parse_variable(&rx_buf[data_index+i], "dow", data_len-i, value)) { for(j=0;j<7;j++) { if (strcmp(dow[j],value)==0) { DOW = j; break; } } } if (parse_variable(&rx_buf[data_index+i], "month", data_len-i, value)) { for(j=0;j<12;j++) { if (strcmp(month[j],value)==0) { MONTH = j+1; break; } } } if (parse_variable(&rx_buf[data_index+i], "dom", data_len-i, value)) { DOM = (value[0]-0x30)*10 + (value[1]-0x30); } if (parse_variable(&rx_buf[data_index+i], "year", data_len-i, value)) { YEAR = (value[0]-0x30)*1000 + (value[1]-0x30)*100 + (value[2]-0x30)*10 + (value[3]-0x30); } if (parse_variable(&rx_buf[data_index+i], "hour", data_len-i, value)) { HOUR = (value[0]-0x30)*10 + (value[1]-0x30); } if (parse_variable(&rx_buf[data_index+i], "min", data_len-i, value)) { MIN = (value[0]-0x30)*10 + (value[1]-0x30); } if (parse_variable(&rx_buf[data_index+i], "sec", data_len-i, value)) { SEC = (value[0]-0x30)*10 + (value[1]-0x30); } #endif return 1; }
/** parse_assignment parse an assignment statement. * * NOTE: * Just calls parse_variable; This is because expressions are fully * recursive. * * @param p_target_id : ptr to target id's symbol table node * @return ptr to the p_target_id type object. */ cx_type *cx_parser::parse_assignment(const cx_symtab_node *p_target_id) { cx_type *p_target_type = parse_variable(p_target_id); return p_target_type; }
main() { char buf[256]; while (gets(buf)) parse_variable(buf); }
static xtk_widget_t* create_skinned_seek_bar(xtk_widget_t *win, skin_t *skin, tcconf_section_t *sec, tchash_table_t *parameters) { int x, y; int sp_x, sp_y; int ep_x, ep_y; int xd=0, yd=0, sx=0, sy=0; char *bg, *indicator, *value, *variable, *ind_over = NULL, *ind_down = NULL; int i=0; char *action = NULL; widget_data_t *wd = tcallocdz(sizeof(*wd), NULL, widgetdata_free); double *position = NULL, *def = NULL, p=0, snap; xtk_widget_t *s; int disable = 0; image_t *img; i += tcconf_getvalue(sec, "position", "%d %d", &x, &y); i += tcconf_getvalue(sec, "start_position", "%d %d", &sp_x, &sp_y); i += tcconf_getvalue(sec, "end_position", "%d %d", &ep_x, &ep_y); i += tcconf_getvalue(sec, "background", "%s", &bg); i += tcconf_getvalue(sec, "indicator", "%s", &indicator); i += tcconf_getvalue(sec, "value", "%s %s", &variable, &value); if(i != 10){ return NULL; } tcconf_getvalue(sec, "action", "%s", &action); tcconf_getvalue(sec, "mouse_over", "%s", &ind_over); tcconf_getvalue(sec, "pressed", "%s", &ind_down); tcconf_getvalue(sec, "scroll_direction", "%d %d %d %d", &xd, &yd, &sx, &sy); parse_variable("double", value, (void *)&position, (void *)&def); if(!position) { if(def) { p = *def; tcfree(def); } position = &p; } else if(*position < 0 || *position > 1) { disable = 1; } wd->action = action; wd->value = value; wd->skin = tcref(skin); img = load_image(skin->path, bg); s = xtk_widget_slider_create(win, x, y, img->params.width[0], img->params.height[0]); xtk_widget_slider_set_image(s, img); tcfree(img); xtk_widget_slider_set_data(s, wd); xtk_widget_slider_set_action(s, lookup_action); xtk_widget_slider_set_position(s, *position); xtk_widget_slider_set_bounds(s, sp_x, sp_y, ep_x, ep_y); xtk_widget_slider_set_scroll_direction(s, xd, yd, sx, sy); if(tcconf_getvalue(sec, "snap", "%lf", &snap) == 1) { xtk_widget_slider_set_snap(s, snap); } img = load_image(skin->path, indicator); xtk_widget_slider_set_indicator_image(s, img); tcfree(img); img = load_image(skin->path, ind_over); xtk_widget_slider_set_indicator_image_hover(s, img); if(img) tcfree(img); img = load_image(skin->path, ind_down); xtk_widget_slider_set_indicator_image_pressed(s, img); if(img) tcfree(img); if(s) { if(strcmp(variable, "position") == 0) { register_varwidget((xtk_widget_t *)s, seek_bar_update, "double", wd->value); } free(variable); s->on_destroy = destroy_skinned_seek_bar; if(disable) xtk_widget_disable(s); } free(ind_over); free(ind_down); free(indicator); free(bg); return s; }
/* * CALL statement * Handles CALL <procedure name> [ ( <parameter list> ) ] ; */ void parse_call(TOKEN *first_token) { TOKEN token; int token_class; DECL_MEMBER *id_type; DECL_ID *id_id; char *new_func, *tmp_out_string; char func_name[MAX_TOKEN_LENGTH]; /* Get procedure name */ token_class = get_token(&token); if (token_class != IDENTIFIER) { parse_error("Illegal procedure name"); return; } out_white_space(first_token); /* Check for function conversion */ if (check_cvt_id(&token, &cvt_functions[0], &new_func)) { out_str(new_func); token_class = get_token(&token); } else if (find_symbol(&token, &id_type, &id_id) && (id_type->type->token_type != PROCEDURE)) { /* Skip white space */ token.white_space_start = token.white_space_end; /* Check for call to pointer */ func_name[0] = '\0'; tmp_out_string = out_string; out_string = func_name; token_class = parse_variable(&token, &id_type, &id_id); out_string = tmp_out_string; if ((id_type->type->token_type == POINTER) || #ifdef OFFSET (id_type->type->token_type == OFFSET) || #endif (id_type->type->token_type == WORD)) { /* Yes - use pointer reference */ out_str("(*"); out_str(func_name); out_char(')'); } else { parse_error("Illegal procedure reference"); return; } } else { out_token_name(&token); token_class = get_token(&token); } /* Get parameter list (if any) */ if (token_class == LEFT_PAREN) { out_token(&token); do { token_class = parse_expression(&token); out_token(&token); } while (token_class == COMMA); if (token_class == RIGHT_PAREN) /* Get end of line */ check_eol(); else parse_error("Illegal parameter list seperator"); } else if (token_class == END_OF_LINE) { /* No parameter list */ out_str("()"); out_token(&token); } else parse_error("';' expected"); }