[BACK]Return to root.C CVS log [TXT] [DIR] Up to [parser3project] / parser3 / src / classes

Diff for /parser3/src/classes/Attic/root.C between versions 1.28 and 1.31

version 1.28, 2001/03/12 18:19:36 version 1.31, 2001/03/12 21:18:00
Line 7 Line 7
 */  */
   
 #include <string.h>  #include <string.h>
   #include <math.h>
   
 #include "pa_request.h"  #include "pa_request.h"
 #include "_root.h"  #include "_root.h"
   #include "pa_vint.h"
   
 static void _if(Request& r, const String&, Array *params) {  static void _if(Request& r, const String&, Array *params) {
         bool condition=          bool condition=
Line 129  static void _use(Request& r, const Strin Line 131  static void _use(Request& r, const Strin
         r.use_file(r.absolute(file));          r.use_file(r.absolute(file));
 }  }
   
   static void _for(Request& r, const String& method_name, Array *params) {
           // ^for[i;from-number;to-number-inclusive]{code}[delim]
   
           Pool& pool=r.pool();
           const String& var_name=r.process(*static_cast<Value *>(params->get(0))).as_string();
           int from=(int)r.process(*static_cast<Value *>(params->get(1))).get_double();
           int to=(int)r.process(*static_cast<Value *>(params->get(2))).get_double();
           Value& body_code=*static_cast<Value *>(params->get(3));
           // forcing ^menu{this param type}
           r.fail_if_junction_(false, body_code, 
                   method_name, "body must be junction");
           Value *delim_code=params->size()==3+1+1?static_cast<Value *>(params->get(3+1)):0;
   
           bool need_delim=false;
           int endless_loop_count=0;
           for(VInt *vint=new(pool) VInt(pool, from); vint->get_int()<=to; vint->inc()) {
                   if(++endless_loop_count>=2001) // endless loop?
                           R_THROW(0, 0,
                                   &method_name,
                                   "endless loop detected");
                   r.wcontext->put_element(var_name, vint);
   
                   Value& processed_body=r.process(body_code);
                   if(delim_code) { // delimiter set?
                           const String *string=processed_body.get_string();
                           if(need_delim && string && string->size()) // need delim & iteration produced string?
                                   r.write_pass_lang(r.process(*delim_code));
                           need_delim=true;
                   }
                   r.write_pass_lang(processed_body);
           }
   }
   
   
   
   typedef double (*math_one_double_op_func_ptr)(double);
   static double round(double op) { return floor(op+0.5); }
   static double sign(double op) { return op > 0 ? 1 : ( op < 0 ? -1 : 0 ); }
   
   static void _math_one_double_op(
                                                                   Request& r, 
                                                                   const String& method_name, Array *params,
                                                                   math_one_double_op_func_ptr func) {
           Pool& pool=r.pool();
           Value& param=*static_cast<Value *>(params->get(0));
   
           // forcing ^round(this param type)
           r.fail_if_junction_(false, param, 
                   method_name, "parameter must be expression");
   
           Value& result=*new(pool) VDouble(pool, (*func)(r.process(param).get_double()));
           r.wcontext->write(result, String::Untaint_lang::NO /*always object, not string*/);
   }
   
   static void _round(Request& r, const String& method_name, Array *params) {
           _math_one_double_op(r, method_name, params,     &round);
   }
   
   static void _floor(Request& r, const String& method_name, Array *params) {
           _math_one_double_op(r, method_name, params,     &floor);
   }
   
   static void _ceiling(Request& r, const String& method_name, Array *params) {
           _math_one_double_op(r, method_name, params,     &ceil);
   }
   
   static void _abs(Request& r, const String& method_name, Array *params) {
           _math_one_double_op(r, method_name, params,     &fabs);
   }
   
   static void _sign(Request& r, const String& method_name, Array *params) {
           _math_one_double_op(r, method_name, params,     &sign);
   }
   
 void initialize_root_class(Pool& pool, VClass& vclass) {  void initialize_root_class(Pool& pool, VClass& vclass) {
         // ^if(condition){code-when-true}          // ^if(condition){code-when-true}
         // ^if(condition){code-when-true}{code-when-false}          // ^if(condition){code-when-true}{code-when-false}
Line 148  void initialize_root_class(Pool& pool, V Line 224  void initialize_root_class(Pool& pool, V
   
         // ^use[file]          // ^use[file]
         vclass.add_native_method("use", _use, 1, 1);          vclass.add_native_method("use", _use, 1, 1);
   
           // ^for[i;from-number;to-number-inclusive]{code}[delim]
           vclass.add_native_method("for", _for, 3+1, 3+1+1);
   
   
           // math functions
   
           // ^round(expr) 
           vclass.add_native_method("round", _round, 1, 1);
   
           // ^floor(expr) 
           vclass.add_native_method("floor", _floor, 1, 1);
   
           // ^ceiling(expr)       
           vclass.add_native_method("ceiling", _ceiling, 1, 1);
   
           // ^abs(expr)   
           vclass.add_native_method("abs", _abs, 1, 1);
   
           // ^sign(expr)
           vclass.add_native_method("sign", _sign, 1, 1);
 }  }
Removed from v.1.28  
changed lines
  Added in v.1.31

E-mail: