Mercurial Hosting > luan

comparison src/luan/modules/JavaLuan.java @ 1333:25746915a241

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
merge Luan and LuanState
author Franklin Schmidt <fschmidt@gmail.com>
date Tue, 12 Feb 2019 22:33:40 -0700
parents f41919741100
children e0cf0d108a77
comparison
equal deleted inserted replaced
1332:11b7e11f9ed5 1333:25746915a241
16 import java.util.Iterator; 16 import java.util.Iterator;
17 import java.util.Collections; 17 import java.util.Collections;
18 import java.util.Arrays; 18 import java.util.Arrays;
19 import java.util.Comparator; 19 import java.util.Comparator;
20 import luan.Luan; 20 import luan.Luan;
21 import luan.LuanState;
22 import luan.LuanTable; 21 import luan.LuanTable;
23 import luan.LuanException; 22 import luan.LuanException;
24 import luan.LuanFunction; 23 import luan.LuanFunction;
25 import luan.LuanJavaFunction; 24 import luan.LuanJavaFunction;
26 25
27 26
28 public final class JavaLuan { 27 public final class JavaLuan {
29 28
30 public static void java(LuanState luan) throws LuanException { 29 public static void java(Luan luan) throws LuanException {
31 Luan.checkSecurity(luan,"java"); 30 Luan.checkSecurity(luan,"java");
32 luan.peek().javaOk = true; 31 luan.peek().javaOk = true;
33 } 32 }
34 33
35 public static final LuanFunction javaFn; 34 public static final LuanFunction javaFn;
36 static { 35 static {
37 try { 36 try {
38 javaFn = new LuanJavaFunction(JavaLuan.class.getMethod("java",LuanState.class),null); 37 javaFn = new LuanJavaFunction(JavaLuan.class.getMethod("java",Luan.class),null);
39 } catch(NoSuchMethodException e) { 38 } catch(NoSuchMethodException e) {
40 throw new RuntimeException(e); 39 throw new RuntimeException(e);
41 } 40 }
42 } 41 }
43 42
44 private static void checkJava(LuanState luan) throws LuanException { 43 private static void checkJava(Luan luan) throws LuanException {
45 if( !luan.peek().javaOk ) 44 if( !luan.peek().javaOk )
46 throw new LuanException("Java isn't allowed"); 45 throw new LuanException("Java isn't allowed");
47 } 46 }
48 47
49 public static Object __index(LuanState luan,Object obj,Object key) throws LuanException { 48 public static Object __index(Luan luan,Object obj,Object key) throws LuanException {
50 checkJava(luan); 49 checkJava(luan);
51 Class cls; 50 Class cls;
52 if( obj instanceof Static ) { 51 if( obj instanceof Static ) {
53 Static st = (Static)obj; 52 Static st = (Static)obj;
54 cls = st.cls; 53 cls = st.cls;
134 } catch(IllegalAccessException e) { 133 } catch(IllegalAccessException e) {
135 throw new RuntimeException(e); 134 throw new RuntimeException(e);
136 } 135 }
137 } 136 }
138 137
139 public static void __new_index(LuanState luan,Object obj,Object key,Object value) throws LuanException { 138 public static void __new_index(Luan luan,Object obj,Object key,Object value) throws LuanException {
140 checkJava(luan); 139 checkJava(luan);
141 Class cls; 140 Class cls;
142 if( obj instanceof Static ) { 141 if( obj instanceof Static ) {
143 Static st = (Static)obj; 142 Static st = (Static)obj;
144 cls = st.cls; 143 cls = st.cls;
308 307
309 @Override public boolean isSynthetic() { 308 @Override public boolean isSynthetic() {
310 return cls.isSynthetic(); 309 return cls.isSynthetic();
311 } 310 }
312 311
313 public Object luan_proxy(final LuanState luan,final LuanTable t) throws LuanException { 312 public Object luan_proxy(final Luan luan,final LuanTable t) throws LuanException {
314 return Proxy.newProxyInstance( 313 return Proxy.newProxyInstance(
315 cls.getClassLoader(), 314 cls.getClassLoader(),
316 new Class[]{cls}, 315 new Class[]{cls},
317 new InvocationHandler() { 316 new InvocationHandler() {
318 public Object invoke(Object proxy,Method method, Object[] args) 317 public Object invoke(Object proxy,Method method, Object[] args)
332 } 331 }
333 } 332 }
334 private static final Method luan_proxyMethod; 333 private static final Method luan_proxyMethod;
335 static { 334 static {
336 try { 335 try {
337 luan_proxyMethod = Static.class.getMethod("luan_proxy",LuanState.class,LuanTable.class); 336 luan_proxyMethod = Static.class.getMethod("luan_proxy",Luan.class,LuanTable.class);
338 luan_proxyMethod.setAccessible(true); 337 luan_proxyMethod.setAccessible(true);
339 } catch(NoSuchMethodException e) { 338 } catch(NoSuchMethodException e) {
340 throw new RuntimeException(e); 339 throw new RuntimeException(e);
341 } 340 }
342 } 341 }
343 342
344 public static Static load(LuanState luan,String name) throws LuanException { 343 public static Static load(Luan luan,String name) throws LuanException {
345 checkJava(luan); 344 checkJava(luan);
346 Class cls; 345 Class cls;
347 try { 346 try {
348 cls = Class.forName(name); 347 cls = Class.forName(name);
349 } catch(ClassNotFoundException e) { 348 } catch(ClassNotFoundException e) {
381 } 380 }
382 } 381 }
383 Collections.sort(varArgs,varArgsSorter); 382 Collections.sort(varArgs,varArgsSorter);
384 } 383 }
385 384
386 @Override public Object call(LuanState luan,Object[] args) throws LuanException { 385 @Override public Object call(Luan luan,Object[] args) throws LuanException {
387 List<LuanJavaFunction> list = fnMap.get(args.length); 386 List<LuanJavaFunction> list = fnMap.get(args.length);
388 if( list != null ) { 387 if( list != null ) {
389 for( LuanJavaFunction fn : list ) { 388 for( LuanJavaFunction fn : list ) {
390 try { 389 try {
391 return fn.rawCall(luan,args); 390 return fn.rawCall(luan,args);
428 427
429 AssertClass(Class cls) { 428 AssertClass(Class cls) {
430 this.cls = cls; 429 this.cls = cls;
431 } 430 }
432 431
433 public Object assertClass(LuanState luan,Object v) throws LuanException { 432 public Object assertClass(Luan luan,Object v) throws LuanException {
434 if( !cls.isInstance(v) ) { 433 if( !cls.isInstance(v) ) {
435 String got = v.getClass().getSimpleName(); 434 String got = v.getClass().getSimpleName();
436 String expected = cls.getSimpleName(); 435 String expected = cls.getSimpleName();
437 throw new LuanException(luan,"bad argument #1 ("+expected+" expected, got "+got+")"); 436 throw new LuanException(luan,"bad argument #1 ("+expected+" expected, got "+got+")");
438 } 437 }
440 } 439 }
441 } 440 }
442 private static final Method assertClass; 441 private static final Method assertClass;
443 static { 442 static {
444 try { 443 try {
445 assertClass = AssertClass.class.getMethod("assertClass",LuanState.class,Object.class); 444 assertClass = AssertClass.class.getMethod("assertClass",Luan.class,Object.class);
446 assertClass.setAccessible(true); 445 assertClass.setAccessible(true);
447 } catch(NoSuchMethodException e) { 446 } catch(NoSuchMethodException e) {
448 throw new RuntimeException(e); 447 throw new RuntimeException(e);
449 } 448 }
450 } 449 }
451 450
452 451
453 public static Object proxy(final LuanState luan,Static st,final LuanTable t,final Object base) throws LuanException { 452 public static Object proxy(final Luan luan,Static st,final LuanTable t,final Object base) throws LuanException {
454 return Proxy.newProxyInstance( 453 return Proxy.newProxyInstance(
455 st.cls.getClassLoader(), 454 st.cls.getClassLoader(),
456 new Class[]{st.cls}, 455 new Class[]{st.cls},
457 new InvocationHandler() { 456 new InvocationHandler() {
458 public Object invoke(Object proxy,Method method, Object[] args) 457 public Object invoke(Object proxy,Method method, Object[] args)