Examples of org.luaj.vm2.LuaValue

org.luaj.vm2.LuaValue
Base class for all concrete lua type values.
Establishes base implementations for all the operations on lua types. This allows Java clients to deal essentially with one type for all Java values, namely {@link LuaValue}.
Constructors are provided as static methods for common Java types, such as {@link LuaValue#valueOf(int)} or {@link LuaValue#valueOf(String)} to allow for instance pooling.
Constants are defined for the lua values {@link #NIL}, {@link #TRUE}, and {@link #FALSE}. A constant {@link #NONE} is defined which is a {@link Varargs} list having no values.
Operations are performed on values directly via their Java methods. For example, the following code divides two numbers:
```
  {@code LuaValue a = LuaValue.valueOf( 5 ); LuaValue b = LuaValue.valueOf( 4 ); LuaValue c = a.div(b);} 
```
Note that in this example, c will be a {@link LuaDouble}, but would be a {@link LuaInteger} if the value of a were changed to 8, say. In general the value of c in practice will vary depending on both the types and values of a and b as well as any metatable/metatag processing that occurs.
Field access and function calls are similar, with common overloads to simplify Java usage:
```
  {@code LuaValue globals = JsePlatform.standardGlobals(); LuaValue sqrt = globals.get("math").get("sqrt"); LuaValue print = globals.get("print"); LuaValue d = sqrt.call( a ); print.call( LuaValue.valueOf("sqrt(5):"), a );} 
```
To supply variable arguments or get multiple return values, use {@link invoke(Varargs)} or {@link invokemethod(LuaValue, Varargs)} methods:
```
  {@code LuaValue modf = globals.get("math").get("modf"); Varargs r = modf.invoke( d ); print.call( r.arg(1), r.arg(2) );} 
```
To load and run a script, {@link LoadState} is used:
```
  {@code LoadState.load( new FileInputStream("main.lua"), "main.lua", globals ).call();} 
```
although {@code require} could also be used:
```
  {@code globals.get("require").call(LuaValue.valueOf("main"));} 
```
For this to work the file must be in the current directory, or in the class path, dependening on the platform. See {@link JsePlatform} and {@link JmePlatform} for details.
In general a {@link LuaError} may be thrown on any operation when the types supplied to any operation are illegal from a lua perspective. Examples could be attempting to concatenate a NIL value, or attempting arithmetic on values that are not number.
There are several methods for preinitializing tables, such as:
- {@link #listOf(LuaValue[])} for unnamed elements
- {@link #tableOf(LuaValue[])} for named elements
- {@link #tableOf(LuaValue[],LuaValue[],Varargs)} for mixtures
Predefined constants exist for the standard lua type constants {@link TNIL}, {@link TBOOLEAN}, {@link TLIGHTUSERDATA}, {@link TNUMBER}, {@link TSTRING}, {@link TTABLE}, {@link TFUNCTION}, {@link TUSERDATA}, {@link TTHREAD}, and extended lua type constants {@link TINT}, {@link TNONE}, {@link TVALUE}
Predefined constants exist for all strings used as metatags: {@link INDEX}, {@link NEWINDEX}, {@link CALL}, {@link MODE}, {@link METATABLE}, {@link ADD}, {@link SUB}, {@link DIV}, {@link MUL}, {@link POW}, {@link MOD}, {@link UNM}, {@link LEN}, {@link EQ}, {@link LT}, {@link LE}, {@link TOSTRING}, and {@link CONCAT}. @see JsePlatform @see JmePlatform @see LoadState @see Varargs

    do {
      e = fname.indexOf(_DOT, b=e+1 );
      if ( e < 0 )
        e = fname.m_length;
      LuaString key = fname.substring(b, e);
      LuaValue val = table.rawget(key);
      if ( val.isnil() ) { /* no such field? */
        LuaTable field = new LuaTable(); /* new table for field */
        table.set(key, field);
        table = field;
      } else if ( ! val.istable() ) {  /* field has a non-table value? */
        return null;
      } else {
        table = val;
      }
    } while ( e < fname.m_length );

View Full Code Here

   * If there is any error loading or running the module, or if it cannot find any loader for 
   * the module, then require signals an error.
   */  
  public LuaValue require( LuaValue arg ) {
    LuaString name = arg.checkstring();
    LuaValue loaded = LOADED.get(name);
    if ( loaded.toboolean() ) {
      if ( loaded == _SENTINEL )
        error("loop or previous error loading module '"+name+"'");
      return loaded;
    }


    /* else must load it; iterate over available loaders */
    LuaTable tbl = PACKAGE.get(_LOADERS).checktable();
    StringBuffer sb = new StringBuffer();
    LuaValue chunk = null;
    for ( int i=1; true; i++ ) {
      LuaValue loader = tbl.get(i);
      if ( loader.isnil() ) {
        error( "module '"+name+"' not found: "+name+sb );        
        }
            
        /* call loader with module name as argument */
      chunk = loader.call(name);
      if ( chunk.isfunction() )
        break;
      if ( chunk.isstring() )
        sb.append( chunk.tojstring() );
    }


    // load the module using the loader
    LOADED.set(name, _SENTINEL);
    LuaValue result = chunk.call(name);
    if ( ! result.isnil() )
      LOADED.set( name, result );
    else if ( (result = LOADED.get(name)) == _SENTINEL ) 
      LOADED.set( name, result = LuaValue.TRUE );
    return result;
  }

View Full Code Here

    return varargsOf(NIL, valueOf("dynamic libraries not enabled"), valueOf("absent"));
  }


  LuaValue loader_preload( Varargs args ) {
    LuaString name = args.checkstring(1);
    LuaValue preload = PACKAGE.get(_PRELOAD).checktable();
    LuaValue val = preload.get(name);
    return val.isnil()? 
      valueOf("\n\tno field package.preload['"+name+"']"):
      val;
  }

View Full Code Here

    String name = args.checkjstring(1);
    InputStream is = null;
    
    
    // get package path
    LuaValue pp = PACKAGE.get(_PATH);
    if ( ! pp.isstring() ) 
      return valueOf("package.path is not a string");
    String path = pp.tojstring();
    
    // check the path elements
    int e = -1;
    int n = path.length();
    StringBuffer sb = null;

View Full Code Here

  
  LuaValue loader_Java( Varargs args ) {
    String name = args.checkjstring(1);
    String classname = toClassname( name );
    Class c = null;
    LuaValue v = null;
    try {
      c = Class.forName(classname);
      v = (LuaValue) c.newInstance();
      v.setfenv(env);
      return v;
    } catch ( ClassNotFoundException  cnfe ) {
      return valueOf("\n\tno class '"+classname+"'" );
    } catch ( Exception e ) {
      return valueOf("\n\tjava load failed on '"+classname+"', "+e );

View Full Code Here

      switch ( opcode ) {
      case OP_REQUIRE: 
        return lib.require(arg);
      case OP_SEEALL: { 
        LuaTable t = arg.checktable();
        LuaValue m = t.getmetatable();
        if ( m == null )
          t.setmetatable(m=tableOf());
        m.set( INDEX, LuaThread.getGlobals() );
        return NONE;
      }
      }
      return NIL;
    }

View Full Code Here

    ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
    PrintStream printStream = new PrintStream( outputStream );
    try {
      org.luaj.vm2.LuaTable _G = org.luaj.vm2.lib.jse.JsePlatform.debugGlobals();
      LuaThread.getRunning().setfenv(_G);
      LuaValue loader = new org.luaj.vm2.lib.OneArgFunction(_G) {
        public LuaValue call(LuaValue arg) {
          String name = arg.tojstring();
          String file = name + ".lua";
          InputStream is = open( file );
          if ( is == null )
            return LuaValue.valueOf("not found: "+file);
          try {
            return org.luaj.vm2.LoadState.load(is, "@stdin", env);
          } catch (IOException e) {
            return LuaValue.valueOf(e.toString());
          } finally {
            try { is.close(); } catch ( IOException ioe ) {}
          }
        }
      };
      LuaTable loaders = _G.get("package").get("loaders").checktable();
      loaders.insert(1, loader);
      org.luaj.vm2.lib.BaseLib.instance.STDOUT = printStream;
      loader.call(LuaValue.valueOf(test)).invoke(LuaValue.valueOf(test));
    } finally {
      printStream.close();
    }
    return outputStream.toString();
  }

View Full Code Here

   * function must be a Lua function without upvalues.
   *  
   * TODO: port dumping code as optional add-on
   */
  static LuaValue dump( LuaValue arg ) {
    LuaValue f = arg.checkfunction();
    ByteArrayOutputStream baos = new ByteArrayOutputStream();
    try {
      DumpState.dump( ((LuaClosure)f).p, baos, true );
      return LuaString.valueOf(baos.toByteArray());
    } catch (IOException e) {

View Full Code Here

   */
  static Varargs gsub( Varargs args ) {
    LuaString src = args.checkstring( 1 );
    final int srclen = src.length();
    LuaString p = args.checkstring( 2 );
    LuaValue repl = args.arg( 3 );
    int max_s = args.optint( 4, srclen + 1 );
    final boolean anchor = p.length() > 0 && p.charAt( 0 ) == '^';
    
    Buffer lbuf = new Buffer( srclen );
    MatchState ms = new MatchState( args, src, p );

View Full Code Here

      try {
        return CoerceJavaToLua.coerce(f.get(m_instance));
      } catch (Exception e) {
        throw new LuaError(e);
      }
    LuaValue m = jclass.getMethod(key);
    if ( m != null )
      return m;
    return super.get(key);
  }

View Full Code Here

0 1 2 3 4 5 6 7 8 9

TOP

Related Classes of org.luaj.vm2.LuaValue

com.aerospike.client.lua.LuaAerospikeLib

com.aerospike.client.lua.LuaBytesLib

com.aerospike.client.lua.LuaBytesLib$MetaLib

com.aerospike.client.lua.LuaCache

com.aerospike.client.lua.LuaInstance

com.aerospike.client.lua.LuaListLib

com.aerospike.client.lua.LuaListLib$create

com.aerospike.client.lua.LuaListLib$MetaLib

com.aerospike.client.lua.LuaMapLib

com.aerospike.client.lua.LuaMapLib$create

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.