STATIC void push_result_rule(parser_t *parser, size_t src_line, const rule_t *rule, size_t num_args) { // optimise away parenthesis around an expression if possible if (rule->rule_id == RULE_atom_paren) { // there should be just 1 arg for this rule mp_parse_node_t pn = peek_result(parser, 0); if (MP_PARSE_NODE_IS_NULL(pn)) { // need to keep parenthesis for () } else if (MP_PARSE_NODE_IS_STRUCT_KIND(pn, RULE_testlist_comp)) { // need to keep parenthesis for (a, b, ...) } else { // parenthesis around a single expression, so it's just the expression return; } } #if MICROPY_COMP_CONST_FOLDING if (fold_logical_constants(parser, rule, &num_args)) { // we folded this rule so return straight away return; } if (fold_constants(parser, rule, num_args)) { // we folded this rule so return straight away return; } #endif mp_parse_node_struct_t *pn = parser_alloc(parser, sizeof(mp_parse_node_struct_t) + sizeof(mp_parse_node_t) * num_args); pn->source_line = src_line; pn->kind_num_nodes = (rule->rule_id & 0xff) | (num_args << 8); for (size_t i = num_args; i > 0; i--) { pn->nodes[i - 1] = pop_result(parser); } push_result_node(parser, (mp_parse_node_t)pn); }
static void subst_list_eval_funcs__(const subst_list_type * subst_list , buffer_type * buffer) { parser_type * parser = parser_alloc( "," , "\"\'" , NULL , " \t" , NULL , NULL ); subst_list_eval_funcs____( subst_list , parser , buffer ); parser_free( parser ); }
static int parse_string_literal(parser_ctx_t *ctx, const WCHAR **ret, WCHAR endch) { const WCHAR *ptr = ++ctx->ptr; WCHAR *wstr; int len; while(ctx->ptr < ctx->end && *ctx->ptr != endch) { if(*ctx->ptr++ == '\\') ctx->ptr++; } if(ctx->ptr == ctx->end) return lex_error(ctx, JS_E_UNTERMINATED_STRING); len = ctx->ptr-ptr; *ret = wstr = parser_alloc(ctx, (len+1)*sizeof(WCHAR)); memcpy(wstr, ptr, (len+1)*sizeof(WCHAR)); wstr[len] = 0; ctx->ptr++; if(!unescape(wstr)) { WARN("unescape failed\n"); return lex_error(ctx, E_FAIL); } return tStringLiteral; }
static literal_t *new_double_literal(parser_ctx_t *ctx, DOUBLE d) { literal_t *ret = parser_alloc(ctx, sizeof(literal_t)); ret->type = LT_DOUBLE; ret->u.dval = d; return ret; }
char * parser_fread_alloc_file_content(const char * filename , const char * quote_set , const char * delete_set , const char * comment_start , const char * comment_end) { parser_type * parser = parser_alloc( NULL , quote_set , NULL , delete_set , comment_start , comment_end); char * buffer = util_fread_alloc_file_content( filename , NULL); parser_strip_buffer( parser , &buffer ); parser_free( parser ); return buffer; }
static literal_t *new_int_literal(parser_ctx_t *ctx, LONG l) { literal_t *ret = parser_alloc(ctx, sizeof(literal_t)); ret->type = LT_INT; ret->u.lval = l; return ret; }
literal_t *new_boolean_literal(parser_ctx_t *ctx, VARIANT_BOOL bval) { literal_t *ret = parser_alloc(ctx, sizeof(literal_t)); ret->type = LT_BOOL; ret->u.bval = bval; return ret; }
literal_t *parse_regexp(parser_ctx_t *ctx) { const WCHAR *re, *flags_ptr; BOOL in_class = FALSE; DWORD re_len, flags; literal_t *ret; HRESULT hres; TRACE("\n"); while(*--ctx->ptr != '/'); /* Simple regexp pre-parser; '/' if used in char class does not terminate regexp literal */ re = ++ctx->ptr; while(ctx->ptr < ctx->end) { if(*ctx->ptr == '\\') { if(++ctx->ptr == ctx->end) break; }else if(in_class) { if(*ctx->ptr == '\n') break; if(*ctx->ptr == ']') in_class = FALSE; }else { if(*ctx->ptr == '/') break; if(*ctx->ptr == '[') in_class = TRUE; } ctx->ptr++; } if(ctx->ptr == ctx->end || *ctx->ptr != '/') { WARN("pre-parsing failed\n"); return NULL; } re_len = ctx->ptr-re; flags_ptr = ++ctx->ptr; while(ctx->ptr < ctx->end && isalnumW(*ctx->ptr)) ctx->ptr++; hres = parse_regexp_flags(flags_ptr, ctx->ptr-flags_ptr, &flags); if(FAILED(hres)) return NULL; ret = parser_alloc(ctx, sizeof(literal_t)); ret->type = LT_REGEXP; ret->u.regexp.str = re; ret->u.regexp.str_len = re_len; ret->u.regexp.flags = flags; return ret; }
STATIC mp_parse_node_t make_node_const_object(parser_t *parser, size_t src_line, mp_obj_t obj) { mp_parse_node_struct_t *pn = parser_alloc(parser, sizeof(mp_parse_node_struct_t) + sizeof(mp_obj_t)); pn->source_line = src_line; #if MICROPY_OBJ_REPR == MICROPY_OBJ_REPR_D // nodes are 32-bit pointers, but need to store 64-bit object pn->kind_num_nodes = RULE_const_object | (2 << 8); pn->nodes[0] = (uint64_t)obj; pn->nodes[1] = (uint64_t)obj >> 32; #else pn->kind_num_nodes = RULE_const_object | (1 << 8); pn->nodes[0] = (uintptr_t)obj; #endif return (mp_parse_node_t)pn; }
STATIC mp_parse_node_t make_node_string_bytes(parser_t *parser, size_t src_line, size_t rule_kind, const char *str, size_t len) { mp_parse_node_struct_t *pn = parser_alloc(parser, sizeof(mp_parse_node_struct_t) + sizeof(mp_parse_node_t) * 2); if (pn == NULL) { parser->parse_error = PARSE_ERROR_MEMORY; return MP_PARSE_NODE_NULL; } pn->source_line = src_line; pn->kind_num_nodes = rule_kind | (2 << 8); char *p = m_new(char, len); memcpy(p, str, len); pn->nodes[0] = (uintptr_t)p; pn->nodes[1] = len; return (mp_parse_node_t)pn; }
ecl_unit_enum ecl_util_get_unit_set(const char * data_file) { ecl_unit_enum units = ECL_METRIC_UNITS; parser_type * parser = parser_alloc(" \t\r\n" , "\"\'" , NULL , NULL , "--" , "\n"); FILE * stream = util_fopen(data_file , "r"); if (parser_fseek_string( parser , stream , "FIELD" , true , true)) { /* Seeks case insensitive. */ units = ECL_FIELD_UNITS; } else if (parser_fseek_string( parser , stream , "LAB" , true , true)) { /* Seeks case insensitive. */ units = ECL_LAB_UNITS; } parser_free( parser ); fclose(stream); return units; }
void ecl_config_set_data_file( ecl_config_type * ecl_config , const char * data_file) { ecl_config->data_file = util_realloc_string_copy( ecl_config->data_file , data_file ); { FILE * stream = util_fopen( ecl_config->data_file , "r"); parser_type * parser = parser_alloc(NULL , NULL , NULL , NULL , "--" , "\n" ); char * init_tag = enkf_util_alloc_tagged_string( "INIT" ); ecl_config->can_restart = parser_fseek_string( parser , stream , init_tag , false , true ); free( init_tag ); parser_free( parser ); fclose( stream ); } ecl_config->start_date = ecl_util_get_start_date( ecl_config->data_file ); ecl_config->num_cpu = ecl_util_get_num_cpu( ecl_config->data_file ); }
int ecl_util_get_num_cpu(const char * data_file) { int num_cpu = 1; parser_type * parser = parser_alloc(" \t\r\n" , "\"\'" , NULL , NULL , "--" , "\n"); FILE * stream = util_fopen(data_file , "r"); if (parser_fseek_string( parser , stream , "PARALLEL" , true , true)) { /* Seeks case insensitive. */ num_cpu = ecl_util_get_num_parallel_cpu__(parser, stream, data_file); } else if (parser_fseek_string( parser , stream , "SLAVES" , true , true)) { /* Seeks case insensitive. */ num_cpu = ecl_util_get_num_slave_cpu__(parser, stream, data_file) + 1; fprintf(stderr, "Information: \"SLAVES\" option found, returning %d number of CPUs", num_cpu); } parser_free( parser ); fclose(stream); return num_cpu; }
static int_vector_type * string_util_sscanf_alloc_active_list(const char * range_string ) { int_vector_type *active_list = NULL; bool valid = valid_characters( range_string ); if (valid) { parser_type * parser = parser_alloc( "," , /* No ordinary split characters. */ NULL , /* No quoters. */ NULL , /* No special split */ " \t" , /* Removing ' ' and '\t' */ NULL , /* No comment */ NULL ); stringlist_type * tokens; int item; active_list = int_vector_alloc(0,0); tokens = parser_tokenize_buffer( parser , range_string , true); for (item = 0; item < stringlist_get_size( tokens ); item++) { const char * string_item = stringlist_iget( tokens , item ); char * pos_ptr = (char *) string_item; int value1 , value2; value1 = strtol( string_item , &pos_ptr , 10); if (*pos_ptr == '\0') // The pos_ptr points to the end of the string, i.e. this was a single digit. value2 = value1; else { // OK - this is a range; skip spaces and the range dash '-' while (isspace(*pos_ptr) || *pos_ptr == '-') pos_ptr++; util_sscanf_int( pos_ptr , &value2); } { int value; for (value = value1; value <= value2; value++) int_vector_append( active_list , value ); } } stringlist_free( tokens ); parser_free( parser ); } return active_list; }
static int parse_identifier(parser_ctx_t *ctx, const WCHAR **ret) { const WCHAR *ptr = ctx->ptr++; WCHAR *wstr; int len; while(ctx->ptr < ctx->end && is_identifier_char(*ctx->ptr)) ctx->ptr++; len = ctx->ptr-ptr; *ret = wstr = parser_alloc(ctx, (len+1)*sizeof(WCHAR)); memcpy(wstr, ptr, (len+1)*sizeof(WCHAR)); wstr[len] = 0; /* FIXME: unescape */ return tIdentifier; }
static int parse_identifier(parser_ctx_t *ctx, const WCHAR **ret) { const WCHAR *ptr = ctx->ptr++; WCHAR *str; int len; while(ctx->ptr < ctx->end && is_identifier_char(*ctx->ptr)) ctx->ptr++; len = ctx->ptr-ptr; str = parser_alloc(ctx, (len+1)*sizeof(WCHAR)); if(!str) return 0; memcpy(str, ptr, (len+1)*sizeof(WCHAR)); str[len] = 0; *ret = str; return tIdentifier; }
static int parse_string_literal(parser_ctx_t *ctx, const WCHAR **ret) { const WCHAR *ptr = ++ctx->ptr; WCHAR *rptr; int len = 0; while(ctx->ptr < ctx->end) { if(*ctx->ptr == '\n') { FIXME("newline inside string literal\n"); return 0; } if(*ctx->ptr == '"') { if(ctx->ptr[1] != '"') break; len--; ctx->ptr++; } ctx->ptr++; } if(ctx->ptr == ctx->end) { FIXME("unterminated string literal\n"); return 0; } len += ctx->ptr-ptr; *ret = rptr = parser_alloc(ctx, (len+1)*sizeof(WCHAR)); if(!rptr) return 0; while(ptr < ctx->ptr) { if(*ptr == '"') ptr++; *rptr++ = *ptr++; } *rptr = 0; ctx->ptr++; return tString; }
time_t ecl_util_get_start_date(const char * data_file) { parser_type * parser = parser_alloc(" \t\r\n" , "\"\'" , NULL , NULL , "--" , "\n"); time_t start_date = -1; FILE * stream = util_fopen(data_file , "r"); char * buffer; if (!parser_fseek_string( parser , stream , "START" , true , true)) /* Seeks case insensitive. */ util_abort("%s: sorry - could not find START in DATA file %s \n",__func__ , data_file); { long int start_pos = util_ftell( stream ); int buffer_size; /* Look for terminating '/' */ if (!parser_fseek_string( parser , stream , "/" , false , true)) util_abort("%s: sorry - could not find \"/\" termination of START keyword in data_file: \n",__func__ , data_file); buffer_size = (util_ftell(stream) - start_pos) ; buffer = util_calloc( buffer_size + 1 , sizeof * buffer ); util_fseek( stream , start_pos , SEEK_SET); util_fread( buffer , sizeof * buffer , buffer_size ,stream , __func__); buffer[buffer_size] = '\0'; } { stringlist_type * tokens = parser_tokenize_buffer( parser , buffer , true ); int day, year, month_nr; if ( util_sscanf_int( stringlist_iget( tokens , 0 ) , &day) && util_sscanf_int( stringlist_iget(tokens , 2) , &year)) { month_nr = ecl_util_get_month_nr(stringlist_iget( tokens , 1)); start_date = ecl_util_make_date(day , month_nr , year ); } else util_abort("%s: failed to parse DAY MONTH YEAR from : \"%s\" \n",__func__ , buffer); stringlist_free( tokens ); } free( buffer ); parser_free( parser ); fclose(stream); return start_date; }
literal_t *parse_regexp(parser_ctx_t *ctx) { const WCHAR *re, *flags_ptr; DWORD re_len, flags; literal_t *ret; HRESULT hres; TRACE("\n"); while(*ctx->ptr != '/') ctx->ptr--; re = ++ctx->ptr; while(ctx->ptr < ctx->end && *ctx->ptr != '/') { if(*ctx->ptr++ == '\\' && ctx->ptr < ctx->end) ctx->ptr++; } if(ctx->ptr == ctx->end) { WARN("unexpected end of file\n"); return NULL; } re_len = ctx->ptr-re; flags_ptr = ++ctx->ptr; while(ctx->ptr < ctx->end && isalnumW(*ctx->ptr)) ctx->ptr++; hres = parse_regexp_flags(flags_ptr, ctx->ptr-flags_ptr, &flags); if(FAILED(hres)) return NULL; ret = parser_alloc(ctx, sizeof(literal_t)); ret->type = LT_REGEXP; ret->u.regexp.str = re; ret->u.regexp.str_len = re_len; ret->u.regexp.flags = flags; return ret; }
static int parse_string_literal(parser_ctx_t *ctx, jsstr_t **ret, WCHAR endch) { const WCHAR *ptr = ++ctx->ptr, *ret_str = ptr; BOOL needs_unescape = FALSE; WCHAR *unescape_str; size_t len; while(ctx->ptr < ctx->end && *ctx->ptr != endch) { if(*ctx->ptr++ == '\\') { ctx->ptr++; needs_unescape = TRUE; } } if(ctx->ptr == ctx->end) return lex_error(ctx, JS_E_UNTERMINATED_STRING); len = ctx->ptr - ptr; ctx->ptr++; if(needs_unescape) { ret_str = unescape_str = parser_alloc(ctx, len * sizeof(WCHAR)); if(!unescape_str) return lex_error(ctx, E_OUTOFMEMORY); memcpy(unescape_str, ptr, len * sizeof(WCHAR)); if(!unescape(unescape_str, &len)) { WARN("unescape failed\n"); return lex_error(ctx, E_FAIL); } } if(!(*ret = compiler_alloc_string_len(ctx->compiler, ret_str, len))) return lex_error(ctx, E_OUTOFMEMORY); /* FIXME: leaking string */ return tStringLiteral; }