Mercurial > octave-dspies

comparison libinterp/parse-tree/oct-parse.in.yy @ 18158:bf638abc95de

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
eliminate constant folding in parser * oct-parse.in.yy (fold): Delete functions and all uses.
author John W. Eaton <jwe@octave.org>
date Fri, 13 Dec 2013 17:24:57 -0500
parents c7b68a11074b
children 69990d5edcc2
comparison
equal deleted inserted replaced
18151:1c22f0465c74 18158:bf638abc95de
1938 "variable switch label near line %d, column %d in file '%s'", 1938 "variable switch label near line %d, column %d in file '%s'",
1939 expr->line (), expr->column (), lexer.fcn_file_full_name.c_str ()); 1939 expr->line (), expr->column (), lexer.fcn_file_full_name.c_str ());
1940 } 1940 }
1941 } 1941 }
1942 1942
1943 static tree_expression *
1944 fold (tree_binary_expression *e)
1945 {
1946 tree_expression *retval = e;
1947
1948 unwind_protect frame;
1949
1950 frame.protect_var (error_state);
1951 frame.protect_var (warning_state);
1952
1953 frame.protect_var (discard_error_messages);
1954 frame.protect_var (discard_warning_messages);
1955
1956 discard_error_messages = true;
1957 discard_warning_messages = true;
1958
1959 tree_expression *op1 = e->lhs ();
1960 tree_expression *op2 = e->rhs ();
1961
1962 if (op1->is_constant () && op2->is_constant ())
1963 {
1964 octave_value tmp = e->rvalue1 ();
1965
1966 if (! (error_state || warning_state))
1967 {
1968 tree_constant *tc_retval
1969 = new tree_constant (tmp, op1->line (), op1->column ());
1970
1971 std::ostringstream buf;
1972
1973 tree_print_code tpc (buf);
1974
1975 e->accept (tpc);
1976
1977 tc_retval->stash_original_text (buf.str ());
1978
1979 delete e;
1980
1981 retval = tc_retval;
1982 }
1983 }
1984
1985 return retval;
1986 }
1987
1988 static tree_expression *
1989 fold (tree_unary_expression *e)
1990 {
1991 tree_expression *retval = e;
1992
1993 unwind_protect frame;
1994
1995 frame.protect_var (error_state);
1996 frame.protect_var (warning_state);
1997
1998 frame.protect_var (discard_error_messages);
1999 frame.protect_var (discard_warning_messages);
2000
2001 discard_error_messages = true;
2002 discard_warning_messages = true;
2003
2004 tree_expression *op = e->operand ();
2005
2006 if (op->is_constant ())
2007 {
2008 octave_value tmp = e->rvalue1 ();
2009
2010 if (! (error_state || warning_state))
2011 {
2012 tree_constant *tc_retval
2013 = new tree_constant (tmp, op->line (), op->column ());
2014
2015 std::ostringstream buf;
2016
2017 tree_print_code tpc (buf);
2018
2019 e->accept (tpc);
2020
2021 tc_retval->stash_original_text (buf.str ());
2022
2023 delete e;
2024
2025 retval = tc_retval;
2026 }
2027 }
2028
2029 return retval;
2030 }
2031
2032 // Finish building a range. 1943 // Finish building a range.
2033 1944
2034 tree_expression * 1945 tree_expression *
2035 octave_base_parser::finish_colon_expression (tree_colon_expression *e) 1946 octave_base_parser::finish_colon_expression (tree_colon_expression *e)
2036 { 1947 {
2082 else 1993 else
2083 { 1994 {
2084 e->preserve_base (); 1995 e->preserve_base ();
2085 delete e; 1996 delete e;
2086 1997
2087 // FIXME -- need to attempt constant folding here
2088 // too (we need a generic way to do that).
2089 retval = base; 1998 retval = base;
2090 } 1999 }
2091 } 2000 }
2092 2001
2093 return retval; 2002 return retval;
2296 } 2205 }
2297 2206
2298 int l = tok_val->line (); 2207 int l = tok_val->line ();
2299 int c = tok_val->column (); 2208 int c = tok_val->column ();
2300 2209
2301 tree_binary_expression *e 2210 return maybe_compound_binary_expression (op1, op2, l, c, t);
2302 = maybe_compound_binary_expression (op1, op2, l, c, t);
2303
2304 return fold (e);
2305 } 2211 }
2306 2212
2307 // Build a boolean expression. 2213 // Build a boolean expression.
2308 2214
2309 tree_expression * 2215 tree_expression *
2328 } 2234 }
2329 2235
2330 int l = tok_val->line (); 2236 int l = tok_val->line ();
2331 int c = tok_val->column (); 2237 int c = tok_val->column ();
2332 2238
2333 tree_boolean_expression *e 2239 return new tree_boolean_expression (op1, op2, l, c, t);
2334 = new tree_boolean_expression (op1, op2, l, c, t);
2335
2336 return fold (e);
2337 } 2240 }
2338 2241
2339 // Build a prefix expression. 2242 // Build a prefix expression.
2340 2243
2341 tree_expression * 2244 tree_expression *
2372 } 2275 }
2373 2276
2374 int l = tok_val->line (); 2277 int l = tok_val->line ();
2375 int c = tok_val->column (); 2278 int c = tok_val->column ();
2376 2279
2377 tree_prefix_expression *e 2280 return new tree_prefix_expression (op1, l, c, t);
2378 = new tree_prefix_expression (op1, l, c, t);
2379
2380 return fold (e);
2381 } 2281 }
2382 2282
2383 // Build a postfix expression. 2283 // Build a postfix expression.
2384 2284
2385 tree_expression * 2285 tree_expression *
2412 } 2312 }
2413 2313
2414 int l = tok_val->line (); 2314 int l = tok_val->line ();
2415 int c = tok_val->column (); 2315 int c = tok_val->column ();
2416 2316
2417 tree_postfix_expression *e 2317 return new tree_postfix_expression (op1, l, c, t);
2418 = new tree_postfix_expression (op1, l, c, t);
2419
2420 return fold (e);
2421 } 2318 }
2422 2319
2423 // Build an unwind-protect command. 2320 // Build an unwind-protect command.
2424 2321
2425 tree_command * 2322 tree_command *