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;
}
