1 29 30 package com.caucho.quercus.lib; 31 32 import com.caucho.quercus.QuercusModuleException; 33 import com.caucho.quercus.annotation.Optional; 34 import com.caucho.quercus.annotation.ReadOnly; 35 import com.caucho.quercus.annotation.Reference; 36 import com.caucho.quercus.annotation.UsesSymbolTable; 37 import com.caucho.quercus.env.*; 38 import com.caucho.quercus.module.AbstractQuercusModule; 39 import com.caucho.util.L10N; 40 import com.caucho.util.LruCache; 41 import com.caucho.vfs.WriteStream; 42 43 import java.io.IOException ; 44 import java.lang.reflect.Method ; 45 import java.util.HashMap ; 46 import java.util.IdentityHashMap ; 47 import java.util.Map ; 48 import java.util.logging.Level ; 49 import java.util.logging.Logger ; 50 51 54 public class VariableModule extends AbstractQuercusModule { 55 private static final Logger log 56 = Logger.getLogger(VariableModule.class.getName()); 57 private static final L10N L = new L10N(VariableModule.class); 58 59 private static final LruCache<StringValue,Value> _unserializeCache 60 = new LruCache<StringValue,Value>(256); 61 62 68 public static Value constant(Env env, String name) 69 { 70 return env.getConstant(name); 71 } 72 73 80 public static Value debug_zval_dump(Env env, @ReadOnly Value v) 81 { 82 try { 83 debug_impl(env, v, 0); 84 85 return NullValue.NULL; 86 } catch (IOException e) { 87 throw new QuercusModuleException(e); 88 } 89 } 90 91 98 public static Value var_dump(Env env, @ReadOnly Value v) 99 { 100 try { 101 if (v == null) 102 env.getOut().print("NULL#java"); 103 else 104 v.varDump(env, env.getOut(), 0, new IdentityHashMap <Value,String >()); 105 106 env.getOut().println(); 107 108 return NullValue.NULL; 109 } catch (IOException e) { 110 throw new QuercusModuleException(e); 111 } 112 } 113 114 121 public static Value define(Env env, 122 String name, 123 Value value, 124 @Optional boolean isCaseInsensitive) 125 { 126 return env.addConstant(name, value, isCaseInsensitive); 127 } 128 129 135 public static boolean defined(Env env, StringValue name) 136 { 137 return env.isDefined(name.toString()); 138 } 139 140 146 public static Value doubleval(@ReadOnly Value v) 147 { 148 return floatval(v); 149 } 150 151 158 public static boolean empty(@ReadOnly Value v) 159 { 160 v = v.toValue(); 161 162 if (v instanceof NullValue) 163 return true; 164 else if (v instanceof StringValue) { 165 String s = v.toString(); 166 167 return (s.equals("") || s.equals("0")); 168 } 169 else if (v instanceof LongValue) { 170 return v.toLong() == 0; 171 } 172 else if (v instanceof BooleanValue) { 173 return ! v.toBoolean(); 174 } 175 else if (v instanceof ArrayValue) { 176 ArrayValue array = (ArrayValue) v; 177 178 return array.getSize() == 0; 179 } 180 else 181 return false; 182 } 183 184 190 public static Value floatval(@ReadOnly Value v) 191 { 192 return new DoubleValue(v.toDouble()); 193 } 194 195 198 @UsesSymbolTable 199 public static Value get_defined_vars(Env env) 200 { 201 ArrayValue result = new ArrayValueImpl(); 202 203 HashMap <String ,Var> map = env.getEnv(); 204 205 for (Map.Entry <String ,Var> entry : map.entrySet()) { 206 result.append(new StringValueImpl(entry.getKey()), 207 entry.getValue().toValue()); 208 } 209 210 HashMap <String ,Var> globalMap = env.getGlobalEnv(); 211 if (map != globalMap) { 212 for (Map.Entry <String ,Var> entry : globalMap.entrySet()) { 213 result.append(new StringValueImpl(entry.getKey()), 214 entry.getValue().toValue()); 215 } 216 } 217 218 return result; 219 } 220 221 224 public static String gettype(@ReadOnly Value v) 225 { 226 return v.getType(); 227 } 228 229 public static Value get_resource_type(Value v) 230 { 231 if (! (v instanceof JavaValue)) 232 return BooleanValue.FALSE; 233 234 Object obj = v.toJavaObject(); 235 236 try { 237 Method m = obj.getClass().getMethod("getResourceType", 238 new Class [0]); 239 240 if (m != null) 241 return StringValue.create(String.valueOf(m.invoke(obj))); 242 } catch (Exception e) { 243 } 244 245 return StringValue.create("Unknown"); 246 } 247 248 254 public static boolean import_request_variables(Env env, 255 String types, 256 @Optional String prefix) 257 { 258 if ("".equals(prefix)) 259 env.notice(L.l("import_request_variables should use a prefix argument")); 260 261 for (int i = 0; i < types.length(); i++) { 262 char ch = types.charAt(i); 263 264 Value value = null; 265 266 if (ch == 'c' || ch == 'C') 267 value = env.getGlobalValue("_COOKIE"); 268 else if (ch == 'g' || ch == 'G') 269 value = env.getGlobalValue("_GET"); 270 else if (ch == 'p' || ch == 'P') 271 value = env.getGlobalValue("_POST"); 272 273 if (! (value instanceof ArrayValue)) 274 continue; 275 276 ArrayValue array = (ArrayValue) value; 277 278 for (Map.Entry <Value,Value> entry : array.entrySet()) { 279 String key = entry.getKey().toString(); 280 281 env.setGlobalValue(prefix + key, 282 array.getRef(entry.getKey())); 283 } 284 } 285 286 return true; 287 } 288 289 295 public static long intval(@ReadOnly Value v) 296 { 297 return v.toLong(); 298 } 299 300 307 public static boolean is_array(@ReadOnly Value v) 308 { 309 return v.isArray(); 310 } 311 312 319 public static Value is_bool(@ReadOnly Value v) 320 { 321 return (v.toValue() instanceof BooleanValue 322 ? BooleanValue.TRUE 323 : BooleanValue.FALSE); 324 } 325 326 333 public static boolean is_scalar(@ReadOnly Value v) 334 { 335 if (v==null) 336 return false; 337 338 Value value = v.toValue(); 339 return 340 value instanceof DoubleValue || 341 value instanceof StringValue || 342 value instanceof LongValue || 343 value instanceof BooleanValue; 344 } 345 346 349 public static boolean is_callable(Env env, 350 Value v, 351 @Optional boolean isSyntaxOnly, 352 @Optional @Reference Value nameRef) 353 { 354 if (v instanceof StringValue) { 355 if (nameRef != null) 356 nameRef.set(v); 357 358 if (isSyntaxOnly) 359 return true; 360 else 361 return env.findFunction(v.toString().intern()) != null; 362 } 363 else if (v instanceof ArrayValue) { 364 Value obj = v.get(LongValue.ZERO); 365 Value name = v.get(LongValue.ONE); 366 367 if (! (name instanceof StringValue)) 368 return false; 369 370 if (nameRef != null) 371 nameRef.set(name); 372 373 if (obj instanceof StringValue) { 374 if (isSyntaxOnly) 375 return true; 376 377 QuercusClass cl = env.findClass(obj.toString().intern()); 378 if (cl == null) 379 return false; 380 381 return (cl.findFunction(name.toString().intern()) != null); 382 } 383 else if (obj.isObject()) { 384 if (isSyntaxOnly) 385 return true; 386 387 return obj.findFunction(name.toString().intern()) != null; 388 } 389 else 390 return false; 391 } 392 else 393 return false; 394 } 395 396 403 public static boolean is_double(@ReadOnly Value v) 404 { 405 return is_float(v); 406 } 407 408 415 public static boolean is_float(@ReadOnly Value v) 416 { 417 return (v.toValue() instanceof DoubleValue); 418 } 419 420 427 public static Value is_int(@ReadOnly Value v) 428 { 429 return (v.toValue() instanceof LongValue 430 ? BooleanValue.TRUE 431 : BooleanValue.FALSE); 432 } 433 434 441 public static Value is_integer(@ReadOnly Value v) 442 { 443 return is_int(v); 444 } 445 446 453 public static Value is_long(@ReadOnly Value v) 454 { 455 return is_int(v); 456 } 457 458 465 public static boolean is_null(@ReadOnly Value v) 466 { 467 return v.isNull(); 468 } 469 470 478 public static boolean is_numeric(Env env, @ReadOnly Value v) 479 { 480 return v.isNumeric(); 481 } 482 483 491 public static boolean is_object(Env env, @ReadOnly Value v) 492 { 493 return v.isObject(); 494 } 495 496 503 public static boolean is_real(@ReadOnly Value v) 504 { 505 return is_float(v); 506 } 507 508 511 public boolean is_resource(@ReadOnly Value value) 512 { 513 return (value.toValue() instanceof ResourceValue); 514 } 515 516 518 521 public boolean is_string(@ReadOnly Value value) 522 { 523 return (value.toValue() instanceof StringValue); 524 } 525 526 529 public static boolean isset(@ReadOnly Value v) 530 { 531 return v.isset(); 532 } 533 534 541 public static Value strval(Env env, @ReadOnly Value v) 542 { 543 if (v instanceof StringValue) 544 return (StringValue) v; 545 else 546 return new StringValueImpl(v.toString()); 547 } 548 549 556 public static Value print_r(Env env, 557 @ReadOnly Value v, 558 @Optional Value isRet) 559 { 560 562 try { 563 WriteStream out = env.getOut(); 564 565 v.printR(env, out, 0, new IdentityHashMap <Value, String >()); 566 567 return BooleanValue.FALSE; 568 } catch (IOException e) { 569 throw new QuercusModuleException(e); 570 } 571 } 572 573 private static void printDepth(WriteStream out, int depth) 574 throws IOException 575 { 576 for (int i = 0; i < depth; i++) 577 out.print(' '); 578 } 579 580 583 public static String serialize(@ReadOnly Value v) 584 { 585 StringBuilder sb = new StringBuilder (); 586 587 v.serialize(sb); 588 589 return sb.toString(); 590 } 591 592 595 public static boolean settype(Env env, 596 @Reference Value var, 597 String type) 598 { 599 Value value = var.toValue(); 600 601 if ("null".equals(type)) { 602 var.set(NullValue.NULL); 603 return true; 604 } 605 else if ("boolean".equals(type) || "bool".equals(type)) { 606 var.set(value.toBoolean() ? BooleanValue.TRUE : BooleanValue.TRUE); 607 return true; 608 } 609 else if ("string".equals(type)) { 610 var.set(new StringValueImpl(value.toString())); 611 return true; 612 } 613 else if ("int".equals(type) || "integer".equals(type)) { 614 var.set(new LongValue(value.toLong())); 615 return true; 616 } 617 else if ("float".equals(type) || "double".equals(type)) { 618 var.set(new DoubleValue(value.toDouble())); 619 return true; 620 } 621 else if ("object".equals(type)) { 622 var.set(value.toObject(env)); 623 return true; 624 } 625 else if ("array".equals(type)) { 626 if (value.isArray()) 627 var.set(value); 628 else 629 var.set(new ArrayValueImpl().append(value)); 630 return true; 631 } 632 else 633 return false; 634 } 635 636 639 public static Value unserialize(Env env, StringValue s) 640 { 641 Value v = _unserializeCache.get(s); 642 643 if (v != null) 644 return v.copy(env); 645 646 try { 647 UnserializeReader is = new UnserializeReader(s); 648 649 v = is.unserialize(env); 650 } catch (Throwable e) { 651 log.log(Level.FINE, e.toString(), e); 652 653 env.notice(e.toString()); 654 655 v = BooleanValue.FALSE; 656 } 657 658 _unserializeCache.put(s, v.copy(env)); 659 660 return v; 661 } 662 663 666 public static Value var_export(Env env, 667 @ReadOnly Value v, 668 @Optional boolean isReturn) 669 { 670 StringBuilder sb = new StringBuilder (); 671 672 v.varExport(sb); 673 674 if (isReturn) 675 return new StringValueImpl(sb.toString()); 676 else { 677 env.print(sb); 678 679 return NullValue.NULL; 680 } 681 } 682 683 private static void debug_impl(Env env, Value v, int depth) 684 throws IOException 685 { 686 WriteStream out = env.getOut(); 687 688 if (v instanceof Var) 689 out.print("&"); 690 691 v = v.toValue(); 692 693 if (v instanceof ArrayValue) { 694 ArrayValue array = (ArrayValue) v; 695 696 out.println("Array"); 697 printDepth(out, 2 * depth); 698 out.println("("); 699 700 for (Map.Entry <Value,Value> mapEntry : array.entrySet()) { 701 ArrayValue.Entry entry = (ArrayValue.Entry) mapEntry; 702 703 printDepth(out, 2 * depth); 704 out.print(" ["); 705 out.print(entry.getKey()); 706 out.print("] => "); 707 debug_impl(env, entry.getValue(), depth + 1); } 709 printDepth(out, 2 * depth); 710 out.println(")"); 711 } 712 else if (v instanceof BooleanValue) { 713 if (v.toBoolean()) 714 out.print("bool(true)"); 715 else 716 out.print("bool(false)"); 717 } 718 else if (v instanceof LongValue) { 719 out.print("int(" + v.toLong() + ")"); 720 } 721 else if (v instanceof DoubleValue) { 722 out.print("float(" + v.toDouble() + ")"); 723 } 724 else if (v instanceof StringValue) { 725 out.print("string(" + v.toString() + ")"); 726 } 727 else if (v instanceof NullValue) { 728 out.print("NULL"); 729 } 730 else { 731 v.print(env); 732 } 733 } 734 } 735 736 | Popular Tags |