5 | *
6 | * Licensed under the blakequ.com License, Version 1.0 (the "License");
7 | * Unless required by applicable law or agreed to in writing, software
8 | * distributed under the License is distributed on an "AS IS" BASIS,
9 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
10 | * See the License for the specific language governing permissions and
11 | * limitations under the License.
12 | *
13 | * author : quhao
5 |
--------------------------------------------------------------------------------
/app/src/main/res/layout/activity_main.xml:
--------------------------------------------------------------------------------
1 |
2 |
6 |
7 |
12 |
13 |
59 |
60 |
61 |
62 |
63 |
72 |
--------------------------------------------------------------------------------
/app/src/main/res/menu/menu_main.xml:
--------------------------------------------------------------------------------
1 |
4 |
7 |
--------------------------------------------------------------------------------
/app/src/main/res/mipmap-hdpi/ic_launcher.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/haodynasty/AndroidLuaExample/f51699da7c2a07e8c7ddc4ebb3fd29a5cccf0f45/app/src/main/res/mipmap-hdpi/ic_launcher.png
--------------------------------------------------------------------------------
/app/src/main/res/mipmap-mdpi/ic_launcher.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/haodynasty/AndroidLuaExample/f51699da7c2a07e8c7ddc4ebb3fd29a5cccf0f45/app/src/main/res/mipmap-mdpi/ic_launcher.png
--------------------------------------------------------------------------------
/app/src/main/res/mipmap-xhdpi/ic_launcher.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/haodynasty/AndroidLuaExample/f51699da7c2a07e8c7ddc4ebb3fd29a5cccf0f45/app/src/main/res/mipmap-xhdpi/ic_launcher.png
--------------------------------------------------------------------------------
/app/src/main/res/mipmap-xxhdpi/ic_launcher.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/haodynasty/AndroidLuaExample/f51699da7c2a07e8c7ddc4ebb3fd29a5cccf0f45/app/src/main/res/mipmap-xxhdpi/ic_launcher.png
--------------------------------------------------------------------------------
/app/src/main/res/raw/hello.lua:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/haodynasty/AndroidLuaExample/f51699da7c2a07e8c7ddc4ebb3fd29a5cccf0f45/app/src/main/res/raw/hello.lua
--------------------------------------------------------------------------------
/app/src/main/res/raw/luafile.lua:
--------------------------------------------------------------------------------
1 | --
2 | -- Created by IntelliJ IDEA.
3 | -- User: PLUSUB
4 | -- Date: 2015/10/16
5 | -- Time: 11:09
6 | -- To change this template use File | Settings | File Templates.
7 | --
8 | str = "are you china"
9 | VERSION = 1
10 | function functionInLuaFile(key)
11 | --print log
12 | Log:i("LuaLog", "over setcontent")
13 | return ' Function in Lua file . Return : '..key..'!'..str
14 | end
15 |
16 | function callAndroidApi(context,layout,tip)
17 | tv = luajava.newInstance("android.widget.TextView",context)
18 | tv:setText(tip)
19 | layout:addView(tv)
20 | end
21 |
22 | function reloadMethod(self, info)
23 | Log:i("LuaLog", "method origial "..info)
24 | return ' Function in Lua file.' ..info
25 | end
26 |
27 | function GetVersion(info, intvalue)
28 | Log:i("LuaLog", info..intvalue)
29 | -- 测试返回值，调用时mLuaState.call(1, 1);在这里可以是下面4中情况
30 | -- return nil
31 | -- return
32 | -- 没有return也没有影响
33 | return VERSION
34 | end
35 |
36 | -- 错误处理测试
37 | function testErrorHandler()
38 | Log:i("LuaLog", '----xpcall有错误---')
39 | -- xpcall接收第二个参数——一个错误处理函数，当错误发生时，Lua会在调用桟展看（unwind）前调用错误处理函数，于是就可以在这个函数中使用debug库来获取关于错误的额外信息了
40 | status = xpcall(myfunction, myerrorhandler)
41 | Log:i("LuaLog", '----xpcall无错误带返回值---')
42 | -- 返回三个参数：状态，返回值，错误,xpcall (f, msgh [, arg1, ···])这个传入参数arg1需要5.2以上才能支持http://stackoverflow.com/questions/30125726/how-to-use-xpcall-with-a-function-which-has-parameters
43 | status1, ret, err = xpcall(myfunction3, myerrorhandler, 5, 6)
44 | -- 5.2以下版本不能传入参数，只能用函数包装参数
45 | -- status1, ret, err = xpcall(myfunction4, myerrorhandler)
46 | Log:i("LuaLog", 'myfunction3 result '..(status1 and "true" or "false"))
47 | if ret ~= nil then
48 | Log:i("LuaLog", 'myfunction3 ret '..ret)
49 | end
50 | if err ~= nil then
51 | Log:i("LuaLog", 'myfunction3 err '..err)
52 | end
53 |
54 | Log:i("LuaLog", '----pcall---')
55 | -- pcall接收一个函数和要传递个后者的参数，并执行，执行结果：有错误、无错误；返回值true或者或false, errorinfo。
56 | status, err = pcall(testPcall, 33)
57 | -- status, err = pcall(function(i) testPcall(i) end, 33)
58 | -- if pcall(function(i) testPcall(i) end, 33) then
59 | if status == true then
60 | -- 没有错误
61 | Log:i("LuaLog", 'test right')
62 | else
63 | -- 一些错误
64 | Log:e("LuaLog", 'test error== '..err)
65 | end
66 | Log:i("LuaLog", '----end---')
67 | end
68 |
69 | function myfunction ()
70 | -- n = n/nil
71 | myfunction2()
72 | end
73 |
74 | function myfunction2 ()
75 | -- 位运算
76 | n = 1024>>2
77 | Log:i("LuaLog", 'bit value1:'..n)
78 | n = 1024|2
79 | Log:i("LuaLog", 'bit value2:'..n)
80 | n = 1024~2
81 | Log:i("LuaLog", 'bit value3:'..n)
82 | n = 1024&0
83 | Log:i("LuaLog", 'bit value4:'..n)
84 | n = ~1
85 | Log:i("LuaLog", 'bit value5:'..n)
86 | -- 异常抛出
87 | n = n/nil
88 | end
89 |
90 | -- 5.2以上才能带参数
91 | function myfunction3(a, b)
92 | if a ~= nil and b ~= nil then
93 | Log:i("LuaLog", 'myfunction3 value is a:'..a..' b:'..b)
94 | return a + b
95 | end
96 | return 0
97 | end
98 | -- 5.1以下要传参需要无参数
99 | function myfunction4()
100 | n = n/nil
101 | myfunction3(1,3)
102 | end
103 |
104 | function myerrorhandler( err )
105 | Log:i("LuaLog", "ERROR:"..err..'\n'..debug.traceback("Stack trace"))
106 | end
107 |
108 | function testPcall(i)
109 | print(i)
110 | n = n/nil
111 | error('error..11 ')
112 | end
113 |
114 |
--------------------------------------------------------------------------------
/app/src/main/res/raw/luafile1.lua:
--------------------------------------------------------------------------------
1 | --
2 | -- Created by IntelliJ IDEA.
3 | -- User: PLUSUB
4 | -- Date: 2015/10/16
5 | -- Time: 11:09
6 | -- To change this template use File | Settings | File Templates.
7 | --
8 | str = "are you china"
9 | function functionInLuaFile(key)
10 | --print log
11 | Log:i("LuaLog", "reload lua file")
12 | return ' Function in Lua file222222 . Return : '..key..'!'..str
13 | end
14 |
15 |
16 | function callAndroidApi(context,layout,tip)
17 | tv = luajava.newInstance("android.widget.TextView",context)
18 | tv:setText(tip)
19 | layout:addView(tv)
20 | end
21 |
22 | function reloadMethod(self, info)
23 | Log:i("LuaLog", "method reload "..info)
24 | return ' Function in reload Lua file.' ..info
25 | end
--------------------------------------------------------------------------------
/app/src/main/res/values-w820dp/dimens.xml:
--------------------------------------------------------------------------------
1 |
2 |
5 | 64dp
6 |
7 |
--------------------------------------------------------------------------------
/app/src/main/res/values/dimens.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 | 16dp
4 | 16dp
5 |
6 |
--------------------------------------------------------------------------------
/app/src/main/res/values/strings.xml:
--------------------------------------------------------------------------------
1 |
2 | AndroidLuaExample
3 |
4 | Hello world!
5 | Settings
6 |
7 |
--------------------------------------------------------------------------------
/app/src/main/res/values/styles.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
7 |
8 |
9 |
--------------------------------------------------------------------------------
/build.gradle:
--------------------------------------------------------------------------------
1 | // Top-level build file where you can add configuration options common to all sub-projects/modules.
2 | def getLocalProperty(String key) {
3 | if (!localPropertiesFile().exists()) {
4 | return null
5 | }
6 |
7 | Properties properties = new Properties()
8 | properties.load(localPropertiesFile().newDataInputStream())
9 | return properties.getProperty(key)
10 | }
11 |
12 | def localPropertiesFile() {
13 | return project.rootProject.file('local.properties');
14 | }
15 |
16 | def isForUpload2Maven() {
17 | return getLocalProperty("for.upload") == "true"
18 | }
19 |
20 | //获取当前时间
21 | def releaseTime() {
22 | return new Date().format("yyyyMMdd", TimeZone.getTimeZone("UTC"))
23 | }
24 |
25 | buildscript {
26 | repositories {
27 | jcenter()
28 | maven {
29 | url "https://plugins.gradle.org/m2/"
30 | }
31 | }
32 | dependencies {
33 | classpath 'com.android.tools.build:gradle:2.3.0'
34 |
35 | // NOTE: Do not place your application dependencies here; they belong
36 | // in the individual module build.gradle files
37 | //using for upload to bintray lib
38 | File file = project.rootProject.file('local.properties')
39 | if (file.exists()) {
40 | Properties properties = new Properties()
41 | properties.load(file.newDataInputStream())
42 | boolean upload2maven = properties.getProperty("for.upload") == "true"
43 | if (upload2maven) {
44 | println ':global:include upload 2 maven classpath'
45 | classpath 'com.jfrog.bintray.gradle:gradle-bintray-plugin:1.4'
46 | classpath 'com.github.dcendents:android-maven-gradle-plugin:1.4.1'
47 | classpath "gradle.plugin.nl.javadude.gradle.plugins:license-gradle-plugin:0.13.1"
48 | }
49 | }
50 | }
51 | }
52 |
53 | allprojects {
54 | repositories {
55 | jcenter()
56 | }
57 | }
58 |
59 | task clean(type: Delete) {
60 | delete rootProject.buildDir
61 | }
62 |
--------------------------------------------------------------------------------
/gradle.properties:
--------------------------------------------------------------------------------
1 | # Project-wide Gradle settings.
2 |
3 | # IDE (e.g. Android Studio) users:
4 | # Gradle settings configured through the IDE *will override*
5 | # any settings specified in this file.
6 |
7 | # For more details on how to configure your build environment visit
8 | # http://www.gradle.org/docs/current/userguide/build_environment.html
9 |
10 | # Specifies the JVM arguments used for the daemon process.
11 | # The setting is particularly useful for tweaking memory settings.
12 | # Default value: -Xmx10248m -XX:MaxPermSize=256m
13 | # org.gradle.jvmargs=-Xmx2048m -XX:MaxPermSize=512m -XX:+HeapDumpOnOutOfMemoryError -Dfile.encoding=UTF-8
14 |
15 | # When configured, Gradle will run in incubating parallel mode.
16 | # This option should only be used with decoupled projects. More details, visit
17 | # http://www.gradle.org/docs/current/userguide/multi_project_builds.html#sec:decoupled_projects
18 | # org.gradle.parallel=true
19 |
20 | # Android configuration
21 | COMPILE_SDK_VERSION=android-25
22 | BUILD_TOOLS_VERSION=25.0.0
23 | MIN_SDK_VERSION=18
24 | TARGET_SDK_VERSION = 23
25 |
26 | # Dependency versions
27 | SUPPORT_LIBRARY_VERSION=25.0.0
28 |
29 | # bintray
30 | GROUP=com.blakequ.luajava
31 | VERSION_CODE=1
32 | VERSION_NAME=1.0
33 | ARTIFACT_NAME=AndroidLua
34 | SITE_URL=https://github.com/haodynasty/AndroidLuaExample
35 | ISSUE_URL=https://github.com/haodynasty/AndroidLuaExample/issues
36 | SCM_URL=https://github.com/haodynasty/AndroidLuaExample.git
37 | ARTIFACT_DESCRIPTION=android lua bridge
38 | ISSUE_SYSTEM=github
39 | SCM_CONNECTION=scm:git@github.com:haodynasty/AndroidLuaExample.git
40 | SCM_DEV_CONNECTION=scm:git@github.com:haodynasty/AndroidLuaExample.git
41 | LICENCE_DIST=repo
42 | LICENCE_NAME=The Apache Software License, Version 2.0
43 | LICENCE_URL=http://www.apache.org/licenses/LICENSE-2.0.txt
44 | DEVELOPER_ID=haodynasty
45 | DEVELOPER_NAME=Blakequ
46 | DEVELOPER_EMAIL=blakequ@gmail.com
--------------------------------------------------------------------------------
/gradle/wrapper/gradle-wrapper.jar:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/haodynasty/AndroidLuaExample/f51699da7c2a07e8c7ddc4ebb3fd29a5cccf0f45/gradle/wrapper/gradle-wrapper.jar
--------------------------------------------------------------------------------
/gradle/wrapper/gradle-wrapper.properties:
--------------------------------------------------------------------------------
1 | #Fri Feb 17 15:03:15 CST 2017
2 | distributionBase=GRADLE_USER_HOME
3 | distributionPath=wrapper/dists
4 | zipStoreBase=GRADLE_USER_HOME
5 | zipStorePath=wrapper/dists
6 | distributionUrl=https\://services.gradle.org/distributions/gradle-3.3-all.zip
7 |
--------------------------------------------------------------------------------
/gradlew:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env bash
2 |
3 | ##############################################################################
4 | ##
5 | ## Gradle start up script for UN*X
6 | ##
7 | ##############################################################################
8 |
9 | # Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
10 | DEFAULT_JVM_OPTS=""
11 |
12 | APP_NAME="Gradle"
13 | APP_BASE_NAME=`basename "$0"`
14 |
15 | # Use the maximum available, or set MAX_FD != -1 to use that value.
16 | MAX_FD="maximum"
17 |
18 | warn ( ) {
19 | echo "$*"
20 | }
21 |
22 | die ( ) {
23 | echo
24 | echo "$*"
25 | echo
26 | exit 1
27 | }
28 |
29 | # OS specific support (must be 'true' or 'false').
30 | cygwin=false
31 | msys=false
32 | darwin=false
33 | case "`uname`" in
34 | CYGWIN* )
35 | cygwin=true
36 | ;;
37 | Darwin* )
38 | darwin=true
39 | ;;
40 | MINGW* )
41 | msys=true
42 | ;;
43 | esac
44 |
45 | # For Cygwin, ensure paths are in UNIX format before anything is touched.
46 | if $cygwin ; then
47 | [ -n "$JAVA_HOME" ] && JAVA_HOME=`cygpath --unix "$JAVA_HOME"`
48 | fi
49 |
50 | # Attempt to set APP_HOME
51 | # Resolve links: $0 may be a link
52 | PRG="$0"
53 | # Need this for relative symlinks.
54 | while [ -h "$PRG" ] ; do
55 | ls=`ls -ld "$PRG"`
56 | link=`expr "$ls" : '.*-> \(.*\)$'`
57 | if expr "$link" : '/.*' > /dev/null; then
58 | PRG="$link"
59 | else
60 | PRG=`dirname "$PRG"`"/$link"
61 | fi
62 | done
63 | SAVED="`pwd`"
64 | cd "`dirname \"$PRG\"`/" >&-
65 | APP_HOME="`pwd -P`"
66 | cd "$SAVED" >&-
67 |
68 | CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
69 |
70 | # Determine the Java command to use to start the JVM.
71 | if [ -n "$JAVA_HOME" ] ; then
72 | if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
73 | # IBM's JDK on AIX uses strange locations for the executables
74 | JAVACMD="$JAVA_HOME/jre/sh/java"
75 | else
76 | JAVACMD="$JAVA_HOME/bin/java"
77 | fi
78 | if [ ! -x "$JAVACMD" ] ; then
79 | die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
80 |
81 | Please set the JAVA_HOME variable in your environment to match the
82 | location of your Java installation."
83 | fi
84 | else
85 | JAVACMD="java"
86 | which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
87 |
88 | Please set the JAVA_HOME variable in your environment to match the
89 | location of your Java installation."
90 | fi
91 |
92 | # Increase the maximum file descriptors if we can.
93 | if [ "$cygwin" = "false" -a "$darwin" = "false" ] ; then
94 | MAX_FD_LIMIT=`ulimit -H -n`
95 | if [ $? -eq 0 ] ; then
96 | if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
97 | MAX_FD="$MAX_FD_LIMIT"
98 | fi
99 | ulimit -n $MAX_FD
100 | if [ $? -ne 0 ] ; then
101 | warn "Could not set maximum file descriptor limit: $MAX_FD"
102 | fi
103 | else
104 | warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
105 | fi
106 | fi
107 |
108 | # For Darwin, add options to specify how the application appears in the dock
109 | if $darwin; then
110 | GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
111 | fi
112 |
113 | # For Cygwin, switch paths to Windows format before running java
114 | if $cygwin ; then
115 | APP_HOME=`cygpath --path --mixed "$APP_HOME"`
116 | CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
117 |
118 | # We build the pattern for arguments to be converted via cygpath
119 | ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
120 | SEP=""
121 | for dir in $ROOTDIRSRAW ; do
122 | ROOTDIRS="$ROOTDIRS$SEP$dir"
123 | SEP="|"
124 | done
125 | OURCYGPATTERN="(^($ROOTDIRS))"
126 | # Add a user-defined pattern to the cygpath arguments
127 | if [ "$GRADLE_CYGPATTERN" != "" ] ; then
128 | OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
129 | fi
130 | # Now convert the arguments - kludge to limit ourselves to /bin/sh
131 | i=0
132 | for arg in "$@" ; do
133 | CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
134 | CHECK2=`echo "$arg"|egrep -c "^-"` ### Determine if an option
135 |
136 | if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then ### Added a condition
137 | eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
138 | else
139 | eval `echo args$i`="\"$arg\""
140 | fi
141 | i=$((i+1))
142 | done
143 | case $i in
144 | (0) set -- ;;
145 | (1) set -- "$args0" ;;
146 | (2) set -- "$args0" "$args1" ;;
147 | (3) set -- "$args0" "$args1" "$args2" ;;
148 | (4) set -- "$args0" "$args1" "$args2" "$args3" ;;
149 | (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
150 | (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
151 | (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
152 | (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
153 | (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
154 | esac
155 | fi
156 |
157 | # Split up the JVM_OPTS And GRADLE_OPTS values into an array, following the shell quoting and substitution rules
158 | function splitJvmOpts() {
159 | JVM_OPTS=("$@")
160 | }
161 | eval splitJvmOpts $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS
162 | JVM_OPTS[${#JVM_OPTS[*]}]="-Dorg.gradle.appname=$APP_BASE_NAME"
163 |
164 | exec "$JAVACMD" "${JVM_OPTS[@]}" -classpath "$CLASSPATH" org.gradle.wrapper.GradleWrapperMain "$@"
165 |
--------------------------------------------------------------------------------
/gradlew.bat:
--------------------------------------------------------------------------------
1 | @if "%DEBUG%" == "" @echo off
2 | @rem ##########################################################################
3 | @rem
4 | @rem Gradle startup script for Windows
5 | @rem
6 | @rem ##########################################################################
7 |
8 | @rem Set local scope for the variables with windows NT shell
9 | if "%OS%"=="Windows_NT" setlocal
10 |
11 | @rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
12 | set DEFAULT_JVM_OPTS=
13 |
14 | set DIRNAME=%~dp0
15 | if "%DIRNAME%" == "" set DIRNAME=.
16 | set APP_BASE_NAME=%~n0
17 | set APP_HOME=%DIRNAME%
18 |
19 | @rem Find java.exe
20 | if defined JAVA_HOME goto findJavaFromJavaHome
21 |
22 | set JAVA_EXE=java.exe
23 | %JAVA_EXE% -version >NUL 2>&1
24 | if "%ERRORLEVEL%" == "0" goto init
25 |
26 | echo.
27 | echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
28 | echo.
29 | echo Please set the JAVA_HOME variable in your environment to match the
30 | echo location of your Java installation.
31 |
32 | goto fail
33 |
34 | :findJavaFromJavaHome
35 | set JAVA_HOME=%JAVA_HOME:"=%
36 | set JAVA_EXE=%JAVA_HOME%/bin/java.exe
37 |
38 | if exist "%JAVA_EXE%" goto init
39 |
40 | echo.
41 | echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
42 | echo.
43 | echo Please set the JAVA_HOME variable in your environment to match the
44 | echo location of your Java installation.
45 |
46 | goto fail
47 |
48 | :init
49 | @rem Get command-line arguments, handling Windowz variants
50 |
51 | if not "%OS%" == "Windows_NT" goto win9xME_args
52 | if "%@eval[2+2]" == "4" goto 4NT_args
53 |
54 | :win9xME_args
55 | @rem Slurp the command line arguments.
56 | set CMD_LINE_ARGS=
57 | set _SKIP=2
58 |
59 | :win9xME_args_slurp
60 | if "x%~1" == "x" goto execute
61 |
62 | set CMD_LINE_ARGS=%*
63 | goto execute
64 |
65 | :4NT_args
66 | @rem Get arguments from the 4NT Shell from JP Software
67 | set CMD_LINE_ARGS=%$
68 |
69 | :execute
70 | @rem Setup the command line
71 |
72 | set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
73 |
74 | @rem Execute Gradle
75 | "%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%
76 |
77 | :end
78 | @rem End local scope for the variables with windows NT shell
79 | if "%ERRORLEVEL%"=="0" goto mainEnd
80 |
81 | :fail
82 | rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
83 | rem the _cmd.exe /c_ return code!
84 | if not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
85 | exit /b 1
86 |
87 | :mainEnd
88 | if "%OS%"=="Windows_NT" endlocal
89 |
90 | :omega
91 |
--------------------------------------------------------------------------------
/luajava/.gitignore:
--------------------------------------------------------------------------------
1 | /build
2 |
--------------------------------------------------------------------------------
/luajava/build.gradle:
--------------------------------------------------------------------------------
1 | apply plugin: 'com.android.library'
2 |
3 | android {
4 | compileSdkVersion COMPILE_SDK_VERSION
5 | buildToolsVersion BUILD_TOOLS_VERSION as String
6 |
7 | defaultConfig {
8 | minSdkVersion MIN_SDK_VERSION
9 | targetSdkVersion TARGET_SDK_VERSION
10 | versionCode VERSION_CODE as int
11 | versionName VERSION_NAME as String
12 | testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
13 | }
14 |
15 | buildTypes {
16 | release {
17 | minifyEnabled false
18 | proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
19 | }
20 | }
21 |
22 | //屏蔽gradle检测到c自己调用jni
23 | //http://www.liuling123.com/2016/05/android-studio-gradle-ndk-config.html
24 | sourceSets {
25 | main {
26 | jni.srcDirs = [] //屏蔽gradle的jni生成过程
27 | jniLibs.srcDirs = ['src/main/jniLibs']//设置目标的so存放路径
28 | }
29 | }
30 |
31 | }
32 |
33 | //Compile JNI source via NDK
34 | task ndkBuild(type: Exec) {
35 | // def ndkDir = project.plugins.findPlugin('com.android.application').sdkHandler.getNdkFolder()
36 | def ndkDir = android.ndkDirectory
37 | //注：在mac下使用ndk-build ，在win下使用ndk-build.cmd
38 | //notice: in mac use /ndk-build , in win use /ndk-build.cmd
39 | commandLine "$ndkDir/ndk-build.cmd", '-C', 'src/main/jni',
40 | "NDK_OUT=$buildDir/ndk/obj",
41 | "NDK_APP_DST_DIR=$buildDir/ndk/libs/\$(TARGET_ARCH_ABI)"
42 | }
43 |
44 | task copyJniLibs(type: Copy, dependsOn:['ndkBuild']) {
45 | from fileTree(dir: file(buildDir.absolutePath + '/ndk/libs'), include: '**/*.so')
46 | into file('src/main/jniLibs')
47 | }
48 |
49 | tasks.withType(JavaCompile) {
50 | compileTask -> compileTask.dependsOn 'ndkBuild','copyJniLibs'
51 | }
52 |
53 | task cleanNative(type: Exec, description: 'Clean JNI object files') {
54 | def ndkDir = android.ndkDirectory
55 | commandLine "$ndkDir/ndk-build.cmd",
56 | '-C', file('src/main/jni').absolutePath, // Change src/main/jni the relative path to your jni source
57 | 'clean'
58 | }
59 |
60 | clean.dependsOn 'cleanNative'
61 |
62 | dependencies {
63 | compile fileTree(dir: 'libs', include: ['*.jar'])
64 | androidTestCompile('com.android.support.test.espresso:espresso-core:2.2.2', {
65 | exclude group: 'com.android.support', module: 'support-annotations'
66 | })
67 | compile 'com.android.support:appcompat-v7:25.0.0'
68 | testCompile 'junit:junit:4.12'
69 | }
70 |
71 | //执行bintrayUpload之前必须执行gradlew install生成poms文件（build/poms）
72 | if (isForUpload2Maven()) {
73 | println ':library:include upload 2 maven methods'
74 | apply from: 'https://raw.githubusercontent.com/haodynasty/JCenter/master/installv1.gradle'
75 | apply from: 'https://raw.githubusercontent.com/haodynasty/JCenter/master/bintrayv1.gradle'
76 | apply from: 'https://raw.githubusercontent.com/haodynasty/JCenter/master/license.gradle'
77 | }
78 |
--------------------------------------------------------------------------------
/luajava/proguard-rules.pro:
--------------------------------------------------------------------------------
1 | # Add project specific ProGuard rules here.
2 | # By default, the flags in this file are appended to flags specified
3 | # in D:\studio_sdk/tools/proguard/proguard-android.txt
4 | # You can edit the include path and order by changing the proguardFiles
5 | # directive in build.gradle.
6 | #
7 | # For more details, see
8 | # http://developer.android.com/guide/developing/tools/proguard.html
9 |
10 | # Add any project specific keep options here:
11 |
12 | # If your project uses WebView with JS, uncomment the following
13 | # and specify the fully qualified class name to the JavaScript interface
14 | # class:
15 | #-keepclassmembers class fqcn.of.javascript.interface.for.webview {
16 | # public *;
17 | #}
18 |
19 | # Uncomment this to preserve the line number information for
20 | # debugging stack traces.
21 | #-keepattributes SourceFile,LineNumberTable
22 |
23 | # If you keep the line number information, uncomment this to
24 | # hide the original source file name.
25 | #-renamesourcefileattribute SourceFile
26 |
--------------------------------------------------------------------------------
/luajava/src/androidTest/java/org/keplerproject/luajava/ExampleInstrumentedTest.java:
--------------------------------------------------------------------------------
1 | package org.keplerproject.luajava;
2 |
3 | import android.content.Context;
4 | import android.support.test.InstrumentationRegistry;
5 | import android.support.test.runner.AndroidJUnit4;
6 |
7 | import org.junit.Test;
8 | import org.junit.runner.RunWith;
9 |
10 | import static org.junit.Assert.*;
11 |
12 | /**
13 | * Instrumentation test, which will execute on an Android device.
14 | *
15 | * @see Testing documentation
16 | */
17 | @RunWith(AndroidJUnit4.class)
18 | public class ExampleInstrumentedTest {
19 | @Test
20 | public void useAppContext() throws Exception {
21 | // Context of the app under test.
22 | Context appContext = InstrumentationRegistry.getTargetContext();
23 |
24 | assertEquals("org.keplerproject.luajava.test", appContext.getPackageName());
25 | }
26 | }
27 |
--------------------------------------------------------------------------------
/luajava/src/main/AndroidManifest.xml:
--------------------------------------------------------------------------------
1 |
4 |
5 |
7 |
8 |
9 |
10 |
11 |
--------------------------------------------------------------------------------
/luajava/src/main/java/org/keplerproject/luajava/CPtr.java:
--------------------------------------------------------------------------------
1 | /*
2 | * $Id: CPtr.java,v 1.4 2006/12/22 14:06:40 thiago Exp $
3 | * Copyright (C) 2003-2007 Kepler Project.
4 | *
5 | * Permission is hereby granted, free of charge, to any person obtaining
6 | * a copy of this software and associated documentation files (the
7 | * "Software"), to deal in the Software without restriction, including
8 | * without limitation the rights to use, copy, modify, merge, publish,
9 | * distribute, sublicense, and/or sell copies of the Software, and to
10 | * permit persons to whom the Software is furnished to do so, subject to
11 | * the following conditions:
12 | *
13 | * The above copyright notice and this permission notice shall be
14 | * included in all copies or substantial portions of the Software.
15 | *
16 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
17 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
18 | * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
19 | * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
20 | * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
21 | * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
22 | * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
23 | */
24 |
25 | package org.keplerproject.luajava;
26 |
27 | /**
28 | * An abstraction for a C pointer data type. A CPtr instance represents, on
29 | * the Java side, a C pointer. The C pointer could be any type of C
30 | * pointer.
31 | */
32 | public class CPtr {
33 |
34 | /**
35 | * Compares this CPtr to the specified object.
36 | *
37 | * @param other a CPtr
38 | * @return true if the class of this CPtr object and the
39 | * class of other are exactly equal, and the C
40 | * pointers being pointed to by these objects are also
41 | * equal. Returns false otherwise.
42 | */
43 | public boolean equals(Object other) {
44 | if (other == null)
45 | return false;
46 | if (other == this)
47 | return true;
48 | if (CPtr.class != other.getClass())
49 | return false;
50 | return peer == ((CPtr) other).peer;
51 | }
52 |
53 |
54 | /* Pointer value of the real C pointer. Use long to be 64-bit safe. */
55 | private long peer;
56 |
57 | /**
58 | * Gets the value of the C pointer abstraction
59 | *
60 | * @return long
61 | */
62 | protected long getPeer() {
63 | return peer;
64 | }
65 |
66 | /* No-args constructor. */
67 | CPtr() {
68 | }
69 |
70 | }
71 |
--------------------------------------------------------------------------------
/luajava/src/main/java/org/keplerproject/luajava/Console.java:
--------------------------------------------------------------------------------
1 | /*
2 | * $Id: Console.java,v 1.7 2006/12/22 14:06:40 thiago Exp $
3 | * Copyright (C) 2003-2007 Kepler Project.
4 | *
5 | * Permission is hereby granted, free of charge, to any person obtaining
6 | * a copy of this software and associated documentation files (the
7 | * "Software"), to deal in the Software without restriction, including
8 | * without limitation the rights to use, copy, modify, merge, publish,
9 | * distribute, sublicense, and/or sell copies of the Software, and to
10 | * permit persons to whom the Software is furnished to do so, subject to
11 | * the following conditions:
12 | *
13 | * The above copyright notice and this permission notice shall be
14 | * included in all copies or substantial portions of the Software.
15 | *
16 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
17 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
18 | * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
19 | * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
20 | * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
21 | * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
22 | * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
23 | */
24 |
25 | package org.keplerproject.luajava;
26 |
27 | import java.io.BufferedReader;
28 | import java.io.InputStreamReader;
29 |
30 | /**
31 | * Simple LuaJava console.
32 | * This is also an example on how to use the Java side of LuaJava and how to startup
33 | * a LuaJava application.
34 | *
35 | * @author Thiago Ponte
36 | */
37 | public class Console {
38 |
39 | /**
40 | * Creates a console for user interaction.
41 | *
42 | * @param args names of the lua files to be executed
43 | */
44 | public static void main(String[] args) {
45 | try {
46 | LuaState L = LuaStateFactory.newLuaState();
47 | L.openLibs();
48 |
49 | if (args.length > 0) {
50 | for (int i = 0; i < args.length; i++) {
51 | int res = L.LloadFile(args[i]);
52 | if (res == 0) {
53 | res = L.pcall(0, 0, 0);
54 | }
55 | if (res != 0) {
56 | throw new LuaException("Error on file: " + args[i] + ". " + L.toString(-1));
57 | }
58 | }
59 |
60 | return;
61 | }
62 |
63 | System.out.println("API Lua Java - console mode.");
64 |
65 | BufferedReader inp = new BufferedReader(new InputStreamReader(System.in));
66 |
67 | String line;
68 |
69 | System.out.print("> ");
70 | while ((line = inp.readLine()) != null && !line.equals("exit")) {
71 | int ret = L.LloadBuffer(line.getBytes(), "from console");
72 | if (ret == 0) {
73 | ret = L.pcall(0, 0, 0);
74 | }
75 | if (ret != 0) {
76 | System.err.println("Error on line: " + line);
77 | System.err.println(L.toString(-1));
78 | }
79 | System.out.print("> ");
80 | }
81 |
82 | L.close();
83 | } catch (Exception e) {
84 | e.printStackTrace();
85 | }
86 |
87 | }
88 | }
--------------------------------------------------------------------------------
/luajava/src/main/java/org/keplerproject/luajava/JavaFunction.java:
--------------------------------------------------------------------------------
1 | /*
2 | * $Id: JavaFunction.java,v 1.6 2006/12/22 14:06:40 thiago Exp $
3 | * Copyright (C) 2003-2007 Kepler Project.
4 | *
5 | * Permission is hereby granted, free of charge, to any person obtaining
6 | * a copy of this software and associated documentation files (the
7 | * "Software"), to deal in the Software without restriction, including
8 | * without limitation the rights to use, copy, modify, merge, publish,
9 | * distribute, sublicense, and/or sell copies of the Software, and to
10 | * permit persons to whom the Software is furnished to do so, subject to
11 | * the following conditions:
12 | *
13 | * The above copyright notice and this permission notice shall be
14 | * included in all copies or substantial portions of the Software.
15 | *
16 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
17 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
18 | * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
19 | * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
20 | * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
21 | * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
22 | * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
23 | */
24 |
25 | package org.keplerproject.luajava;
26 |
27 | /**
28 | * JavaFunction is a class that can be used to implement a Lua function in Java.
29 | * JavaFunction is an abstract class, so in order to use it you must extend this
30 | * class and implement the execute method. This execute
31 | * method is the method that will be called when you call the function from Lua.
32 | * To register the JavaFunction in Lua use the method register(String name).
33 | */
34 | public abstract class JavaFunction {
35 |
36 | /**
37 | * This is the state in which this function will exist.
38 | */
39 | protected LuaState L;
40 |
41 | /**
42 | * This method is called from Lua. Any parameters can be taken with
43 | * getParam. A reference to the JavaFunctionWrapper itself is
44 | * always the first parameter received. Values passed back as results
45 | * of the function must be pushed onto the stack.
46 | *
47 | * @return The number of values pushed onto the stack.
48 | */
49 | public abstract int execute() throws LuaException;
50 |
51 | /**
52 | * Constructor that receives a LuaState.
53 | *
54 | * @param L LuaState object associated with this JavaFunction object
55 | */
56 | public JavaFunction(LuaState L) {
57 | this.L = L;
58 | }
59 |
60 | /**
61 | * Returns a parameter received from Lua. Parameters are numbered from 1.
62 | * A reference to the JavaFunction itself is always the first parameter
63 | * received (the same as this).
64 | *
65 | * @param idx Index of the parameter.
66 | * @return Reference to parameter.
67 | * @see LuaObject
68 | */
69 | public LuaObject getParam(int idx) {
70 | return L.getLuaObject(idx);
71 | }
72 |
73 | /**
74 | * Register a JavaFunction with a given name. This method registers in a
75 | * global variable the JavaFunction specified.
76 | *
77 | * @param name name of the function.
78 | */
79 | public void register(String name) throws LuaException {
80 | synchronized (L) {
81 | L.pushJavaFunction(this);
82 | L.setGlobal(name);
83 | }
84 | }
85 | }
86 |
--------------------------------------------------------------------------------
/luajava/src/main/java/org/keplerproject/luajava/LuaException.java:
--------------------------------------------------------------------------------
1 | /*
2 | * $Id: LuaException.java,v 1.6 2006/12/22 14:06:40 thiago Exp $
3 | * Copyright (C) 2003-2007 Kepler Project.
4 | *
5 | * Permission is hereby granted, free of charge, to any person obtaining
6 | * a copy of this software and associated documentation files (the
7 | * "Software"), to deal in the Software without restriction, including
8 | * without limitation the rights to use, copy, modify, merge, publish,
9 | * distribute, sublicense, and/or sell copies of the Software, and to
10 | * permit persons to whom the Software is furnished to do so, subject to
11 | * the following conditions:
12 | *
13 | * The above copyright notice and this permission notice shall be
14 | * included in all copies or substantial portions of the Software.
15 | *
16 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
17 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
18 | * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
19 | * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
20 | * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
21 | * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
22 | * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
23 | */
24 |
25 | package org.keplerproject.luajava;
26 |
27 | /**
28 | * LuaJava exception
29 | *
30 | * @author Thiago Ponte
31 | */
32 | public class LuaException extends Exception {
33 | /**
34 | *
35 | */
36 | private static final long serialVersionUID = 1L;
37 |
38 | public LuaException(String str) {
39 | super(str);
40 | }
41 |
42 | /**
43 | * Will work only on Java 1.4 or later.
44 | * To work with Java 1.3, comment the first line and uncomment the second one.
45 | */
46 | public LuaException(Exception e) {
47 | super((e.getCause() != null) ? e.getCause() : e);
48 | //super(e.getMessage());
49 | }
50 | }
--------------------------------------------------------------------------------
/luajava/src/main/java/org/keplerproject/luajava/LuaInvocationHandler.java:
--------------------------------------------------------------------------------
1 | /*
2 | * $Id: LuaInvocationHandler.java,v 1.4 2006/12/22 14:06:40 thiago Exp $
3 | * Copyright (C) 2003-2007 Kepler Project.
4 | *
5 | * Permission is hereby granted, free of charge, to any person obtaining
6 | * a copy of this software and associated documentation files (the
7 | * "Software"), to deal in the Software without restriction, including
8 | * without limitation the rights to use, copy, modify, merge, publish,
9 | * distribute, sublicense, and/or sell copies of the Software, and to
10 | * permit persons to whom the Software is furnished to do so, subject to
11 | * the following conditions:
12 | *
13 | * The above copyright notice and this permission notice shall be
14 | * included in all copies or substantial portions of the Software.
15 | *
16 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
17 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
18 | * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
19 | * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
20 | * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
21 | * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
22 | * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
23 | */
24 |
25 | package org.keplerproject.luajava;
26 |
27 | import java.lang.reflect.InvocationHandler;
28 | import java.lang.reflect.Method;
29 |
30 | /**
31 | * Class that implements the InvocationHandler interface.
32 | * This class is used in the LuaJava's proxy system.
33 | * When a proxy object is accessed, the method invoked is
34 | * called from Lua
35 | *
36 | * @author Rizzato
37 | * @author Thiago Ponte
38 | */
39 | public class LuaInvocationHandler implements InvocationHandler {
40 | private LuaObject obj;
41 |
42 |
43 | public LuaInvocationHandler(LuaObject obj) {
44 | this.obj = obj;
45 | }
46 |
47 | /**
48 | * Function called when a proxy object function is invoked.
49 | */
50 | public Object invoke(Object proxy, Method method, Object[] args) throws LuaException {
51 | synchronized (obj.L) {
52 | String methodName = method.getName();
53 | LuaObject func = obj.getField(methodName);
54 |
55 | if (func.isNil()) {
56 | return null;
57 | }
58 |
59 | Class retType = method.getReturnType();
60 | Object ret;
61 |
62 | // Checks if returned type is void. if it is returns null.
63 | if (retType.equals(Void.class) || retType.equals(void.class)) {
64 | func.call(args, 0);
65 | ret = null;
66 | } else {
67 | ret = func.call(args, 1)[0];
68 | if (ret != null && ret instanceof Double) {
69 | ret = LuaState.convertLuaNumber((Double) ret, retType);
70 | }
71 | }
72 |
73 | return ret;
74 | }
75 | }
76 | }
77 |
--------------------------------------------------------------------------------
/luajava/src/main/java/org/keplerproject/luajava/LuaStateFactory.java:
--------------------------------------------------------------------------------
1 | /*
2 | * $Id: LuaStateFactory.java,v 1.4 2006/12/22 14:06:40 thiago Exp $
3 | * Copyright (C) 2003-2007 Kepler Project.
4 | *
5 | * Permission is hereby granted, free of charge, to any person obtaining
6 | * a copy of this software and associated documentation files (the
7 | * "Software"), to deal in the Software without restriction, including
8 | * without limitation the rights to use, copy, modify, merge, publish,
9 | * distribute, sublicense, and/or sell copies of the Software, and to
10 | * permit persons to whom the Software is furnished to do so, subject to
11 | * the following conditions:
12 | *
13 | * The above copyright notice and this permission notice shall be
14 | * included in all copies or substantial portions of the Software.
15 | *
16 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
17 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
18 | * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
19 | * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
20 | * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
21 | * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
22 | * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
23 | */
24 |
25 | package org.keplerproject.luajava;
26 |
27 | import java.util.ArrayList;
28 | import java.util.List;
29 |
30 | /**
31 | * This class is responsible for instantiating new LuaStates.
32 | * When a new LuaState is instantiated it is put into a List
33 | * and an index is returned. This index is registred in Lua
34 | * and it is used to find the right LuaState when lua calls
35 | * a Java Function.
36 | *
37 | * @author Thiago Ponte
38 | */
39 | public final class LuaStateFactory {
40 |
41 | private final static String LUAJAVA_LIB = "luajava";
42 | private final static boolean isLuaLibLoaded;
43 |
44 | /**
45 | * Opens the library containing the luajava API
46 | */
47 | static {
48 | boolean loaded = false;
49 | try {
50 | System.loadLibrary(LUAJAVA_LIB);
51 | loaded = true;
52 | } catch (UnsatisfiedLinkError e) {
53 | e.printStackTrace();
54 | }
55 | isLuaLibLoaded = loaded;
56 | }
57 |
58 | /**
59 | * Array with all luaState's instances
60 | */
61 | private static final List states = new ArrayList<>();
62 |
63 | /**
64 | * Non-public constructor.
65 | */
66 | private LuaStateFactory() {
67 | }
68 |
69 | /**
70 | * Method that creates a new instance of LuaState
71 | *
72 | * @return LuaState
73 | */
74 | public synchronized static LuaState newLuaState() {
75 | if(!isLuaLibLoaded) {
76 | return null;
77 | }
78 | int i = getNextStateIndex();
79 | LuaState L = new LuaState(i);
80 |
81 | states.add(i, L);
82 |
83 | return L;
84 | }
85 |
86 | /**
87 | * Returns a existing instance of LuaState
88 | *
89 | * @param index
90 | * @return LuaState
91 | */
92 | public synchronized static LuaState getExistingState(int index) {
93 | return (LuaState) states.get(index);
94 | }
95 |
96 | /**
97 | * Receives a existing LuaState and checks if it exists in the states list.
98 | * If it doesn't exist adds it to the list.
99 | *
100 | * @param L
101 | * @return int
102 | */
103 | public synchronized static int insertLuaState(LuaState L) {
104 | int i;
105 | for (i = 0; i < states.size(); i++) {
106 | LuaState state = (LuaState) states.get(i);
107 |
108 | if (state != null) {
109 | if (state.getCPtrPeer() == L.getCPtrPeer())
110 | return i;
111 | }
112 | }
113 |
114 | i = getNextStateIndex();
115 |
116 | states.set(i, L);
117 |
118 | return i;
119 | }
120 |
121 | /**
122 | * removes the luaState from the states list
123 | *
124 | * @param idx
125 | */
126 | public synchronized static void removeLuaState(int idx) {
127 | states.add(idx, null);
128 | }
129 |
130 | /**
131 | * Get next available index
132 | *
133 | * @return int
134 | */
135 | private synchronized static int getNextStateIndex() {
136 | int i;
137 | for (i = 0; i < states.size() && states.get(i) != null; i++) ;
138 |
139 | return i;
140 | }
141 | }
--------------------------------------------------------------------------------
/luajava/src/main/jni/Android.mk:
--------------------------------------------------------------------------------
1 | include $(call all-subdir-makefiles)
2 |
3 |
--------------------------------------------------------------------------------
/luajava/src/main/jni/Application.mk:
--------------------------------------------------------------------------------
1 | APP_ABI := all
2 | #APP_ABI := armeabi , armeabi-v7a #, arm64-v8a, mips, mips64, x86, x86_64
3 |
4 | APP_CPPFLAGS += \
5 | -D__STDC_CONSTANT_MACROS \
6 | -D__STDC_LIMIT_MACROS \
7 | -D__STDC_FORMAT_MACROS \
8 | -D__DEBUG__ \
9 | -std=gnu99 \
10 | -Wno-pmf-conversions \
11 | -fno-rtti \
12 | -fno-exceptions \
13 | -Dtypeof=decltype \
14 |
15 | APP_CPPFLAGS += -O2 -Wall -Wextra -flto=3 -fvisibility=hidden
16 |
17 | APP_LDFLAGS += \
18 | -Wl,--exclude-libs=ALL \
19 | -flto=3 \
20 |
21 | APP_STL := gnustl_static
22 |
23 | APP_OPTIM := release
24 |
25 | APP_MODULES := liblua luajava
26 |
27 | NDK_TOOLCHAIN_VERSION := 4.9
28 | APP_PLATFORM := android-14
--------------------------------------------------------------------------------
/luajava/src/main/jni/lua/Android.mk:
--------------------------------------------------------------------------------
1 | LOCAL_PATH := $(call my-dir)
2 |
3 | include $(CLEAR_VARS)
4 |
5 | LOCAL_MODULE := lua
6 | LOCAL_SRC_FILES := lapi.c lauxlib.c lbaselib.c lbitlib.c lcode.c lcorolib.c lctype.c ldblib.c ldebug.c ldo.c ldump.c lfunc.c lgc.c linit.c liolib.c llex.c lmathlib.c lmem.c loadlib.c lobject.c lopcodes.c loslib.c lparser.c lstate.c lstring.c lstrlib.c ltable.c ltablib.c ltm.c lundump.c lutf8lib.c lvm.c lzio.c
7 |
8 | LOCAL_CFLAGS += -DLUA_DL_DLOPEN -DLUA_USE_C89 -DLUA_COMPAT_5_1 -DLUA_COMPAT_5_2 -DLUA_USE_LINUX
9 |
10 | LOCAL_LDLIBS += -L$(SYSROOT)/usr/lib -llog -ldl
11 | LOCAL_CFLAGS += -pie -fPIE
12 | LOCAL_LDFLAGS += -pie -fPIE
13 |
14 | LOCAL_LDLIBS := -ld -lm
15 |
16 | include $(BUILD_STATIC_LIBRARY)
17 |
--------------------------------------------------------------------------------
/luajava/src/main/jni/lua/Makefile:
--------------------------------------------------------------------------------
1 | # Makefile for building Lua
2 | # See ../doc/readme.html for installation and customization instructions.
3 |
4 | # == CHANGE THE SETTINGS BELOW TO SUIT YOUR ENVIRONMENT =======================
5 |
6 | # Your platform. See PLATS for possible values.
7 | PLAT= none
8 |
9 | CC= gcc -std=gnu99
10 | CFLAGS= -O2 -Wall -Wextra -DLUA_COMPAT_5_2 $(SYSCFLAGS) $(MYCFLAGS)
11 | LDFLAGS= $(SYSLDFLAGS) $(MYLDFLAGS)
12 | LIBS= -lm $(SYSLIBS) $(MYLIBS)
13 |
14 | AR= ar rcu
15 | RANLIB= ranlib
16 | RM= rm -f
17 |
18 | SYSCFLAGS=
19 | SYSLDFLAGS=
20 | SYSLIBS=
21 |
22 | MYCFLAGS=
23 | MYLDFLAGS=
24 | MYLIBS=
25 | MYOBJS=
26 |
27 | # == END OF USER SETTINGS -- NO NEED TO CHANGE ANYTHING BELOW THIS LINE =======
28 |
29 | PLATS= aix bsd c89 freebsd generic linux macosx mingw posix solaris
30 |
31 | LUA_A= liblua.a
32 | CORE_O= lapi.o lcode.o lctype.o ldebug.o ldo.o ldump.o lfunc.o lgc.o llex.o \
33 | lmem.o lobject.o lopcodes.o lparser.o lstate.o lstring.o ltable.o \
34 | ltm.o lundump.o lvm.o lzio.o
35 | LIB_O= lauxlib.o lbaselib.o lbitlib.o lcorolib.o ldblib.o liolib.o \
36 | lmathlib.o loslib.o lstrlib.o ltablib.o lutf8lib.o loadlib.o linit.o
37 | BASE_O= $(CORE_O) $(LIB_O) $(MYOBJS)
38 |
39 | LUA_T= lua
40 | LUA_O= lua.o
41 |
42 | LUAC_T= luac
43 | LUAC_O= luac.o
44 |
45 | ALL_O= $(BASE_O) $(LUA_O) $(LUAC_O)
46 | ALL_T= $(LUA_A) $(LUA_T) $(LUAC_T)
47 | ALL_A= $(LUA_A)
48 |
49 | # Targets start here.
50 | default: $(PLAT)
51 |
52 | all: $(ALL_T)
53 |
54 | o: $(ALL_O)
55 |
56 | a: $(ALL_A)
57 |
58 | $(LUA_A): $(BASE_O)
59 | $(AR) $@ $(BASE_O)
60 | $(RANLIB) $@
61 |
62 | $(LUA_T): $(LUA_O) $(LUA_A)
63 | $(CC) -o $@ $(LDFLAGS) $(LUA_O) $(LUA_A) $(LIBS)
64 |
65 | $(LUAC_T): $(LUAC_O) $(LUA_A)
66 | $(CC) -o $@ $(LDFLAGS) $(LUAC_O) $(LUA_A) $(LIBS)
67 |
68 | clean:
69 | $(RM) $(ALL_T) $(ALL_O)
70 |
71 | depend:
72 | @$(CC) $(CFLAGS) -MM l*.c
73 |
74 | echo:
75 | @echo "PLAT= $(PLAT)"
76 | @echo "CC= $(CC)"
77 | @echo "CFLAGS= $(CFLAGS)"
78 | @echo "LDFLAGS= $(SYSLDFLAGS)"
79 | @echo "LIBS= $(LIBS)"
80 | @echo "AR= $(AR)"
81 | @echo "RANLIB= $(RANLIB)"
82 | @echo "RM= $(RM)"
83 |
84 | # Convenience targets for popular platforms
85 | ALL= all
86 |
87 | none:
88 | @echo "Please do 'make PLATFORM' where PLATFORM is one of these:"
89 | @echo " $(PLATS)"
90 |
91 | aix:
92 | $(MAKE) $(ALL) CC="xlc" CFLAGS="-O2 -DLUA_USE_POSIX -DLUA_USE_DLOPEN" SYSLIBS="-ldl" SYSLDFLAGS="-brtl -bexpall"
93 |
94 | bsd:
95 | $(MAKE) $(ALL) SYSCFLAGS="-DLUA_USE_POSIX -DLUA_USE_DLOPEN" SYSLIBS="-Wl,-E"
96 |
97 | c89:
98 | $(MAKE) $(ALL) SYSCFLAGS="-DLUA_USE_C89" CC="gcc -std=c89"
99 | @echo ''
100 | @echo '*** C89 does not guarantee 64-bit integers for Lua.'
101 | @echo ''
102 |
103 |
104 | freebsd:
105 | $(MAKE) $(ALL) SYSCFLAGS="-DLUA_USE_LINUX" SYSLIBS="-Wl,-E -lreadline"
106 |
107 | generic: $(ALL)
108 |
109 | linux:
110 | $(MAKE) $(ALL) SYSCFLAGS="-DLUA_USE_LINUX" SYSLIBS="-Wl,-E -ldl -lreadline"
111 |
112 | macosx:
113 | $(MAKE) $(ALL) SYSCFLAGS="-DLUA_USE_MACOSX" SYSLIBS="-lreadline" CC=cc
114 |
115 | mingw:
116 | $(MAKE) "LUA_A=lua53.dll" "LUA_T=lua.exe" \
117 | "AR=$(CC) -shared -o" "RANLIB=strip --strip-unneeded" \
118 | "SYSCFLAGS=-DLUA_BUILD_AS_DLL" "SYSLIBS=" "SYSLDFLAGS=-s" lua.exe
119 | $(MAKE) "LUAC_T=luac.exe" luac.exe
120 |
121 | posix:
122 | $(MAKE) $(ALL) SYSCFLAGS="-DLUA_USE_POSIX"
123 |
124 | solaris:
125 | $(MAKE) $(ALL) SYSCFLAGS="-DLUA_USE_POSIX -DLUA_USE_DLOPEN -D_REENTRANT" SYSLIBS="-ldl"
126 |
127 | # list targets that do not create files (but not all makes understand .PHONY)
128 | .PHONY: all $(PLATS) default o a clean depend echo none
129 |
130 | # DO NOT DELETE
131 |
132 | lapi.o: lapi.c lprefix.h lua.h luaconf.h lapi.h llimits.h lstate.h \
133 | lobject.h ltm.h lzio.h lmem.h ldebug.h ldo.h lfunc.h lgc.h lstring.h \
134 | ltable.h lundump.h lvm.h
135 | lauxlib.o: lauxlib.c lprefix.h lua.h luaconf.h lauxlib.h
136 | lbaselib.o: lbaselib.c lprefix.h lua.h luaconf.h lauxlib.h lualib.h
137 | lbitlib.o: lbitlib.c lprefix.h lua.h luaconf.h lauxlib.h lualib.h
138 | lcode.o: lcode.c lprefix.h lua.h luaconf.h lcode.h llex.h lobject.h \
139 | llimits.h lzio.h lmem.h lopcodes.h lparser.h ldebug.h lstate.h ltm.h \
140 | ldo.h lgc.h lstring.h ltable.h lvm.h
141 | lcorolib.o: lcorolib.c lprefix.h lua.h luaconf.h lauxlib.h lualib.h
142 | lctype.o: lctype.c lprefix.h lctype.h lua.h luaconf.h llimits.h
143 | ldblib.o: ldblib.c lprefix.h lua.h luaconf.h lauxlib.h lualib.h
144 | ldebug.o: ldebug.c lprefix.h lua.h luaconf.h lapi.h llimits.h lstate.h \
145 | lobject.h ltm.h lzio.h lmem.h lcode.h llex.h lopcodes.h lparser.h \
146 | ldebug.h ldo.h lfunc.h lstring.h lgc.h ltable.h lvm.h
147 | ldo.o: ldo.c lprefix.h lua.h luaconf.h lapi.h llimits.h lstate.h \
148 | lobject.h ltm.h lzio.h lmem.h ldebug.h ldo.h lfunc.h lgc.h lopcodes.h \
149 | lparser.h lstring.h ltable.h lundump.h lvm.h
150 | ldump.o: ldump.c lprefix.h lua.h luaconf.h lobject.h llimits.h lstate.h \
151 | ltm.h lzio.h lmem.h lundump.h
152 | lfunc.o: lfunc.c lprefix.h lua.h luaconf.h lfunc.h lobject.h llimits.h \
153 | lgc.h lstate.h ltm.h lzio.h lmem.h
154 | lgc.o: lgc.c lprefix.h lua.h luaconf.h ldebug.h lstate.h lobject.h \
155 | llimits.h ltm.h lzio.h lmem.h ldo.h lfunc.h lgc.h lstring.h ltable.h
156 | linit.o: linit.c lprefix.h lua.h luaconf.h lualib.h lauxlib.h
157 | liolib.o: liolib.c lprefix.h lua.h luaconf.h lauxlib.h lualib.h
158 | llex.o: llex.c lprefix.h lua.h luaconf.h lctype.h llimits.h ldebug.h \
159 | lstate.h lobject.h ltm.h lzio.h lmem.h ldo.h lgc.h llex.h lparser.h \
160 | lstring.h ltable.h
161 | lmathlib.o: lmathlib.c lprefix.h lua.h luaconf.h lauxlib.h lualib.h
162 | lmem.o: lmem.c lprefix.h lua.h luaconf.h ldebug.h lstate.h lobject.h \
163 | llimits.h ltm.h lzio.h lmem.h ldo.h lgc.h
164 | loadlib.o: loadlib.c lprefix.h lua.h luaconf.h lauxlib.h lualib.h
165 | lobject.o: lobject.c lprefix.h lua.h luaconf.h lctype.h llimits.h \
166 | ldebug.h lstate.h lobject.h ltm.h lzio.h lmem.h ldo.h lstring.h lgc.h \
167 | lvm.h
168 | lopcodes.o: lopcodes.c lprefix.h lopcodes.h llimits.h lua.h luaconf.h
169 | loslib.o: loslib.c lprefix.h lua.h luaconf.h lauxlib.h lualib.h
170 | lparser.o: lparser.c lprefix.h lua.h luaconf.h lcode.h llex.h lobject.h \
171 | llimits.h lzio.h lmem.h lopcodes.h lparser.h ldebug.h lstate.h ltm.h \
172 | ldo.h lfunc.h lstring.h lgc.h ltable.h
173 | lstate.o: lstate.c lprefix.h lua.h luaconf.h lapi.h llimits.h lstate.h \
174 | lobject.h ltm.h lzio.h lmem.h ldebug.h ldo.h lfunc.h lgc.h llex.h \
175 | lstring.h ltable.h
176 | lstring.o: lstring.c lprefix.h lua.h luaconf.h ldebug.h lstate.h \
177 | lobject.h llimits.h ltm.h lzio.h lmem.h ldo.h lstring.h lgc.h
178 | lstrlib.o: lstrlib.c lprefix.h lua.h luaconf.h lauxlib.h lualib.h
179 | ltable.o: ltable.c lprefix.h lua.h luaconf.h ldebug.h lstate.h lobject.h \
180 | llimits.h ltm.h lzio.h lmem.h ldo.h lgc.h lstring.h ltable.h lvm.h
181 | ltablib.o: ltablib.c lprefix.h lua.h luaconf.h lauxlib.h lualib.h
182 | ltm.o: ltm.c lprefix.h lua.h luaconf.h ldebug.h lstate.h lobject.h \
183 | llimits.h ltm.h lzio.h lmem.h ldo.h lstring.h lgc.h ltable.h lvm.h
184 | lua.o: lua.c lprefix.h lua.h luaconf.h lauxlib.h lualib.h
185 | luac.o: luac.c lprefix.h lua.h luaconf.h lauxlib.h lobject.h llimits.h \
186 | lstate.h ltm.h lzio.h lmem.h lundump.h ldebug.h lopcodes.h
187 | lundump.o: lundump.c lprefix.h lua.h luaconf.h ldebug.h lstate.h \
188 | lobject.h llimits.h ltm.h lzio.h lmem.h ldo.h lfunc.h lstring.h lgc.h \
189 | lundump.h
190 | lutf8lib.o: lutf8lib.c lprefix.h lua.h luaconf.h lauxlib.h lualib.h
191 | lvm.o: lvm.c lprefix.h lua.h luaconf.h ldebug.h lstate.h lobject.h \
192 | llimits.h ltm.h lzio.h lmem.h ldo.h lfunc.h lgc.h lopcodes.h lstring.h \
193 | ltable.h lvm.h
194 | lzio.o: lzio.c lprefix.h lua.h luaconf.h llimits.h lmem.h lstate.h \
195 | lobject.h ltm.h lzio.h
196 |
197 | # (end of Makefile)
198 |
--------------------------------------------------------------------------------
/luajava/src/main/jni/lua/lapi.h:
--------------------------------------------------------------------------------
1 | /*
2 | ** $Id: lapi.h,v 2.9 2015/03/06 19:49:50 roberto Exp $
3 | ** Auxiliary functions from Lua API
4 | ** See Copyright Notice in lua.h
5 | */
6 |
7 | #ifndef lapi_h
8 | #define lapi_h
9 |
10 |
11 | #include "llimits.h"
12 | #include "lstate.h"
13 |
14 | #define api_incr_top(L) {L->top++; api_check(L, L->top <= L->ci->top, \
15 | "stack overflow");}
16 |
17 | #define adjustresults(L,nres) \
18 | { if ((nres) == LUA_MULTRET && L->ci->top < L->top) L->ci->top = L->top; }
19 |
20 | #define api_checknelems(L,n) api_check(L, (n) < (L->top - L->ci->func), \
21 | "not enough elements in the stack")
22 |
23 |
24 | #endif
25 |
--------------------------------------------------------------------------------
/luajava/src/main/jni/lua/lbitlib.c:
--------------------------------------------------------------------------------
1 | /*
2 | ** $Id: lbitlib.c,v 1.30 2015/11/11 19:08:09 roberto Exp $
3 | ** Standard library for bitwise operations
4 | ** See Copyright Notice in lua.h
5 | */
6 |
7 | #define lbitlib_c
8 | #define LUA_LIB
9 |
10 | #include "lprefix.h"
11 |
12 |
13 | #include "lua.h"
14 |
15 | #include "lauxlib.h"
16 | #include "lualib.h"
17 |
18 |
19 | #if defined(LUA_COMPAT_BITLIB) /* { */
20 |
21 |
22 | #define pushunsigned(L,n) lua_pushinteger(L, (lua_Integer)(n))
23 | #define checkunsigned(L,i) ((lua_Unsigned)luaL_checkinteger(L,i))
24 |
25 |
26 | /* number of bits to consider in a number */
27 | #if !defined(LUA_NBITS)
28 | #define LUA_NBITS 32
29 | #endif
30 |
31 |
32 | /*
33 | ** a lua_Unsigned with its first LUA_NBITS bits equal to 1. (Shift must
34 | ** be made in two parts to avoid problems when LUA_NBITS is equal to the
35 | ** number of bits in a lua_Unsigned.)
36 | */
37 | #define ALLONES (~(((~(lua_Unsigned)0) << (LUA_NBITS - 1)) << 1))
38 |
39 |
40 | /* macro to trim extra bits */
41 | #define trim(x) ((x) & ALLONES)
42 |
43 |
44 | /* builds a number with 'n' ones (1 <= n <= LUA_NBITS) */
45 | #define mask(n) (~((ALLONES << 1) << ((n) - 1)))
46 |
47 |
48 |
49 | static lua_Unsigned andaux (lua_State *L) {
50 | int i, n = lua_gettop(L);
51 | lua_Unsigned r = ~(lua_Unsigned)0;
52 | for (i = 1; i <= n; i++)
53 | r &= checkunsigned(L, i);
54 | return trim(r);
55 | }
56 |
57 |
58 | static int b_and (lua_State *L) {
59 | lua_Unsigned r = andaux(L);
60 | pushunsigned(L, r);
61 | return 1;
62 | }
63 |
64 |
65 | static int b_test (lua_State *L) {
66 | lua_Unsigned r = andaux(L);
67 | lua_pushboolean(L, r != 0);
68 | return 1;
69 | }
70 |
71 |
72 | static int b_or (lua_State *L) {
73 | int i, n = lua_gettop(L);
74 | lua_Unsigned r = 0;
75 | for (i = 1; i <= n; i++)
76 | r |= checkunsigned(L, i);
77 | pushunsigned(L, trim(r));
78 | return 1;
79 | }
80 |
81 |
82 | static int b_xor (lua_State *L) {
83 | int i, n = lua_gettop(L);
84 | lua_Unsigned r = 0;
85 | for (i = 1; i <= n; i++)
86 | r ^= checkunsigned(L, i);
87 | pushunsigned(L, trim(r));
88 | return 1;
89 | }
90 |
91 |
92 | static int b_not (lua_State *L) {
93 | lua_Unsigned r = ~checkunsigned(L, 1);
94 | pushunsigned(L, trim(r));
95 | return 1;
96 | }
97 |
98 |
99 | static int b_shift (lua_State *L, lua_Unsigned r, lua_Integer i) {
100 | if (i < 0) { /* shift right? */
101 | i = -i;
102 | r = trim(r);
103 | if (i >= LUA_NBITS) r = 0;
104 | else r >>= i;
105 | }
106 | else { /* shift left */
107 | if (i >= LUA_NBITS) r = 0;
108 | else r <<= i;
109 | r = trim(r);
110 | }
111 | pushunsigned(L, r);
112 | return 1;
113 | }
114 |
115 |
116 | static int b_lshift (lua_State *L) {
117 | return b_shift(L, checkunsigned(L, 1), luaL_checkinteger(L, 2));
118 | }
119 |
120 |
121 | static int b_rshift (lua_State *L) {
122 | return b_shift(L, checkunsigned(L, 1), -luaL_checkinteger(L, 2));
123 | }
124 |
125 |
126 | static int b_arshift (lua_State *L) {
127 | lua_Unsigned r = checkunsigned(L, 1);
128 | lua_Integer i = luaL_checkinteger(L, 2);
129 | if (i < 0 || !(r & ((lua_Unsigned)1 << (LUA_NBITS - 1))))
130 | return b_shift(L, r, -i);
131 | else { /* arithmetic shift for 'negative' number */
132 | if (i >= LUA_NBITS) r = ALLONES;
133 | else
134 | r = trim((r >> i) | ~(trim(~(lua_Unsigned)0) >> i)); /* add signal bit */
135 | pushunsigned(L, r);
136 | return 1;
137 | }
138 | }
139 |
140 |
141 | static int b_rot (lua_State *L, lua_Integer d) {
142 | lua_Unsigned r = checkunsigned(L, 1);
143 | int i = d & (LUA_NBITS - 1); /* i = d % NBITS */
144 | r = trim(r);
145 | if (i != 0) /* avoid undefined shift of LUA_NBITS when i == 0 */
146 | r = (r << i) | (r >> (LUA_NBITS - i));
147 | pushunsigned(L, trim(r));
148 | return 1;
149 | }
150 |
151 |
152 | static int b_lrot (lua_State *L) {
153 | return b_rot(L, luaL_checkinteger(L, 2));
154 | }
155 |
156 |
157 | static int b_rrot (lua_State *L) {
158 | return b_rot(L, -luaL_checkinteger(L, 2));
159 | }
160 |
161 |
162 | /*
163 | ** get field and width arguments for field-manipulation functions,
164 | ** checking whether they are valid.
165 | ** ('luaL_error' called without 'return' to avoid later warnings about
166 | ** 'width' being used uninitialized.)
167 | */
168 | static int fieldargs (lua_State *L, int farg, int *width) {
169 | lua_Integer f = luaL_checkinteger(L, farg);
170 | lua_Integer w = luaL_optinteger(L, farg + 1, 1);
171 | luaL_argcheck(L, 0 <= f, farg, "field cannot be negative");
172 | luaL_argcheck(L, 0 < w, farg + 1, "width must be positive");
173 | if (f + w > LUA_NBITS)
174 | luaL_error(L, "trying to access non-existent bits");
175 | *width = (int)w;
176 | return (int)f;
177 | }
178 |
179 |
180 | static int b_extract (lua_State *L) {
181 | int w;
182 | lua_Unsigned r = trim(checkunsigned(L, 1));
183 | int f = fieldargs(L, 2, &w);
184 | r = (r >> f) & mask(w);
185 | pushunsigned(L, r);
186 | return 1;
187 | }
188 |
189 |
190 | static int b_replace (lua_State *L) {
191 | int w;
192 | lua_Unsigned r = trim(checkunsigned(L, 1));
193 | lua_Unsigned v = trim(checkunsigned(L, 2));
194 | int f = fieldargs(L, 3, &w);
195 | lua_Unsigned m = mask(w);
196 | r = (r & ~(m << f)) | ((v & m) << f);
197 | pushunsigned(L, r);
198 | return 1;
199 | }
200 |
201 |
202 | static const luaL_Reg bitlib[] = {
203 | {"arshift", b_arshift},
204 | {"band", b_and},
205 | {"bnot", b_not},
206 | {"bor", b_or},
207 | {"bxor", b_xor},
208 | {"btest", b_test},
209 | {"extract", b_extract},
210 | {"lrotate", b_lrot},
211 | {"lshift", b_lshift},
212 | {"replace", b_replace},
213 | {"rrotate", b_rrot},
214 | {"rshift", b_rshift},
215 | {NULL, NULL}
216 | };
217 |
218 |
219 |
220 | LUAMOD_API int luaopen_bit32 (lua_State *L) {
221 | luaL_newlib(L, bitlib);
222 | return 1;
223 | }
224 |
225 |
226 | #else /* }{ */
227 |
228 |
229 | LUAMOD_API int luaopen_bit32 (lua_State *L) {
230 | return luaL_error(L, "library 'bit32' has been deprecated");
231 | }
232 |
233 | #endif /* } */
234 |
--------------------------------------------------------------------------------
/luajava/src/main/jni/lua/lcode.h:
--------------------------------------------------------------------------------
1 | /*
2 | ** $Id: lcode.h,v 1.64 2016/01/05 16:22:37 roberto Exp $
3 | ** Code generator for Lua
4 | ** See Copyright Notice in lua.h
5 | */
6 |
7 | #ifndef lcode_h
8 | #define lcode_h
9 |
10 | #include "llex.h"
11 | #include "lobject.h"
12 | #include "lopcodes.h"
13 | #include "lparser.h"
14 |
15 |
16 | /*
17 | ** Marks the end of a patch list. It is an invalid value both as an absolute
18 | ** address, and as a list link (would link an element to itself).
19 | */
20 | #define NO_JUMP (-1)
21 |
22 |
23 | /*
24 | ** grep "ORDER OPR" if you change these enums (ORDER OP)
25 | */
26 | typedef enum BinOpr {
27 | OPR_ADD, OPR_SUB, OPR_MUL, OPR_MOD, OPR_POW,
28 | OPR_DIV,
29 | OPR_IDIV,
30 | OPR_BAND, OPR_BOR, OPR_BXOR,
31 | OPR_SHL, OPR_SHR,
32 | OPR_CONCAT,
33 | OPR_EQ, OPR_LT, OPR_LE,
34 | OPR_NE, OPR_GT, OPR_GE,
35 | OPR_AND, OPR_OR,
36 | OPR_NOBINOPR
37 | } BinOpr;
38 |
39 |
40 | typedef enum UnOpr { OPR_MINUS, OPR_BNOT, OPR_NOT, OPR_LEN, OPR_NOUNOPR } UnOpr;
41 |
42 |
43 | /* get (pointer to) instruction of given 'expdesc' */
44 | #define getinstruction(fs,e) ((fs)->f->code[(e)->u.info])
45 |
46 | #define luaK_codeAsBx(fs,o,A,sBx) luaK_codeABx(fs,o,A,(sBx)+MAXARG_sBx)
47 |
48 | #define luaK_setmultret(fs,e) luaK_setreturns(fs, e, LUA_MULTRET)
49 |
50 | #define luaK_jumpto(fs,t) luaK_patchlist(fs, luaK_jump(fs), t)
51 |
52 | LUAI_FUNC int luaK_codeABx (FuncState *fs, OpCode o, int A, unsigned int Bx);
53 | LUAI_FUNC int luaK_codeABC (FuncState *fs, OpCode o, int A, int B, int C);
54 | LUAI_FUNC int luaK_codek (FuncState *fs, int reg, int k);
55 | LUAI_FUNC void luaK_fixline (FuncState *fs, int line);
56 | LUAI_FUNC void luaK_nil (FuncState *fs, int from, int n);
57 | LUAI_FUNC void luaK_reserveregs (FuncState *fs, int n);
58 | LUAI_FUNC void luaK_checkstack (FuncState *fs, int n);
59 | LUAI_FUNC int luaK_stringK (FuncState *fs, TString *s);
60 | LUAI_FUNC int luaK_intK (FuncState *fs, lua_Integer n);
61 | LUAI_FUNC void luaK_dischargevars (FuncState *fs, expdesc *e);
62 | LUAI_FUNC int luaK_exp2anyreg (FuncState *fs, expdesc *e);
63 | LUAI_FUNC void luaK_exp2anyregup (FuncState *fs, expdesc *e);
64 | LUAI_FUNC void luaK_exp2nextreg (FuncState *fs, expdesc *e);
65 | LUAI_FUNC void luaK_exp2val (FuncState *fs, expdesc *e);
66 | LUAI_FUNC int luaK_exp2RK (FuncState *fs, expdesc *e);
67 | LUAI_FUNC void luaK_self (FuncState *fs, expdesc *e, expdesc *key);
68 | LUAI_FUNC void luaK_indexed (FuncState *fs, expdesc *t, expdesc *k);
69 | LUAI_FUNC void luaK_goiftrue (FuncState *fs, expdesc *e);
70 | LUAI_FUNC void luaK_goiffalse (FuncState *fs, expdesc *e);
71 | LUAI_FUNC void luaK_storevar (FuncState *fs, expdesc *var, expdesc *e);
72 | LUAI_FUNC void luaK_setreturns (FuncState *fs, expdesc *e, int nresults);
73 | LUAI_FUNC void luaK_setoneret (FuncState *fs, expdesc *e);
74 | LUAI_FUNC int luaK_jump (FuncState *fs);
75 | LUAI_FUNC void luaK_ret (FuncState *fs, int first, int nret);
76 | LUAI_FUNC void luaK_patchlist (FuncState *fs, int list, int target);
77 | LUAI_FUNC void luaK_patchtohere (FuncState *fs, int list);
78 | LUAI_FUNC void luaK_patchclose (FuncState *fs, int list, int level);
79 | LUAI_FUNC void luaK_concat (FuncState *fs, int *l1, int l2);
80 | LUAI_FUNC int luaK_getlabel (FuncState *fs);
81 | LUAI_FUNC void luaK_prefix (FuncState *fs, UnOpr op, expdesc *v, int line);
82 | LUAI_FUNC void luaK_infix (FuncState *fs, BinOpr op, expdesc *v);
83 | LUAI_FUNC void luaK_posfix (FuncState *fs, BinOpr op, expdesc *v1,
84 | expdesc *v2, int line);
85 | LUAI_FUNC void luaK_setlist (FuncState *fs, int base, int nelems, int tostore);
86 |
87 |
88 | #endif
89 |
--------------------------------------------------------------------------------
/luajava/src/main/jni/lua/lcorolib.c:
--------------------------------------------------------------------------------
1 | /*
2 | ** $Id: lcorolib.c,v 1.10 2016/04/11 19:19:55 roberto Exp $
3 | ** Coroutine Library
4 | ** See Copyright Notice in lua.h
5 | */
6 |
7 | #define lcorolib_c
8 | #define LUA_LIB
9 |
10 | #include "lprefix.h"
11 |
12 |
13 | #include
14 |
15 | #include "lua.h"
16 |
17 | #include "lauxlib.h"
18 | #include "lualib.h"
19 |
20 |
21 | static lua_State *getco (lua_State *L) {
22 | lua_State *co = lua_tothread(L, 1);
23 | luaL_argcheck(L, co, 1, "thread expected");
24 | return co;
25 | }
26 |
27 |
28 | static int auxresume (lua_State *L, lua_State *co, int narg) {
29 | int status;
30 | if (!lua_checkstack(co, narg)) {
31 | lua_pushliteral(L, "too many arguments to resume");
32 | return -1; /* error flag */
33 | }
34 | if (lua_status(co) == LUA_OK && lua_gettop(co) == 0) {
35 | lua_pushliteral(L, "cannot resume dead coroutine");
36 | return -1; /* error flag */
37 | }
38 | lua_xmove(L, co, narg);
39 | status = lua_resume(co, L, narg);
40 | if (status == LUA_OK || status == LUA_YIELD) {
41 | int nres = lua_gettop(co);
42 | if (!lua_checkstack(L, nres + 1)) {
43 | lua_pop(co, nres); /* remove results anyway */
44 | lua_pushliteral(L, "too many results to resume");
45 | return -1; /* error flag */
46 | }
47 | lua_xmove(co, L, nres); /* move yielded values */
48 | return nres;
49 | }
50 | else {
51 | lua_xmove(co, L, 1); /* move error message */
52 | return -1; /* error flag */
53 | }
54 | }
55 |
56 |
57 | static int luaB_coresume (lua_State *L) {
58 | lua_State *co = getco(L);
59 | int r;
60 | r = auxresume(L, co, lua_gettop(L) - 1);
61 | if (r < 0) {
62 | lua_pushboolean(L, 0);
63 | lua_insert(L, -2);
64 | return 2; /* return false + error message */
65 | }
66 | else {
67 | lua_pushboolean(L, 1);
68 | lua_insert(L, -(r + 1));
69 | return r + 1; /* return true + 'resume' returns */
70 | }
71 | }
72 |
73 |
74 | static int luaB_auxwrap (lua_State *L) {
75 | lua_State *co = lua_tothread(L, lua_upvalueindex(1));
76 | int r = auxresume(L, co, lua_gettop(L));
77 | if (r < 0) {
78 | if (lua_type(L, -1) == LUA_TSTRING) { /* error object is a string? */
79 | luaL_where(L, 1); /* add extra info */
80 | lua_insert(L, -2);
81 | lua_concat(L, 2);
82 | }
83 | return lua_error(L); /* propagate error */
84 | }
85 | return r;
86 | }
87 |
88 |
89 | static int luaB_cocreate (lua_State *L) {
90 | lua_State *NL;
91 | luaL_checktype(L, 1, LUA_TFUNCTION);
92 | NL = lua_newthread(L);
93 | lua_pushvalue(L, 1); /* move function to top */
94 | lua_xmove(L, NL, 1); /* move function from L to NL */
95 | return 1;
96 | }
97 |
98 |
99 | static int luaB_cowrap (lua_State *L) {
100 | luaB_cocreate(L);
101 | lua_pushcclosure(L, luaB_auxwrap, 1);
102 | return 1;
103 | }
104 |
105 |
106 | static int luaB_yield (lua_State *L) {
107 | return lua_yield(L, lua_gettop(L));
108 | }
109 |
110 |
111 | static int luaB_costatus (lua_State *L) {
112 | lua_State *co = getco(L);
113 | if (L == co) lua_pushliteral(L, "running");
114 | else {
115 | switch (lua_status(co)) {
116 | case LUA_YIELD:
117 | lua_pushliteral(L, "suspended");
118 | break;
119 | case LUA_OK: {
120 | lua_Debug ar;
121 | if (lua_getstack(co, 0, &ar) > 0) /* does it have frames? */
122 | lua_pushliteral(L, "normal"); /* it is running */
123 | else if (lua_gettop(co) == 0)
124 | lua_pushliteral(L, "dead");
125 | else
126 | lua_pushliteral(L, "suspended"); /* initial state */
127 | break;
128 | }
129 | default: /* some error occurred */
130 | lua_pushliteral(L, "dead");
131 | break;
132 | }
133 | }
134 | return 1;
135 | }
136 |
137 |
138 | static int luaB_yieldable (lua_State *L) {
139 | lua_pushboolean(L, lua_isyieldable(L));
140 | return 1;
141 | }
142 |
143 |
144 | static int luaB_corunning (lua_State *L) {
145 | int ismain = lua_pushthread(L);
146 | lua_pushboolean(L, ismain);
147 | return 2;
148 | }
149 |
150 |
151 | static const luaL_Reg co_funcs[] = {
152 | {"create", luaB_cocreate},
153 | {"resume", luaB_coresume},
154 | {"running", luaB_corunning},
155 | {"status", luaB_costatus},
156 | {"wrap", luaB_cowrap},
157 | {"yield", luaB_yield},
158 | {"isyieldable", luaB_yieldable},
159 | {NULL, NULL}
160 | };
161 |
162 |
163 |
164 | LUAMOD_API int luaopen_coroutine (lua_State *L) {
165 | luaL_newlib(L, co_funcs);
166 | return 1;
167 | }
168 |
169 |
--------------------------------------------------------------------------------
/luajava/src/main/jni/lua/lctype.c:
--------------------------------------------------------------------------------
1 | /*
2 | ** $Id: lctype.c,v 1.12 2014/11/02 19:19:04 roberto Exp $
3 | ** 'ctype' functions for Lua
4 | ** See Copyright Notice in lua.h
5 | */
6 |
7 | #define lctype_c
8 | #define LUA_CORE
9 |
10 | #include "lprefix.h"
11 |
12 |
13 | #include "lctype.h"
14 |
15 | #if !LUA_USE_CTYPE /* { */
16 |
17 | #include
18 |
19 | LUAI_DDEF const lu_byte luai_ctype_[UCHAR_MAX + 2] = {
20 | 0x00, /* EOZ */
21 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0. */
22 | 0x00, 0x08, 0x08, 0x08, 0x08, 0x08, 0x00, 0x00,
23 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 1. */
24 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
25 | 0x0c, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, /* 2. */
26 | 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
27 | 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, /* 3. */
28 | 0x16, 0x16, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
29 | 0x04, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x05, /* 4. */
30 | 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
31 | 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, /* 5. */
32 | 0x05, 0x05, 0x05, 0x04, 0x04, 0x04, 0x04, 0x05,
33 | 0x04, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x05, /* 6. */
34 | 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
35 | 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, /* 7. */
36 | 0x05, 0x05, 0x05, 0x04, 0x04, 0x04, 0x04, 0x00,
37 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 8. */
38 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
39 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 9. */
40 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
41 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* a. */
42 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
43 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* b. */
44 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
45 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* c. */
46 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
47 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* d. */
48 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
49 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* e. */
50 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
51 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* f. */
52 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
53 | };
54 |
55 | #endif /* } */
56 |
--------------------------------------------------------------------------------
/luajava/src/main/jni/lua/lctype.h:
--------------------------------------------------------------------------------
1 | /*
2 | ** $Id: lctype.h,v 1.12 2011/07/15 12:50:29 roberto Exp $
3 | ** 'ctype' functions for Lua
4 | ** See Copyright Notice in lua.h
5 | */
6 |
7 | #ifndef lctype_h
8 | #define lctype_h
9 |
10 | #include "lua.h"
11 |
12 |
13 | /*
14 | ** WARNING: the functions defined here do not necessarily correspond
15 | ** to the similar functions in the standard C ctype.h. They are
16 | ** optimized for the specific needs of Lua
17 | */
18 |
19 | #if !defined(LUA_USE_CTYPE)
20 |
21 | #if 'A' == 65 && '0' == 48
22 | /* ASCII case: can use its own tables; faster and fixed */
23 | #define LUA_USE_CTYPE 0
24 | #else
25 | /* must use standard C ctype */
26 | #define LUA_USE_CTYPE 1
27 | #endif
28 |
29 | #endif
30 |
31 |
32 | #if !LUA_USE_CTYPE /* { */
33 |
34 | #include
35 |
36 | #include "llimits.h"
37 |
38 |
39 | #define ALPHABIT 0
40 | #define DIGITBIT 1
41 | #define PRINTBIT 2
42 | #define SPACEBIT 3
43 | #define XDIGITBIT 4
44 |
45 |
46 | #define MASK(B) (1 << (B))
47 |
48 |
49 | /*
50 | ** add 1 to char to allow index -1 (EOZ)
51 | */
52 | #define testprop(c,p) (luai_ctype_[(c)+1] & (p))
53 |
54 | /*
55 | ** 'lalpha' (Lua alphabetic) and 'lalnum' (Lua alphanumeric) both include '_'
56 | */
57 | #define lislalpha(c) testprop(c, MASK(ALPHABIT))
58 | #define lislalnum(c) testprop(c, (MASK(ALPHABIT) | MASK(DIGITBIT)))
59 | #define lisdigit(c) testprop(c, MASK(DIGITBIT))
60 | #define lisspace(c) testprop(c, MASK(SPACEBIT))
61 | #define lisprint(c) testprop(c, MASK(PRINTBIT))
62 | #define lisxdigit(c) testprop(c, MASK(XDIGITBIT))
63 |
64 | /*
65 | ** this 'ltolower' only works for alphabetic characters
66 | */
67 | #define ltolower(c) ((c) | ('A' ^ 'a'))
68 |
69 |
70 | /* two more entries for 0 and -1 (EOZ) */
71 | LUAI_DDEC const lu_byte luai_ctype_[UCHAR_MAX + 2];
72 |
73 |
74 | #else /* }{ */
75 |
76 | /*
77 | ** use standard C ctypes
78 | */
79 |
80 | #include
81 |
82 |
83 | #define lislalpha(c) (isalpha(c) || (c) == '_')
84 | #define lislalnum(c) (isalnum(c) || (c) == '_')
85 | #define lisdigit(c) (isdigit(c))
86 | #define lisspace(c) (isspace(c))
87 | #define lisprint(c) (isprint(c))
88 | #define lisxdigit(c) (isxdigit(c))
89 |
90 | #define ltolower(c) (tolower(c))
91 |
92 | #endif /* } */
93 |
94 | #endif
95 |
96 |
--------------------------------------------------------------------------------
/luajava/src/main/jni/lua/ldebug.h:
--------------------------------------------------------------------------------
1 | /*
2 | ** $Id: ldebug.h,v 2.14 2015/05/22 17:45:56 roberto Exp $
3 | ** Auxiliary functions from Debug Interface module
4 | ** See Copyright Notice in lua.h
5 | */
6 |
7 | #ifndef ldebug_h
8 | #define ldebug_h
9 |
10 |
11 | #include "lstate.h"
12 |
13 |
14 | #define pcRel(pc, p) (cast(int, (pc) - (p)->code) - 1)
15 |
16 | #define getfuncline(f,pc) (((f)->lineinfo) ? (f)->lineinfo[pc] : -1)
17 |
18 | #define resethookcount(L) (L->hookcount = L->basehookcount)
19 |
20 |
21 | LUAI_FUNC l_noret luaG_typeerror (lua_State *L, const TValue *o,
22 | const char *opname);
23 | LUAI_FUNC l_noret luaG_concaterror (lua_State *L, const TValue *p1,
24 | const TValue *p2);
25 | LUAI_FUNC l_noret luaG_opinterror (lua_State *L, const TValue *p1,
26 | const TValue *p2,
27 | const char *msg);
28 | LUAI_FUNC l_noret luaG_tointerror (lua_State *L, const TValue *p1,
29 | const TValue *p2);
30 | LUAI_FUNC l_noret luaG_ordererror (lua_State *L, const TValue *p1,
31 | const TValue *p2);
32 | LUAI_FUNC l_noret luaG_runerror (lua_State *L, const char *fmt, ...);
33 | LUAI_FUNC const char *luaG_addinfo (lua_State *L, const char *msg,
34 | TString *src, int line);
35 | LUAI_FUNC l_noret luaG_errormsg (lua_State *L);
36 | LUAI_FUNC void luaG_traceexec (lua_State *L);
37 |
38 |
39 | #endif
40 |
--------------------------------------------------------------------------------
/luajava/src/main/jni/lua/ldo.h:
--------------------------------------------------------------------------------
1 | /*
2 | ** $Id: ldo.h,v 2.29 2015/12/21 13:02:14 roberto Exp $
3 | ** Stack and Call structure of Lua
4 | ** See Copyright Notice in lua.h
5 | */
6 |
7 | #ifndef ldo_h
8 | #define ldo_h
9 |
10 |
11 | #include "lobject.h"
12 | #include "lstate.h"
13 | #include "lzio.h"
14 |
15 |
16 | /*
17 | ** Macro to check stack size and grow stack if needed. Parameters
18 | ** 'pre'/'pos' allow the macro to preserve a pointer into the
19 | ** stack across reallocations, doing the work only when needed.
20 | ** 'condmovestack' is used in heavy tests to force a stack reallocation
21 | ** at every check.
22 | */
23 | #define luaD_checkstackaux(L,n,pre,pos) \
24 | if (L->stack_last - L->top <= (n)) \
25 | { pre; luaD_growstack(L, n); pos; } else { condmovestack(L,pre,pos); }
26 |
27 | /* In general, 'pre'/'pos' are empty (nothing to save) */
28 | #define luaD_checkstack(L,n) luaD_checkstackaux(L,n,(void)0,(void)0)
29 |
30 |
31 |
32 | #define savestack(L,p) ((char *)(p) - (char *)L->stack)
33 | #define restorestack(L,n) ((TValue *)((char *)L->stack + (n)))
34 |
35 |
36 | /* type of protected functions, to be ran by 'runprotected' */
37 | typedef void (*Pfunc) (lua_State *L, void *ud);
38 |
39 | LUAI_FUNC int luaD_protectedparser (lua_State *L, ZIO *z, const char *name,
40 | const char *mode);
41 | LUAI_FUNC void luaD_hook (lua_State *L, int event, int line);
42 | LUAI_FUNC int luaD_precall (lua_State *L, StkId func, int nresults);
43 | LUAI_FUNC void luaD_call (lua_State *L, StkId func, int nResults);
44 | LUAI_FUNC void luaD_callnoyield (lua_State *L, StkId func, int nResults);
45 | LUAI_FUNC int luaD_pcall (lua_State *L, Pfunc func, void *u,
46 | ptrdiff_t oldtop, ptrdiff_t ef);
47 | LUAI_FUNC int luaD_poscall (lua_State *L, CallInfo *ci, StkId firstResult,
48 | int nres);
49 | LUAI_FUNC void luaD_reallocstack (lua_State *L, int newsize);
50 | LUAI_FUNC void luaD_growstack (lua_State *L, int n);
51 | LUAI_FUNC void luaD_shrinkstack (lua_State *L);
52 | LUAI_FUNC void luaD_inctop (lua_State *L);
53 |
54 | LUAI_FUNC l_noret luaD_throw (lua_State *L, int errcode);
55 | LUAI_FUNC int luaD_rawrunprotected (lua_State *L, Pfunc f, void *ud);
56 |
57 | #endif
58 |
59 |
--------------------------------------------------------------------------------
/luajava/src/main/jni/lua/ldump.c:
--------------------------------------------------------------------------------
1 | /*
2 | ** $Id: ldump.c,v 2.37 2015/10/08 15:53:49 roberto Exp $
3 | ** save precompiled Lua chunks
4 | ** See Copyright Notice in lua.h
5 | */
6 |
7 | #define ldump_c
8 | #define LUA_CORE
9 |
10 | #include "lprefix.h"
11 |
12 |
13 | #include
14 |
15 | #include "lua.h"
16 |
17 | #include "lobject.h"
18 | #include "lstate.h"
19 | #include "lundump.h"
20 |
21 |
22 | typedef struct {
23 | lua_State *L;
24 | lua_Writer writer;
25 | void *data;
26 | int strip;
27 | int status;
28 | } DumpState;
29 |
30 |
31 | /*
32 | ** All high-level dumps go through DumpVector; you can change it to
33 | ** change the endianness of the result
34 | */
35 | #define DumpVector(v,n,D) DumpBlock(v,(n)*sizeof((v)[0]),D)
36 |
37 | #define DumpLiteral(s,D) DumpBlock(s, sizeof(s) - sizeof(char), D)
38 |
39 |
40 | static void DumpBlock (const void *b, size_t size, DumpState *D) {
41 | if (D->status == 0 && size > 0) {
42 | lua_unlock(D->L);
43 | D->status = (*D->writer)(D->L, b, size, D->data);
44 | lua_lock(D->L);
45 | }
46 | }
47 |
48 |
49 | #define DumpVar(x,D) DumpVector(&x,1,D)
50 |
51 |
52 | static void DumpByte (int y, DumpState *D) {
53 | lu_byte x = (lu_byte)y;
54 | DumpVar(x, D);
55 | }
56 |
57 |
58 | static void DumpInt (int x, DumpState *D) {
59 | DumpVar(x, D);
60 | }
61 |
62 |
63 | static void DumpNumber (lua_Number x, DumpState *D) {
64 | DumpVar(x, D);
65 | }
66 |
67 |
68 | static void DumpInteger (lua_Integer x, DumpState *D) {
69 | DumpVar(x, D);
70 | }
71 |
72 |
73 | static void DumpString (const TString *s, DumpState *D) {
74 | if (s == NULL)
75 | DumpByte(0, D);
76 | else {
77 | size_t size = tsslen(s) + 1; /* include trailing '\0' */
78 | const char *str = getstr(s);
79 | if (size < 0xFF)
80 | DumpByte(cast_int(size), D);
81 | else {
82 | DumpByte(0xFF, D);
83 | DumpVar(size, D);
84 | }
85 | DumpVector(str, size - 1, D); /* no need to save '\0' */
86 | }
87 | }
88 |
89 |
90 | static void DumpCode (const Proto *f, DumpState *D) {
91 | DumpInt(f->sizecode, D);
92 | DumpVector(f->code, f->sizecode, D);
93 | }
94 |
95 |
96 | static void DumpFunction(const Proto *f, TString *psource, DumpState *D);
97 |
98 | static void DumpConstants (const Proto *f, DumpState *D) {
99 | int i;
100 | int n = f->sizek;
101 | DumpInt(n, D);
102 | for (i = 0; i < n; i++) {
103 | const TValue *o = &f->k[i];
104 | DumpByte(ttype(o), D);
105 | switch (ttype(o)) {
106 | case LUA_TNIL:
107 | break;
108 | case LUA_TBOOLEAN:
109 | DumpByte(bvalue(o), D);
110 | break;
111 | case LUA_TNUMFLT:
112 | DumpNumber(fltvalue(o), D);
113 | break;
114 | case LUA_TNUMINT:
115 | DumpInteger(ivalue(o), D);
116 | break;
117 | case LUA_TSHRSTR:
118 | case LUA_TLNGSTR:
119 | DumpString(tsvalue(o), D);
120 | break;
121 | default:
122 | lua_assert(0);
123 | }
124 | }
125 | }
126 |
127 |
128 | static void DumpProtos (const Proto *f, DumpState *D) {
129 | int i;
130 | int n = f->sizep;
131 | DumpInt(n, D);
132 | for (i = 0; i < n; i++)
133 | DumpFunction(f->p[i], f->source, D);
134 | }
135 |
136 |
137 | static void DumpUpvalues (const Proto *f, DumpState *D) {
138 | int i, n = f->sizeupvalues;
139 | DumpInt(n, D);
140 | for (i = 0; i < n; i++) {
141 | DumpByte(f->upvalues[i].instack, D);
142 | DumpByte(f->upvalues[i].idx, D);
143 | }
144 | }
145 |
146 |
147 | static void DumpDebug (const Proto *f, DumpState *D) {
148 | int i, n;
149 | n = (D->strip) ? 0 : f->sizelineinfo;
150 | DumpInt(n, D);
151 | DumpVector(f->lineinfo, n, D);
152 | n = (D->strip) ? 0 : f->sizelocvars;
153 | DumpInt(n, D);
154 | for (i = 0; i < n; i++) {
155 | DumpString(f->locvars[i].varname, D);
156 | DumpInt(f->locvars[i].startpc, D);
157 | DumpInt(f->locvars[i].endpc, D);
158 | }
159 | n = (D->strip) ? 0 : f->sizeupvalues;
160 | DumpInt(n, D);
161 | for (i = 0; i < n; i++)
162 | DumpString(f->upvalues[i].name, D);
163 | }
164 |
165 |
166 | static void DumpFunction (const Proto *f, TString *psource, DumpState *D) {
167 | if (D->strip || f->source == psource)
168 | DumpString(NULL, D); /* no debug info or same source as its parent */
169 | else
170 | DumpString(f->source, D);
171 | DumpInt(f->linedefined, D);
172 | DumpInt(f->lastlinedefined, D);
173 | DumpByte(f->numparams, D);
174 | DumpByte(f->is_vararg, D);
175 | DumpByte(f->maxstacksize, D);
176 | DumpCode(f, D);
177 | DumpConstants(f, D);
178 | DumpUpvalues(f, D);
179 | DumpProtos(f, D);
180 | DumpDebug(f, D);
181 | }
182 |
183 |
184 | static void DumpHeader (DumpState *D) {
185 | DumpLiteral(LUA_SIGNATURE, D);
186 | DumpByte(LUAC_VERSION, D);
187 | DumpByte(LUAC_FORMAT, D);
188 | DumpLiteral(LUAC_DATA, D);
189 | DumpByte(sizeof(int), D);
190 | DumpByte(sizeof(size_t), D);
191 | DumpByte(sizeof(Instruction), D);
192 | DumpByte(sizeof(lua_Integer), D);
193 | DumpByte(sizeof(lua_Number), D);
194 | DumpInteger(LUAC_INT, D);
195 | DumpNumber(LUAC_NUM, D);
196 | }
197 |
198 |
199 | /*
200 | ** dump Lua function as precompiled chunk
201 | */
202 | int luaU_dump(lua_State *L, const Proto *f, lua_Writer w, void *data,
203 | int strip) {
204 | DumpState D;
205 | D.L = L;
206 | D.writer = w;
207 | D.data = data;
208 | D.strip = strip;
209 | D.status = 0;
210 | DumpHeader(&D);
211 | DumpByte(f->sizeupvalues, &D);
212 | DumpFunction(f, NULL, &D);
213 | return D.status;
214 | }
215 |
216 |
--------------------------------------------------------------------------------
/luajava/src/main/jni/lua/lfunc.c:
--------------------------------------------------------------------------------
1 | /*
2 | ** $Id: lfunc.c,v 2.45 2014/11/02 19:19:04 roberto Exp $
3 | ** Auxiliary functions to manipulate prototypes and closures
4 | ** See Copyright Notice in lua.h
5 | */
6 |
7 | #define lfunc_c
8 | #define LUA_CORE
9 |
10 | #include "lprefix.h"
11 |
12 |
13 | #include
14 |
15 | #include "lua.h"
16 |
17 | #include "lfunc.h"
18 | #include "lgc.h"
19 | #include "lmem.h"
20 | #include "lobject.h"
21 | #include "lstate.h"
22 |
23 |
24 |
25 | CClosure *luaF_newCclosure (lua_State *L, int n) {
26 | GCObject *o = luaC_newobj(L, LUA_TCCL, sizeCclosure(n));
27 | CClosure *c = gco2ccl(o);
28 | c->nupvalues = cast_byte(n);
29 | return c;
30 | }
31 |
32 |
33 | LClosure *luaF_newLclosure (lua_State *L, int n) {
34 | GCObject *o = luaC_newobj(L, LUA_TLCL, sizeLclosure(n));
35 | LClosure *c = gco2lcl(o);
36 | c->p = NULL;
37 | c->nupvalues = cast_byte(n);
38 | while (n--) c->upvals[n] = NULL;
39 | return c;
40 | }
41 |
42 | /*
43 | ** fill a closure with new closed upvalues
44 | */
45 | void luaF_initupvals (lua_State *L, LClosure *cl) {
46 | int i;
47 | for (i = 0; i < cl->nupvalues; i++) {
48 | UpVal *uv = luaM_new(L, UpVal);
49 | uv->refcount = 1;
50 | uv->v = &uv->u.value; /* make it closed */
51 | setnilvalue(uv->v);
52 | cl->upvals[i] = uv;
53 | }
54 | }
55 |
56 |
57 | UpVal *luaF_findupval (lua_State *L, StkId level) {
58 | UpVal **pp = &L->openupval;
59 | UpVal *p;
60 | UpVal *uv;
61 | lua_assert(isintwups(L) || L->openupval == NULL);
62 | while (*pp != NULL && (p = *pp)->v >= level) {
63 | lua_assert(upisopen(p));
64 | if (p->v == level) /* found a corresponding upvalue? */
65 | return p; /* return it */
66 | pp = &p->u.open.next;
67 | }
68 | /* not found: create a new upvalue */
69 | uv = luaM_new(L, UpVal);
70 | uv->refcount = 0;
71 | uv->u.open.next = *pp; /* link it to list of open upvalues */
72 | uv->u.open.touched = 1;
73 | *pp = uv;
74 | uv->v = level; /* current value lives in the stack */
75 | if (!isintwups(L)) { /* thread not in list of threads with upvalues? */
76 | L->twups = G(L)->twups; /* link it to the list */
77 | G(L)->twups = L;
78 | }
79 | return uv;
80 | }
81 |
82 |
83 | void luaF_close (lua_State *L, StkId level) {
84 | UpVal *uv;
85 | while (L->openupval != NULL && (uv = L->openupval)->v >= level) {
86 | lua_assert(upisopen(uv));
87 | L->openupval = uv->u.open.next; /* remove from 'open' list */
88 | if (uv->refcount == 0) /* no references? */
89 | luaM_free(L, uv); /* free upvalue */
90 | else {
91 | setobj(L, &uv->u.value, uv->v); /* move value to upvalue slot */
92 | uv->v = &uv->u.value; /* now current value lives here */
93 | luaC_upvalbarrier(L, uv);
94 | }
95 | }
96 | }
97 |
98 |
99 | Proto *luaF_newproto (lua_State *L) {
100 | GCObject *o = luaC_newobj(L, LUA_TPROTO, sizeof(Proto));
101 | Proto *f = gco2p(o);
102 | f->k = NULL;
103 | f->sizek = 0;
104 | f->p = NULL;
105 | f->sizep = 0;
106 | f->code = NULL;
107 | f->cache = NULL;
108 | f->sizecode = 0;
109 | f->lineinfo = NULL;
110 | f->sizelineinfo = 0;
111 | f->upvalues = NULL;
112 | f->sizeupvalues = 0;
113 | f->numparams = 0;
114 | f->is_vararg = 0;
115 | f->maxstacksize = 0;
116 | f->locvars = NULL;
117 | f->sizelocvars = 0;
118 | f->linedefined = 0;
119 | f->lastlinedefined = 0;
120 | f->source = NULL;
121 | return f;
122 | }
123 |
124 |
125 | void luaF_freeproto (lua_State *L, Proto *f) {
126 | luaM_freearray(L, f->code, f->sizecode);
127 | luaM_freearray(L, f->p, f->sizep);
128 | luaM_freearray(L, f->k, f->sizek);
129 | luaM_freearray(L, f->lineinfo, f->sizelineinfo);
130 | luaM_freearray(L, f->locvars, f->sizelocvars);
131 | luaM_freearray(L, f->upvalues, f->sizeupvalues);
132 | luaM_free(L, f);
133 | }
134 |
135 |
136 | /*
137 | ** Look for n-th local variable at line 'line' in function 'func'.
138 | ** Returns NULL if not found.
139 | */
140 | const char *luaF_getlocalname (const Proto *f, int local_number, int pc) {
141 | int i;
142 | for (i = 0; isizelocvars && f->locvars[i].startpc <= pc; i++) {
143 | if (pc < f->locvars[i].endpc) { /* is variable active? */
144 | local_number--;
145 | if (local_number == 0)
146 | return getstr(f->locvars[i].varname);
147 | }
148 | }
149 | return NULL; /* not found */
150 | }
151 |
152 |
--------------------------------------------------------------------------------
/luajava/src/main/jni/lua/lfunc.h:
--------------------------------------------------------------------------------
1 | /*
2 | ** $Id: lfunc.h,v 2.15 2015/01/13 15:49:11 roberto Exp $
3 | ** Auxiliary functions to manipulate prototypes and closures
4 | ** See Copyright Notice in lua.h
5 | */
6 |
7 | #ifndef lfunc_h
8 | #define lfunc_h
9 |
10 |
11 | #include "lobject.h"
12 |
13 |
14 | #define sizeCclosure(n) (cast(int, sizeof(CClosure)) + \
15 | cast(int, sizeof(TValue)*((n)-1)))
16 |
17 | #define sizeLclosure(n) (cast(int, sizeof(LClosure)) + \
18 | cast(int, sizeof(TValue *)*((n)-1)))
19 |
20 |
21 | /* test whether thread is in 'twups' list */
22 | #define isintwups(L) (L->twups != L)
23 |
24 |
25 | /*
26 | ** maximum number of upvalues in a closure (both C and Lua). (Value
27 | ** must fit in a VM register.)
28 | */
29 | #define MAXUPVAL 255
30 |
31 |
32 | /*
33 | ** Upvalues for Lua closures
34 | */
35 | struct UpVal {
36 | TValue *v; /* points to stack or to its own value */
37 | lu_mem refcount; /* reference counter */
38 | union {
39 | struct { /* (when open) */
40 | UpVal *next; /* linked list */
41 | int touched; /* mark to avoid cycles with dead threads */
42 | } open;
43 | TValue value; /* the value (when closed) */
44 | } u;
45 | };
46 |
47 | #define upisopen(up) ((up)->v != &(up)->u.value)
48 |
49 |
50 | LUAI_FUNC Proto *luaF_newproto (lua_State *L);
51 | LUAI_FUNC CClosure *luaF_newCclosure (lua_State *L, int nelems);
52 | LUAI_FUNC LClosure *luaF_newLclosure (lua_State *L, int nelems);
53 | LUAI_FUNC void luaF_initupvals (lua_State *L, LClosure *cl);
54 | LUAI_FUNC UpVal *luaF_findupval (lua_State *L, StkId level);
55 | LUAI_FUNC void luaF_close (lua_State *L, StkId level);
56 | LUAI_FUNC void luaF_freeproto (lua_State *L, Proto *f);
57 | LUAI_FUNC const char *luaF_getlocalname (const Proto *func, int local_number,
58 | int pc);
59 |
60 |
61 | #endif
62 |
--------------------------------------------------------------------------------
/luajava/src/main/jni/lua/lgc.h:
--------------------------------------------------------------------------------
1 | /*
2 | ** $Id: lgc.h,v 2.91 2015/12/21 13:02:14 roberto Exp $
3 | ** Garbage Collector
4 | ** See Copyright Notice in lua.h
5 | */
6 |
7 | #ifndef lgc_h
8 | #define lgc_h
9 |
10 |
11 | #include "lobject.h"
12 | #include "lstate.h"
13 |
14 | /*
15 | ** Collectable objects may have one of three colors: white, which
16 | ** means the object is not marked; gray, which means the
17 | ** object is marked, but its references may be not marked; and
18 | ** black, which means that the object and all its references are marked.
19 | ** The main invariant of the garbage collector, while marking objects,
20 | ** is that a black object can never point to a white one. Moreover,
21 | ** any gray object must be in a "gray list" (gray, grayagain, weak,
22 | ** allweak, ephemeron) so that it can be visited again before finishing
23 | ** the collection cycle. These lists have no meaning when the invariant
24 | ** is not being enforced (e.g., sweep phase).
25 | */
26 |
27 |
28 |
29 | /* how much to allocate before next GC step */
30 | #if !defined(GCSTEPSIZE)
31 | /* ~100 small strings */
32 | #define GCSTEPSIZE (cast_int(100 * sizeof(TString)))
33 | #endif
34 |
35 |
36 | /*
37 | ** Possible states of the Garbage Collector
38 | */
39 | #define GCSpropagate 0
40 | #define GCSatomic 1
41 | #define GCSswpallgc 2
42 | #define GCSswpfinobj 3
43 | #define GCSswptobefnz 4
44 | #define GCSswpend 5
45 | #define GCScallfin 6
46 | #define GCSpause 7
47 |
48 |
49 | #define issweepphase(g) \
50 | (GCSswpallgc <= (g)->gcstate && (g)->gcstate <= GCSswpend)
51 |
52 |
53 | /*
54 | ** macro to tell when main invariant (white objects cannot point to black
55 | ** ones) must be kept. During a collection, the sweep
56 | ** phase may break the invariant, as objects turned white may point to
57 | ** still-black objects. The invariant is restored when sweep ends and
58 | ** all objects are white again.
59 | */
60 |
61 | #define keepinvariant(g) ((g)->gcstate <= GCSatomic)
62 |
63 |
64 | /*
65 | ** some useful bit tricks
66 | */
67 | #define resetbits(x,m) ((x) &= cast(lu_byte, ~(m)))
68 | #define setbits(x,m) ((x) |= (m))
69 | #define testbits(x,m) ((x) & (m))
70 | #define bitmask(b) (1<<(b))
71 | #define bit2mask(b1,b2) (bitmask(b1) | bitmask(b2))
72 | #define l_setbit(x,b) setbits(x, bitmask(b))
73 | #define resetbit(x,b) resetbits(x, bitmask(b))
74 | #define testbit(x,b) testbits(x, bitmask(b))
75 |
76 |
77 | /* Layout for bit use in 'marked' field: */
78 | #define WHITE0BIT 0 /* object is white (type 0) */
79 | #define WHITE1BIT 1 /* object is white (type 1) */
80 | #define BLACKBIT 2 /* object is black */
81 | #define FINALIZEDBIT 3 /* object has been marked for finalization */
82 | /* bit 7 is currently used by tests (luaL_checkmemory) */
83 |
84 | #define WHITEBITS bit2mask(WHITE0BIT, WHITE1BIT)
85 |
86 |
87 | #define iswhite(x) testbits((x)->marked, WHITEBITS)
88 | #define isblack(x) testbit((x)->marked, BLACKBIT)
89 | #define isgray(x) /* neither white nor black */ \
90 | (!testbits((x)->marked, WHITEBITS | bitmask(BLACKBIT)))
91 |
92 | #define tofinalize(x) testbit((x)->marked, FINALIZEDBIT)
93 |
94 | #define otherwhite(g) ((g)->currentwhite ^ WHITEBITS)
95 | #define isdeadm(ow,m) (!(((m) ^ WHITEBITS) & (ow)))
96 | #define isdead(g,v) isdeadm(otherwhite(g), (v)->marked)
97 |
98 | #define changewhite(x) ((x)->marked ^= WHITEBITS)
99 | #define gray2black(x) l_setbit((x)->marked, BLACKBIT)
100 |
101 | #define luaC_white(g) cast(lu_byte, (g)->currentwhite & WHITEBITS)
102 |
103 |
104 | /*
105 | ** Does one step of collection when debt becomes positive. 'pre'/'pos'
106 | ** allows some adjustments to be done only when needed. macro
107 | ** 'condchangemem' is used only for heavy tests (forcing a full
108 | ** GC cycle on every opportunity)
109 | */
110 | #define luaC_condGC(L,pre,pos) \
111 | { if (G(L)->GCdebt > 0) { pre; luaC_step(L); pos;}; \
112 | condchangemem(L,pre,pos); }
113 |
114 | /* more often than not, 'pre'/'pos' are empty */
115 | #define luaC_checkGC(L) luaC_condGC(L,(void)0,(void)0)
116 |
117 |
118 | #define luaC_barrier(L,p,v) ( \
119 | (iscollectable(v) && isblack(p) && iswhite(gcvalue(v))) ? \
120 | luaC_barrier_(L,obj2gco(p),gcvalue(v)) : cast_void(0))
121 |
122 | #define luaC_barrierback(L,p,v) ( \
123 | (iscollectable(v) && isblack(p) && iswhite(gcvalue(v))) ? \
124 | luaC_barrierback_(L,p) : cast_void(0))
125 |
126 | #define luaC_objbarrier(L,p,o) ( \
127 | (isblack(p) && iswhite(o)) ? \
128 | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0))
129 |
130 | #define luaC_upvalbarrier(L,uv) ( \
131 | (iscollectable((uv)->v) && !upisopen(uv)) ? \
132 | luaC_upvalbarrier_(L,uv) : cast_void(0))
133 |
134 | LUAI_FUNC void luaC_fix (lua_State *L, GCObject *o);
135 | LUAI_FUNC void luaC_freeallobjects (lua_State *L);
136 | LUAI_FUNC void luaC_step (lua_State *L);
137 | LUAI_FUNC void luaC_runtilstate (lua_State *L, int statesmask);
138 | LUAI_FUNC void luaC_fullgc (lua_State *L, int isemergency);
139 | LUAI_FUNC GCObject *luaC_newobj (lua_State *L, int tt, size_t sz);
140 | LUAI_FUNC void luaC_barrier_ (lua_State *L, GCObject *o, GCObject *v);
141 | LUAI_FUNC void luaC_barrierback_ (lua_State *L, Table *o);
142 | LUAI_FUNC void luaC_upvalbarrier_ (lua_State *L, UpVal *uv);
143 | LUAI_FUNC void luaC_checkfinalizer (lua_State *L, GCObject *o, Table *mt);
144 | LUAI_FUNC void luaC_upvdeccount (lua_State *L, UpVal *uv);
145 |
146 |
147 | #endif
148 |
--------------------------------------------------------------------------------
/luajava/src/main/jni/lua/linit.c:
--------------------------------------------------------------------------------
1 | /*
2 | ** $Id: linit.c,v 1.38 2015/01/05 13:48:33 roberto Exp $
3 | ** Initialization of libraries for lua.c and other clients
4 | ** See Copyright Notice in lua.h
5 | */
6 |
7 |
8 | #define linit_c
9 | #define LUA_LIB
10 |
11 | /*
12 | ** If you embed Lua in your program and need to open the standard
13 | ** libraries, call luaL_openlibs in your program. If you need a
14 | ** different set of libraries, copy this file to your project and edit
15 | ** it to suit your needs.
16 | **
17 | ** You can also *preload* libraries, so that a later 'require' can
18 | ** open the library, which is already linked to the application.
19 | ** For that, do the following code:
20 | **
21 | ** luaL_getsubtable(L, LUA_REGISTRYINDEX, "_PRELOAD");
22 | ** lua_pushcfunction(L, luaopen_modname);
23 | ** lua_setfield(L, -2, modname);
24 | ** lua_pop(L, 1); // remove _PRELOAD table
25 | */
26 |
27 | #include "lprefix.h"
28 |
29 |
30 | #include
31 |
32 | #include "lua.h"
33 |
34 | #include "lualib.h"
35 | #include "lauxlib.h"
36 |
37 |
38 | /*
39 | ** these libs are loaded by lua.c and are readily available to any Lua
40 | ** program
41 | */
42 | static const luaL_Reg loadedlibs[] = {
43 | {"_G", luaopen_base},
44 | {LUA_LOADLIBNAME, luaopen_package},
45 | {LUA_COLIBNAME, luaopen_coroutine},
46 | {LUA_TABLIBNAME, luaopen_table},
47 | {LUA_IOLIBNAME, luaopen_io},
48 | {LUA_OSLIBNAME, luaopen_os},
49 | {LUA_STRLIBNAME, luaopen_string},
50 | {LUA_MATHLIBNAME, luaopen_math},
51 | {LUA_UTF8LIBNAME, luaopen_utf8},
52 | {LUA_DBLIBNAME, luaopen_debug},
53 | #if defined(LUA_COMPAT_BITLIB)
54 | {LUA_BITLIBNAME, luaopen_bit32},
55 | #endif
56 | {NULL, NULL}
57 | };
58 |
59 |
60 | LUALIB_API void luaL_openlibs (lua_State *L) {
61 | const luaL_Reg *lib;
62 | /* "require" functions from 'loadedlibs' and set results to global table */
63 | for (lib = loadedlibs; lib->func; lib++) {
64 | luaL_requiref(L, lib->name, lib->func, 1);
65 | lua_pop(L, 1); /* remove lib */
66 | }
67 | }
68 |
69 |
--------------------------------------------------------------------------------
/luajava/src/main/jni/lua/llex.h:
--------------------------------------------------------------------------------
1 | /*
2 | ** $Id: llex.h,v 1.79 2016/05/02 14:02:12 roberto Exp $
3 | ** Lexical Analyzer
4 | ** See Copyright Notice in lua.h
5 | */
6 |
7 | #ifndef llex_h
8 | #define llex_h
9 |
10 | #include "lobject.h"
11 | #include "lzio.h"
12 |
13 |
14 | #define FIRST_RESERVED 257
15 |
16 |
17 | #if !defined(LUA_ENV)
18 | #define LUA_ENV "_ENV"
19 | #endif
20 |
21 |
22 | /*
23 | * WARNING: if you change the order of this enumeration,
24 | * grep "ORDER RESERVED"
25 | */
26 | enum RESERVED {
27 | /* terminal symbols denoted by reserved words */
28 | TK_AND = FIRST_RESERVED, TK_BREAK,
29 | TK_DO, TK_ELSE, TK_ELSEIF, TK_END, TK_FALSE, TK_FOR, TK_FUNCTION,
30 | TK_GOTO, TK_IF, TK_IN, TK_LOCAL, TK_NIL, TK_NOT, TK_OR, TK_REPEAT,
31 | TK_RETURN, TK_THEN, TK_TRUE, TK_UNTIL, TK_WHILE,
32 | /* other terminal symbols */
33 | TK_IDIV, TK_CONCAT, TK_DOTS, TK_EQ, TK_GE, TK_LE, TK_NE,
34 | TK_SHL, TK_SHR,
35 | TK_DBCOLON, TK_EOS,
36 | TK_FLT, TK_INT, TK_NAME, TK_STRING
37 | };
38 |
39 | /* number of reserved words */
40 | #define NUM_RESERVED (cast(int, TK_WHILE-FIRST_RESERVED+1))
41 |
42 |
43 | typedef union {
44 | lua_Number r;
45 | lua_Integer i;
46 | TString *ts;
47 | } SemInfo; /* semantics information */
48 |
49 |
50 | typedef struct Token {
51 | int token;
52 | SemInfo seminfo;
53 | } Token;
54 |
55 |
56 | /* state of the lexer plus state of the parser when shared by all
57 | functions */
58 | typedef struct LexState {
59 | int current; /* current character (charint) */
60 | int linenumber; /* input line counter */
61 | int lastline; /* line of last token 'consumed' */
62 | Token t; /* current token */
63 | Token lookahead; /* look ahead token */
64 | struct FuncState *fs; /* current function (parser) */
65 | struct lua_State *L;
66 | ZIO *z; /* input stream */
67 | Mbuffer *buff; /* buffer for tokens */
68 | Table *h; /* to avoid collection/reuse strings */
69 | struct Dyndata *dyd; /* dynamic structures used by the parser */
70 | TString *source; /* current source name */
71 | TString *envn; /* environment variable name */
72 | } LexState;
73 |
74 |
75 | LUAI_FUNC void luaX_init (lua_State *L);
76 | LUAI_FUNC void luaX_setinput (lua_State *L, LexState *ls, ZIO *z,
77 | TString *source, int firstchar);
78 | LUAI_FUNC TString *luaX_newstring (LexState *ls, const char *str, size_t l);
79 | LUAI_FUNC void luaX_next (LexState *ls);
80 | LUAI_FUNC int luaX_lookahead (LexState *ls);
81 | LUAI_FUNC l_noret luaX_syntaxerror (LexState *ls, const char *s);
82 | LUAI_FUNC const char *luaX_token2str (LexState *ls, int token);
83 |
84 |
85 | #endif
86 |
--------------------------------------------------------------------------------
/luajava/src/main/jni/lua/lmem.c:
--------------------------------------------------------------------------------
1 | /*
2 | ** $Id: lmem.c,v 1.91 2015/03/06 19:45:54 roberto Exp $
3 | ** Interface to Memory Manager
4 | ** See Copyright Notice in lua.h
5 | */
6 |
7 | #define lmem_c
8 | #define LUA_CORE
9 |
10 | #include "lprefix.h"
11 |
12 |
13 | #include
14 |
15 | #include "lua.h"
16 |
17 | #include "ldebug.h"
18 | #include "ldo.h"
19 | #include "lgc.h"
20 | #include "lmem.h"
21 | #include "lobject.h"
22 | #include "lstate.h"
23 |
24 |
25 |
26 | /*
27 | ** About the realloc function:
28 | ** void * frealloc (void *ud, void *ptr, size_t osize, size_t nsize);
29 | ** ('osize' is the old size, 'nsize' is the new size)
30 | **
31 | ** * frealloc(ud, NULL, x, s) creates a new block of size 's' (no
32 | ** matter 'x').
33 | **
34 | ** * frealloc(ud, p, x, 0) frees the block 'p'
35 | ** (in this specific case, frealloc must return NULL);
36 | ** particularly, frealloc(ud, NULL, 0, 0) does nothing
37 | ** (which is equivalent to free(NULL) in ISO C)
38 | **
39 | ** frealloc returns NULL if it cannot create or reallocate the area
40 | ** (any reallocation to an equal or smaller size cannot fail!)
41 | */
42 |
43 |
44 |
45 | #define MINSIZEARRAY 4
46 |
47 |
48 | void *luaM_growaux_ (lua_State *L, void *block, int *size, size_t size_elems,
49 | int limit, const char *what) {
50 | void *newblock;
51 | int newsize;
52 | if (*size >= limit/2) { /* cannot double it? */
53 | if (*size >= limit) /* cannot grow even a little? */
54 | luaG_runerror(L, "too many %s (limit is %d)", what, limit);
55 | newsize = limit; /* still have at least one free place */
56 | }
57 | else {
58 | newsize = (*size)*2;
59 | if (newsize < MINSIZEARRAY)
60 | newsize = MINSIZEARRAY; /* minimum size */
61 | }
62 | newblock = luaM_reallocv(L, block, *size, newsize, size_elems);
63 | *size = newsize; /* update only when everything else is OK */
64 | return newblock;
65 | }
66 |
67 |
68 | l_noret luaM_toobig (lua_State *L) {
69 | luaG_runerror(L, "memory allocation error: block too big");
70 | }
71 |
72 |
73 |
74 | /*
75 | ** generic allocation routine.
76 | */
77 | void *luaM_realloc_ (lua_State *L, void *block, size_t osize, size_t nsize) {
78 | void *newblock;
79 | global_State *g = G(L);
80 | size_t realosize = (block) ? osize : 0;
81 | lua_assert((realosize == 0) == (block == NULL));
82 | #if defined(HARDMEMTESTS)
83 | if (nsize > realosize && g->gcrunning)
84 | luaC_fullgc(L, 1); /* force a GC whenever possible */
85 | #endif
86 | newblock = (*g->frealloc)(g->ud, block, osize, nsize);
87 | if (newblock == NULL && nsize > 0) {
88 | lua_assert(nsize > realosize); /* cannot fail when shrinking a block */
89 | if (g->version) { /* is state fully built? */
90 | luaC_fullgc(L, 1); /* try to free some memory... */
91 | newblock = (*g->frealloc)(g->ud, block, osize, nsize); /* try again */
92 | }
93 | if (newblock == NULL)
94 | luaD_throw(L, LUA_ERRMEM);
95 | }
96 | lua_assert((nsize == 0) == (newblock == NULL));
97 | g->GCdebt = (g->GCdebt + nsize) - realosize;
98 | return newblock;
99 | }
100 |
101 |
--------------------------------------------------------------------------------
/luajava/src/main/jni/lua/lmem.h:
--------------------------------------------------------------------------------
1 | /*
2 | ** $Id: lmem.h,v 1.43 2014/12/19 17:26:14 roberto Exp $
3 | ** Interface to Memory Manager
4 | ** See Copyright Notice in lua.h
5 | */
6 |
7 | #ifndef lmem_h
8 | #define lmem_h
9 |
10 |
11 | #include
12 |
13 | #include "llimits.h"
14 | #include "lua.h"
15 |
16 |
17 | /*
18 | ** This macro reallocs a vector 'b' from 'on' to 'n' elements, where
19 | ** each element has size 'e'. In case of arithmetic overflow of the
20 | ** product 'n'*'e', it raises an error (calling 'luaM_toobig'). Because
21 | ** 'e' is always constant, it avoids the runtime division MAX_SIZET/(e).
22 | **
23 | ** (The macro is somewhat complex to avoid warnings: The 'sizeof'
24 | ** comparison avoids a runtime comparison when overflow cannot occur.
25 | ** The compiler should be able to optimize the real test by itself, but
26 | ** when it does it, it may give a warning about "comparison is always
27 | ** false due to limited range of data type"; the +1 tricks the compiler,
28 | ** avoiding this warning but also this optimization.)
29 | */
30 | #define luaM_reallocv(L,b,on,n,e) \
31 | (((sizeof(n) >= sizeof(size_t) && cast(size_t, (n)) + 1 > MAX_SIZET/(e)) \
32 | ? luaM_toobig(L) : cast_void(0)) , \
33 | luaM_realloc_(L, (b), (on)*(e), (n)*(e)))
34 |
35 | /*
36 | ** Arrays of chars do not need any test
37 | */
38 | #define luaM_reallocvchar(L,b,on,n) \
39 | cast(char *, luaM_realloc_(L, (b), (on)*sizeof(char), (n)*sizeof(char)))
40 |
41 | #define luaM_freemem(L, b, s) luaM_realloc_(L, (b), (s), 0)
42 | #define luaM_free(L, b) luaM_realloc_(L, (b), sizeof(*(b)), 0)
43 | #define luaM_freearray(L, b, n) luaM_realloc_(L, (b), (n)*sizeof(*(b)), 0)
44 |
45 | #define luaM_malloc(L,s) luaM_realloc_(L, NULL, 0, (s))
46 | #define luaM_new(L,t) cast(t *, luaM_malloc(L, sizeof(t)))
47 | #define luaM_newvector(L,n,t) \
48 | cast(t *, luaM_reallocv(L, NULL, 0, n, sizeof(t)))
49 |
50 | #define luaM_newobject(L,tag,s) luaM_realloc_(L, NULL, tag, (s))
51 |
52 | #define luaM_growvector(L,v,nelems,size,t,limit,e) \
53 | if ((nelems)+1 > (size)) \
54 | ((v)=cast(t *, luaM_growaux_(L,v,&(size),sizeof(t),limit,e)))
55 |
56 | #define luaM_reallocvector(L, v,oldn,n,t) \
57 | ((v)=cast(t *, luaM_reallocv(L, v, oldn, n, sizeof(t))))
58 |
59 | LUAI_FUNC l_noret luaM_toobig (lua_State *L);
60 |
61 | /* not to be called directly */
62 | LUAI_FUNC void *luaM_realloc_ (lua_State *L, void *block, size_t oldsize,
63 | size_t size);
64 | LUAI_FUNC void *luaM_growaux_ (lua_State *L, void *block, int *size,
65 | size_t size_elem, int limit,
66 | const char *what);
67 |
68 | #endif
69 |
70 |
--------------------------------------------------------------------------------
/luajava/src/main/jni/lua/lopcodes.c:
--------------------------------------------------------------------------------
1 | /*
2 | ** $Id: lopcodes.c,v 1.55 2015/01/05 13:48:33 roberto Exp $
3 | ** Opcodes for Lua virtual machine
4 | ** See Copyright Notice in lua.h
5 | */
6 |
7 | #define lopcodes_c
8 | #define LUA_CORE
9 |
10 | #include "lprefix.h"
11 |
12 |
13 | #include
14 |
15 | #include "lopcodes.h"
16 |
17 |
18 | /* ORDER OP */
19 |
20 | LUAI_DDEF const char *const luaP_opnames[NUM_OPCODES+1] = {
21 | "MOVE",
22 | "LOADK",
23 | "LOADKX",
24 | "LOADBOOL",
25 | "LOADNIL",
26 | "GETUPVAL",
27 | "GETTABUP",
28 | "GETTABLE",
29 | "SETTABUP",
30 | "SETUPVAL",
31 | "SETTABLE",
32 | "NEWTABLE",
33 | "SELF",
34 | "ADD",
35 | "SUB",
36 | "MUL",
37 | "MOD",
38 | "POW",
39 | "DIV",
40 | "IDIV",
41 | "BAND",
42 | "BOR",
43 | "BXOR",
44 | "SHL",
45 | "SHR",
46 | "UNM",
47 | "BNOT",
48 | "NOT",
49 | "LEN",
50 | "CONCAT",
51 | "JMP",
52 | "EQ",
53 | "LT",
54 | "LE",
55 | "TEST",
56 | "TESTSET",
57 | "CALL",
58 | "TAILCALL",
59 | "RETURN",
60 | "FORLOOP",
61 | "FORPREP",
62 | "TFORCALL",
63 | "TFORLOOP",
64 | "SETLIST",
65 | "CLOSURE",
66 | "VARARG",
67 | "EXTRAARG",
68 | NULL
69 | };
70 |
71 |
72 | #define opmode(t,a,b,c,m) (((t)<<7) | ((a)<<6) | ((b)<<4) | ((c)<<2) | (m))
73 |
74 | LUAI_DDEF const lu_byte luaP_opmodes[NUM_OPCODES] = {
75 | /* T A B C mode opcode */
76 | opmode(0, 1, OpArgR, OpArgN, iABC) /* OP_MOVE */
77 | ,opmode(0, 1, OpArgK, OpArgN, iABx) /* OP_LOADK */
78 | ,opmode(0, 1, OpArgN, OpArgN, iABx) /* OP_LOADKX */
79 | ,opmode(0, 1, OpArgU, OpArgU, iABC) /* OP_LOADBOOL */
80 | ,opmode(0, 1, OpArgU, OpArgN, iABC) /* OP_LOADNIL */
81 | ,opmode(0, 1, OpArgU, OpArgN, iABC) /* OP_GETUPVAL */
82 | ,opmode(0, 1, OpArgU, OpArgK, iABC) /* OP_GETTABUP */
83 | ,opmode(0, 1, OpArgR, OpArgK, iABC) /* OP_GETTABLE */
84 | ,opmode(0, 0, OpArgK, OpArgK, iABC) /* OP_SETTABUP */
85 | ,opmode(0, 0, OpArgU, OpArgN, iABC) /* OP_SETUPVAL */
86 | ,opmode(0, 0, OpArgK, OpArgK, iABC) /* OP_SETTABLE */
87 | ,opmode(0, 1, OpArgU, OpArgU, iABC) /* OP_NEWTABLE */
88 | ,opmode(0, 1, OpArgR, OpArgK, iABC) /* OP_SELF */
89 | ,opmode(0, 1, OpArgK, OpArgK, iABC) /* OP_ADD */
90 | ,opmode(0, 1, OpArgK, OpArgK, iABC) /* OP_SUB */
91 | ,opmode(0, 1, OpArgK, OpArgK, iABC) /* OP_MUL */
92 | ,opmode(0, 1, OpArgK, OpArgK, iABC) /* OP_MOD */
93 | ,opmode(0, 1, OpArgK, OpArgK, iABC) /* OP_POW */
94 | ,opmode(0, 1, OpArgK, OpArgK, iABC) /* OP_DIV */
95 | ,opmode(0, 1, OpArgK, OpArgK, iABC) /* OP_IDIV */
96 | ,opmode(0, 1, OpArgK, OpArgK, iABC) /* OP_BAND */
97 | ,opmode(0, 1, OpArgK, OpArgK, iABC) /* OP_BOR */
98 | ,opmode(0, 1, OpArgK, OpArgK, iABC) /* OP_BXOR */
99 | ,opmode(0, 1, OpArgK, OpArgK, iABC) /* OP_SHL */
100 | ,opmode(0, 1, OpArgK, OpArgK, iABC) /* OP_SHR */
101 | ,opmode(0, 1, OpArgR, OpArgN, iABC) /* OP_UNM */
102 | ,opmode(0, 1, OpArgR, OpArgN, iABC) /* OP_BNOT */
103 | ,opmode(0, 1, OpArgR, OpArgN, iABC) /* OP_NOT */
104 | ,opmode(0, 1, OpArgR, OpArgN, iABC) /* OP_LEN */
105 | ,opmode(0, 1, OpArgR, OpArgR, iABC) /* OP_CONCAT */
106 | ,opmode(0, 0, OpArgR, OpArgN, iAsBx) /* OP_JMP */
107 | ,opmode(1, 0, OpArgK, OpArgK, iABC) /* OP_EQ */
108 | ,opmode(1, 0, OpArgK, OpArgK, iABC) /* OP_LT */
109 | ,opmode(1, 0, OpArgK, OpArgK, iABC) /* OP_LE */
110 | ,opmode(1, 0, OpArgN, OpArgU, iABC) /* OP_TEST */
111 | ,opmode(1, 1, OpArgR, OpArgU, iABC) /* OP_TESTSET */
112 | ,opmode(0, 1, OpArgU, OpArgU, iABC) /* OP_CALL */
113 | ,opmode(0, 1, OpArgU, OpArgU, iABC) /* OP_TAILCALL */
114 | ,opmode(0, 0, OpArgU, OpArgN, iABC) /* OP_RETURN */
115 | ,opmode(0, 1, OpArgR, OpArgN, iAsBx) /* OP_FORLOOP */
116 | ,opmode(0, 1, OpArgR, OpArgN, iAsBx) /* OP_FORPREP */
117 | ,opmode(0, 0, OpArgN, OpArgU, iABC) /* OP_TFORCALL */
118 | ,opmode(0, 1, OpArgR, OpArgN, iAsBx) /* OP_TFORLOOP */
119 | ,opmode(0, 0, OpArgU, OpArgU, iABC) /* OP_SETLIST */
120 | ,opmode(0, 1, OpArgU, OpArgN, iABx) /* OP_CLOSURE */
121 | ,opmode(0, 1, OpArgU, OpArgN, iABC) /* OP_VARARG */
122 | ,opmode(0, 0, OpArgU, OpArgU, iAx) /* OP_EXTRAARG */
123 | };
124 |
125 |
--------------------------------------------------------------------------------
/luajava/src/main/jni/lua/lparser.h:
--------------------------------------------------------------------------------
1 | /*
2 | ** $Id: lparser.h,v 1.76 2015/12/30 18:16:13 roberto Exp $
3 | ** Lua Parser
4 | ** See Copyright Notice in lua.h
5 | */
6 |
7 | #ifndef lparser_h
8 | #define lparser_h
9 |
10 | #include "llimits.h"
11 | #include "lobject.h"
12 | #include "lzio.h"
13 |
14 |
15 | /*
16 | ** Expression and variable descriptor.
17 | ** Code generation for variables and expressions can be delayed to allow
18 | ** optimizations; An 'expdesc' structure describes a potentially-delayed
19 | ** variable/expression. It has a description of its "main" value plus a
20 | ** list of conditional jumps that can also produce its value (generated
21 | ** by short-circuit operators 'and'/'or').
22 | */
23 |
24 | /* kinds of variables/expressions */
25 | typedef enum {
26 | VVOID, /* when 'expdesc' describes the last expression a list,
27 | this kind means an empty list (so, no expression) */
28 | VNIL, /* constant nil */
29 | VTRUE, /* constant true */
30 | VFALSE, /* constant false */
31 | VK, /* constant in 'k'; info = index of constant in 'k' */
32 | VKFLT, /* floating constant; nval = numerical float value */
33 | VKINT, /* integer constant; nval = numerical integer value */
34 | VNONRELOC, /* expression has its value in a fixed register;
35 | info = result register */
36 | VLOCAL, /* local variable; info = local register */
37 | VUPVAL, /* upvalue variable; info = index of upvalue in 'upvalues' */
38 | VINDEXED, /* indexed variable;
39 | ind.vt = whether 't' is register or upvalue;
40 | ind.t = table register or upvalue;
41 | ind.idx = key's R/K index */
42 | VJMP, /* expression is a test/comparison;
43 | info = pc of corresponding jump instruction */
44 | VRELOCABLE, /* expression can put result in any register;
45 | info = instruction pc */
46 | VCALL, /* expression is a function call; info = instruction pc */
47 | VVARARG /* vararg expression; info = instruction pc */
48 | } expkind;
49 |
50 |
51 | #define vkisvar(k) (VLOCAL <= (k) && (k) <= VINDEXED)
52 | #define vkisinreg(k) ((k) == VNONRELOC || (k) == VLOCAL)
53 |
54 | typedef struct expdesc {
55 | expkind k;
56 | union {
57 | lua_Integer ival; /* for VKINT */
58 | lua_Number nval; /* for VKFLT */
59 | int info; /* for generic use */
60 | struct { /* for indexed variables (VINDEXED) */
61 | short idx; /* index (R/K) */
62 | lu_byte t; /* table (register or upvalue) */
63 | lu_byte vt; /* whether 't' is register (VLOCAL) or upvalue (VUPVAL) */
64 | } ind;
65 | } u;
66 | int t; /* patch list of 'exit when true' */
67 | int f; /* patch list of 'exit when false' */
68 | } expdesc;
69 |
70 |
71 | /* description of active local variable */
72 | typedef struct Vardesc {
73 | short idx; /* variable index in stack */
74 | } Vardesc;
75 |
76 |
77 | /* description of pending goto statements and label statements */
78 | typedef struct Labeldesc {
79 | TString *name; /* label identifier */
80 | int pc; /* position in code */
81 | int line; /* line where it appeared */
82 | lu_byte nactvar; /* local level where it appears in current block */
83 | } Labeldesc;
84 |
85 |
86 | /* list of labels or gotos */
87 | typedef struct Labellist {
88 | Labeldesc *arr; /* array */
89 | int n; /* number of entries in use */
90 | int size; /* array size */
91 | } Labellist;
92 |
93 |
94 | /* dynamic structures used by the parser */
95 | typedef struct Dyndata {
96 | struct { /* list of active local variables */
97 | Vardesc *arr;
98 | int n;
99 | int size;
100 | } actvar;
101 | Labellist gt; /* list of pending gotos */
102 | Labellist label; /* list of active labels */
103 | } Dyndata;
104 |
105 |
106 | /* control of blocks */
107 | struct BlockCnt; /* defined in lparser.c */
108 |
109 |
110 | /* state needed to generate code for a given function */
111 | typedef struct FuncState {
112 | Proto *f; /* current function header */
113 | struct FuncState *prev; /* enclosing function */
114 | struct LexState *ls; /* lexical state */
115 | struct BlockCnt *bl; /* chain of current blocks */
116 | int pc; /* next position to code (equivalent to 'ncode') */
117 | int lasttarget; /* 'label' of last 'jump label' */
118 | int jpc; /* list of pending jumps to 'pc' */
119 | int nk; /* number of elements in 'k' */
120 | int np; /* number of elements in 'p' */
121 | int firstlocal; /* index of first local var (in Dyndata array) */
122 | short nlocvars; /* number of elements in 'f->locvars' */
123 | lu_byte nactvar; /* number of active local variables */
124 | lu_byte nups; /* number of upvalues */
125 | lu_byte freereg; /* first free register */
126 | } FuncState;
127 |
128 |
129 | LUAI_FUNC LClosure *luaY_parser (lua_State *L, ZIO *z, Mbuffer *buff,
130 | Dyndata *dyd, const char *name, int firstchar);
131 |
132 |
133 | #endif
134 |
--------------------------------------------------------------------------------
/luajava/src/main/jni/lua/lprefix.h:
--------------------------------------------------------------------------------
1 | /*
2 | ** $Id: lprefix.h,v 1.2 2014/12/29 16:54:13 roberto Exp $
3 | ** Definitions for Lua code that must come before any other header file
4 | ** See Copyright Notice in lua.h
5 | */
6 |
7 | #ifndef lprefix_h
8 | #define lprefix_h
9 |
10 |
11 | /*
12 | ** Allows POSIX/XSI stuff
13 | */
14 | #if !defined(LUA_USE_C89) /* { */
15 |
16 | #if !defined(_XOPEN_SOURCE)
17 | #define _XOPEN_SOURCE 600
18 | #elif _XOPEN_SOURCE == 0
19 | #undef _XOPEN_SOURCE /* use -D_XOPEN_SOURCE=0 to undefine it */
20 | #endif
21 |
22 | /*
23 | ** Allows manipulation of large files in gcc and some other compilers
24 | */
25 | #if !defined(LUA_32BITS) && !defined(_FILE_OFFSET_BITS)
26 | #define _LARGEFILE_SOURCE 1
27 | #define _FILE_OFFSET_BITS 64
28 | #endif
29 |
30 | #endif /* } */
31 |
32 |
33 | /*
34 | ** Windows stuff
35 | */
36 | #if defined(_WIN32) /* { */
37 |
38 | #if !defined(_CRT_SECURE_NO_WARNINGS)
39 | #define _CRT_SECURE_NO_WARNINGS /* avoid warnings about ISO C functions */
40 | #endif
41 |
42 | #endif /* } */
43 |
44 | #endif
45 |
46 |
--------------------------------------------------------------------------------
/luajava/src/main/jni/lua/lstate.h:
--------------------------------------------------------------------------------
1 | /*
2 | ** $Id: lstate.h,v 2.130 2015/12/16 16:39:38 roberto Exp $
3 | ** Global State
4 | ** See Copyright Notice in lua.h
5 | */
6 |
7 | #ifndef lstate_h
8 | #define lstate_h
9 |
10 | #include "lua.h"
11 |
12 | #include "lobject.h"
13 | #include "ltm.h"
14 | #include "lzio.h"
15 |
16 |
17 | /*
18 |
19 | ** Some notes about garbage-collected objects: All objects in Lua must
20 | ** be kept somehow accessible until being freed, so all objects always
21 | ** belong to one (and only one) of these lists, using field 'next' of
22 | ** the 'CommonHeader' for the link:
23 | **
24 | ** 'allgc': all objects not marked for finalization;
25 | ** 'finobj': all objects marked for finalization;
26 | ** 'tobefnz': all objects ready to be finalized;
27 | ** 'fixedgc': all objects that are not to be collected (currently
28 | ** only small strings, such as reserved words).
29 |
30 | */
31 |
32 |
33 | struct lua_longjmp; /* defined in ldo.c */
34 |
35 |
36 | /*
37 | ** Atomic type (relative to signals) to better ensure that 'lua_sethook'
38 | ** is thread safe
39 | */
40 | #if !defined(l_signalT)
41 | #include
42 | #define l_signalT sig_atomic_t
43 | #endif
44 |
45 |
46 | /* extra stack space to handle TM calls and some other extras */
47 | #define EXTRA_STACK 5
48 |
49 |
50 | #define BASIC_STACK_SIZE (2*LUA_MINSTACK)
51 |
52 |
53 | /* kinds of Garbage Collection */
54 | #define KGC_NORMAL 0
55 | #define KGC_EMERGENCY 1 /* gc was forced by an allocation failure */
56 |
57 |
58 | typedef struct stringtable {
59 | TString **hash;
60 | int nuse; /* number of elements */
61 | int size;
62 | } stringtable;
63 |
64 |
65 | /*
66 | ** Information about a call.
67 | ** When a thread yields, 'func' is adjusted to pretend that the
68 | ** top function has only the yielded values in its stack; in that
69 | ** case, the actual 'func' value is saved in field 'extra'.
70 | ** When a function calls another with a continuation, 'extra' keeps
71 | ** the function index so that, in case of errors, the continuation
72 | ** function can be called with the correct top.
73 | */
74 | typedef struct CallInfo {
75 | StkId func; /* function index in the stack */
76 | StkId top; /* top for this function */
77 | struct CallInfo *previous, *next; /* dynamic call link */
78 | union {
79 | struct { /* only for Lua functions */
80 | StkId base; /* base for this function */
81 | const Instruction *savedpc;
82 | } l;
83 | struct { /* only for C functions */
84 | lua_KFunction k; /* continuation in case of yields */
85 | ptrdiff_t old_errfunc;
86 | lua_KContext ctx; /* context info. in case of yields */
87 | } c;
88 | } u;
89 | ptrdiff_t extra;
90 | short nresults; /* expected number of results from this function */
91 | lu_byte callstatus;
92 | } CallInfo;
93 |
94 |
95 | /*
96 | ** Bits in CallInfo status
97 | */
98 | #define CIST_OAH (1<<0) /* original value of 'allowhook' */
99 | #define CIST_LUA (1<<1) /* call is running a Lua function */
100 | #define CIST_HOOKED (1<<2) /* call is running a debug hook */
101 | #define CIST_FRESH (1<<3) /* call is running on a fresh invocation
102 | of luaV_execute */
103 | #define CIST_YPCALL (1<<4) /* call is a yieldable protected call */
104 | #define CIST_TAIL (1<<5) /* call was tail called */
105 | #define CIST_HOOKYIELD (1<<6) /* last hook called yielded */
106 | #define CIST_LEQ (1<<7) /* using __lt for __le */
107 |
108 | #define isLua(ci) ((ci)->callstatus & CIST_LUA)
109 |
110 | /* assume that CIST_OAH has offset 0 and that 'v' is strictly 0/1 */
111 | #define setoah(st,v) ((st) = ((st) & ~CIST_OAH) | (v))
112 | #define getoah(st) ((st) & CIST_OAH)
113 |
114 |
115 | /*
116 | ** 'global state', shared by all threads of this state
117 | */
118 | typedef struct global_State {
119 | lua_Alloc frealloc; /* function to reallocate memory */
120 | void *ud; /* auxiliary data to 'frealloc' */
121 | l_mem totalbytes; /* number of bytes currently allocated - GCdebt */
122 | l_mem GCdebt; /* bytes allocated not yet compensated by the collector */
123 | lu_mem GCmemtrav; /* memory traversed by the GC */
124 | lu_mem GCestimate; /* an estimate of the non-garbage memory in use */
125 | stringtable strt; /* hash table for strings */
126 | TValue l_registry;
127 | unsigned int seed; /* randomized seed for hashes */
128 | lu_byte currentwhite;
129 | lu_byte gcstate; /* state of garbage collector */
130 | lu_byte gckind; /* kind of GC running */
131 | lu_byte gcrunning; /* true if GC is running */
132 | GCObject *allgc; /* list of all collectable objects */
133 | GCObject **sweepgc; /* current position of sweep in list */
134 | GCObject *finobj; /* list of collectable objects with finalizers */
135 | GCObject *gray; /* list of gray objects */
136 | GCObject *grayagain; /* list of objects to be traversed atomically */
137 | GCObject *weak; /* list of tables with weak values */
138 | GCObject *ephemeron; /* list of ephemeron tables (weak keys) */
139 | GCObject *allweak; /* list of all-weak tables */
140 | GCObject *tobefnz; /* list of userdata to be GC */
141 | GCObject *fixedgc; /* list of objects not to be collected */
142 | struct lua_State *twups; /* list of threads with open upvalues */
143 | unsigned int gcfinnum; /* number of finalizers to call in each GC step */
144 | int gcpause; /* size of pause between successive GCs */
145 | int gcstepmul; /* GC 'granularity' */
146 | lua_CFunction panic; /* to be called in unprotected errors */
147 | struct lua_State *mainthread;
148 | const lua_Number *version; /* pointer to version number */
149 | TString *memerrmsg; /* memory-error message */
150 | TString *tmname[TM_N]; /* array with tag-method names */
151 | struct Table *mt[LUA_NUMTAGS]; /* metatables for basic types */
152 | TString *strcache[STRCACHE_N][STRCACHE_M]; /* cache for strings in API */
153 | } global_State;
154 |
155 |
156 | /*
157 | ** 'per thread' state
158 | */
159 | struct lua_State {
160 | CommonHeader;
161 | unsigned short nci; /* number of items in 'ci' list */
162 | lu_byte status;
163 | StkId top; /* first free slot in the stack */
164 | global_State *l_G;
165 | CallInfo *ci; /* call info for current function */
166 | const Instruction *oldpc; /* last pc traced */
167 | StkId stack_last; /* last free slot in the stack */
168 | StkId stack; /* stack base */
169 | UpVal *openupval; /* list of open upvalues in this stack */
170 | GCObject *gclist;
171 | struct lua_State *twups; /* list of threads with open upvalues */
172 | struct lua_longjmp *errorJmp; /* current error recover point */
173 | CallInfo base_ci; /* CallInfo for first level (C calling Lua) */
174 | volatile lua_Hook hook;
175 | ptrdiff_t errfunc; /* current error handling function (stack index) */
176 | int stacksize;
177 | int basehookcount;
178 | int hookcount;
179 | unsigned short nny; /* number of non-yieldable calls in stack */
180 | unsigned short nCcalls; /* number of nested C calls */
181 | l_signalT hookmask;
182 | lu_byte allowhook;
183 | };
184 |
185 |
186 | #define G(L) (L->l_G)
187 |
188 |
189 | /*
190 | ** Union of all collectable objects (only for conversions)
191 | */
192 | union GCUnion {
193 | GCObject gc; /* common header */
194 | struct TString ts;
195 | struct Udata u;
196 | union Closure cl;
197 | struct Table h;
198 | struct Proto p;
199 | struct lua_State th; /* thread */
200 | };
201 |
202 |
203 | #define cast_u(o) cast(union GCUnion *, (o))
204 |
205 | /* macros to convert a GCObject into a specific value */
206 | #define gco2ts(o) \
207 | check_exp(novariant((o)->tt) == LUA_TSTRING, &((cast_u(o))->ts))
208 | #define gco2u(o) check_exp((o)->tt == LUA_TUSERDATA, &((cast_u(o))->u))
209 | #define gco2lcl(o) check_exp((o)->tt == LUA_TLCL, &((cast_u(o))->cl.l))
210 | #define gco2ccl(o) check_exp((o)->tt == LUA_TCCL, &((cast_u(o))->cl.c))
211 | #define gco2cl(o) \
212 | check_exp(novariant((o)->tt) == LUA_TFUNCTION, &((cast_u(o))->cl))
213 | #define gco2t(o) check_exp((o)->tt == LUA_TTABLE, &((cast_u(o))->h))
214 | #define gco2p(o) check_exp((o)->tt == LUA_TPROTO, &((cast_u(o))->p))
215 | #define gco2th(o) check_exp((o)->tt == LUA_TTHREAD, &((cast_u(o))->th))
216 |
217 |
218 | /* macro to convert a Lua object into a GCObject */
219 | #define obj2gco(v) \
220 | check_exp(novariant((v)->tt) < LUA_TDEADKEY, (&(cast_u(v)->gc)))
221 |
222 |
223 | /* actual number of total bytes allocated */
224 | #define gettotalbytes(g) cast(lu_mem, (g)->totalbytes + (g)->GCdebt)
225 |
226 | LUAI_FUNC void luaE_setdebt (global_State *g, l_mem debt);
227 | LUAI_FUNC void luaE_freethread (lua_State *L, lua_State *L1);
228 | LUAI_FUNC CallInfo *luaE_extendCI (lua_State *L);
229 | LUAI_FUNC void luaE_freeCI (lua_State *L);
230 | LUAI_FUNC void luaE_shrinkCI (lua_State *L);
231 |
232 |
233 | #endif
234 |
235 |
--------------------------------------------------------------------------------
/luajava/src/main/jni/lua/lstring.c:
--------------------------------------------------------------------------------
1 | /*
2 | ** $Id: lstring.c,v 2.56 2015/11/23 11:32:51 roberto Exp $
3 | ** String table (keeps all strings handled by Lua)
4 | ** See Copyright Notice in lua.h
5 | */
6 |
7 | #define lstring_c
8 | #define LUA_CORE
9 |
10 | #include "lprefix.h"
11 |
12 |
13 | #include
14 |
15 | #include "lua.h"
16 |
17 | #include "ldebug.h"
18 | #include "ldo.h"
19 | #include "lmem.h"
20 | #include "lobject.h"
21 | #include "lstate.h"
22 | #include "lstring.h"
23 |
24 |
25 | #define MEMERRMSG "not enough memory"
26 |
27 |
28 | /*
29 | ** Lua will use at most ~(2^LUAI_HASHLIMIT) bytes from a string to
30 | ** compute its hash
31 | */
32 | #if !defined(LUAI_HASHLIMIT)
33 | #define LUAI_HASHLIMIT 5
34 | #endif
35 |
36 |
37 | /*
38 | ** equality for long strings
39 | */
40 | int luaS_eqlngstr (TString *a, TString *b) {
41 | size_t len = a->u.lnglen;
42 | lua_assert(a->tt == LUA_TLNGSTR && b->tt == LUA_TLNGSTR);
43 | return (a == b) || /* same instance or... */
44 | ((len == b->u.lnglen) && /* equal length and ... */
45 | (memcmp(getstr(a), getstr(b), len) == 0)); /* equal contents */
46 | }
47 |
48 |
49 | unsigned int luaS_hash (const char *str, size_t l, unsigned int seed) {
50 | unsigned int h = seed ^ cast(unsigned int, l);
51 | size_t step = (l >> LUAI_HASHLIMIT) + 1;
52 | for (; l >= step; l -= step)
53 | h ^= ((h<<5) + (h>>2) + cast_byte(str[l - 1]));
54 | return h;
55 | }
56 |
57 |
58 | unsigned int luaS_hashlongstr (TString *ts) {
59 | lua_assert(ts->tt == LUA_TLNGSTR);
60 | if (ts->extra == 0) { /* no hash? */
61 | ts->hash = luaS_hash(getstr(ts), ts->u.lnglen, ts->hash);
62 | ts->extra = 1; /* now it has its hash */
63 | }
64 | return ts->hash;
65 | }
66 |
67 |
68 | /*
69 | ** resizes the string table
70 | */
71 | void luaS_resize (lua_State *L, int newsize) {
72 | int i;
73 | stringtable *tb = &G(L)->strt;
74 | if (newsize > tb->size) { /* grow table if needed */
75 | luaM_reallocvector(L, tb->hash, tb->size, newsize, TString *);
76 | for (i = tb->size; i < newsize; i++)
77 | tb->hash[i] = NULL;
78 | }
79 | for (i = 0; i < tb->size; i++) { /* rehash */
80 | TString *p = tb->hash[i];
81 | tb->hash[i] = NULL;
82 | while (p) { /* for each node in the list */
83 | TString *hnext = p->u.hnext; /* save next */
84 | unsigned int h = lmod(p->hash, newsize); /* new position */
85 | p->u.hnext = tb->hash[h]; /* chain it */
86 | tb->hash[h] = p;
87 | p = hnext;
88 | }
89 | }
90 | if (newsize < tb->size) { /* shrink table if needed */
91 | /* vanishing slice should be empty */
92 | lua_assert(tb->hash[newsize] == NULL && tb->hash[tb->size - 1] == NULL);
93 | luaM_reallocvector(L, tb->hash, tb->size, newsize, TString *);
94 | }
95 | tb->size = newsize;
96 | }
97 |
98 |
99 | /*
100 | ** Clear API string cache. (Entries cannot be empty, so fill them with
101 | ** a non-collectable string.)
102 | */
103 | void luaS_clearcache (global_State *g) {
104 | int i, j;
105 | for (i = 0; i < STRCACHE_N; i++)
106 | for (j = 0; j < STRCACHE_M; j++) {
107 | if (iswhite(g->strcache[i][j])) /* will entry be collected? */
108 | g->strcache[i][j] = g->memerrmsg; /* replace it with something fixed */
109 | }
110 | }
111 |
112 |
113 | /*
114 | ** Initialize the string table and the string cache
115 | */
116 | void luaS_init (lua_State *L) {
117 | global_State *g = G(L);
118 | int i, j;
119 | luaS_resize(L, MINSTRTABSIZE); /* initial size of string table */
120 | /* pre-create memory-error message */
121 | g->memerrmsg = luaS_newliteral(L, MEMERRMSG);
122 | luaC_fix(L, obj2gco(g->memerrmsg)); /* it should never be collected */
123 | for (i = 0; i < STRCACHE_N; i++) /* fill cache with valid strings */
124 | for (j = 0; j < STRCACHE_M; j++)
125 | g->strcache[i][j] = g->memerrmsg;
126 | }
127 |
128 |
129 |
130 | /*
131 | ** creates a new string object
132 | */
133 | static TString *createstrobj (lua_State *L, size_t l, int tag, unsigned int h) {
134 | TString *ts;
135 | GCObject *o;
136 | size_t totalsize; /* total size of TString object */
137 | totalsize = sizelstring(l);
138 | o = luaC_newobj(L, tag, totalsize);
139 | ts = gco2ts(o);
140 | ts->hash = h;
141 | ts->extra = 0;
142 | getstr(ts)[l] = '\0'; /* ending 0 */
143 | return ts;
144 | }
145 |
146 |
147 | TString *luaS_createlngstrobj (lua_State *L, size_t l) {
148 | TString *ts = createstrobj(L, l, LUA_TLNGSTR, G(L)->seed);
149 | ts->u.lnglen = l;
150 | return ts;
151 | }
152 |
153 |
154 | void luaS_remove (lua_State *L, TString *ts) {
155 | stringtable *tb = &G(L)->strt;
156 | TString **p = &tb->hash[lmod(ts->hash, tb->size)];
157 | while (*p != ts) /* find previous element */
158 | p = &(*p)->u.hnext;
159 | *p = (*p)->u.hnext; /* remove element from its list */
160 | tb->nuse--;
161 | }
162 |
163 |
164 | /*
165 | ** checks whether short string exists and reuses it or creates a new one
166 | */
167 | static TString *internshrstr (lua_State *L, const char *str, size_t l) {
168 | TString *ts;
169 | global_State *g = G(L);
170 | unsigned int h = luaS_hash(str, l, g->seed);
171 | TString **list = &g->strt.hash[lmod(h, g->strt.size)];
172 | lua_assert(str != NULL); /* otherwise 'memcmp'/'memcpy' are undefined */
173 | for (ts = *list; ts != NULL; ts = ts->u.hnext) {
174 | if (l == ts->shrlen &&
175 | (memcmp(str, getstr(ts), l * sizeof(char)) == 0)) {
176 | /* found! */
177 | if (isdead(g, ts)) /* dead (but not collected yet)? */
178 | changewhite(ts); /* resurrect it */
179 | return ts;
180 | }
181 | }
182 | if (g->strt.nuse >= g->strt.size && g->strt.size <= MAX_INT/2) {
183 | luaS_resize(L, g->strt.size * 2);
184 | list = &g->strt.hash[lmod(h, g->strt.size)]; /* recompute with new size */
185 | }
186 | ts = createstrobj(L, l, LUA_TSHRSTR, h);
187 | memcpy(getstr(ts), str, l * sizeof(char));
188 | ts->shrlen = cast_byte(l);
189 | ts->u.hnext = *list;
190 | *list = ts;
191 | g->strt.nuse++;
192 | return ts;
193 | }
194 |
195 |
196 | /*
197 | ** new string (with explicit length)
198 | */
199 | TString *luaS_newlstr (lua_State *L, const char *str, size_t l) {
200 | if (l <= LUAI_MAXSHORTLEN) /* short string? */
201 | return internshrstr(L, str, l);
202 | else {
203 | TString *ts;
204 | if (l >= (MAX_SIZE - sizeof(TString))/sizeof(char))
205 | luaM_toobig(L);
206 | ts = luaS_createlngstrobj(L, l);
207 | memcpy(getstr(ts), str, l * sizeof(char));
208 | return ts;
209 | }
210 | }
211 |
212 |
213 | /*
214 | ** Create or reuse a zero-terminated string, first checking in the
215 | ** cache (using the string address as a key). The cache can contain
216 | ** only zero-terminated strings, so it is safe to use 'strcmp' to
217 | ** check hits.
218 | */
219 | TString *luaS_new (lua_State *L, const char *str) {
220 | unsigned int i = point2uint(str) % STRCACHE_N; /* hash */
221 | int j;
222 | TString **p = G(L)->strcache[i];
223 | for (j = 0; j < STRCACHE_M; j++) {
224 | if (strcmp(str, getstr(p[j])) == 0) /* hit? */
225 | return p[j]; /* that is it */
226 | }
227 | /* normal route */
228 | for (j = STRCACHE_M - 1; j > 0; j--)
229 | p[j] = p[j - 1]; /* move out last element */
230 | /* new element is first in the list */
231 | p[0] = luaS_newlstr(L, str, strlen(str));
232 | return p[0];
233 | }
234 |
235 |
236 | Udata *luaS_newudata (lua_State *L, size_t s) {
237 | Udata *u;
238 | GCObject *o;
239 | if (s > MAX_SIZE - sizeof(Udata))
240 | luaM_toobig(L);
241 | o = luaC_newobj(L, LUA_TUSERDATA, sizeludata(s));
242 | u = gco2u(o);
243 | u->len = s;
244 | u->metatable = NULL;
245 | setuservalue(L, u, luaO_nilobject);
246 | return u;
247 | }
248 |
249 |
--------------------------------------------------------------------------------
/luajava/src/main/jni/lua/lstring.h:
--------------------------------------------------------------------------------
1 | /*
2 | ** $Id: lstring.h,v 1.61 2015/11/03 15:36:01 roberto Exp $
3 | ** String table (keep all strings handled by Lua)
4 | ** See Copyright Notice in lua.h
5 | */
6 |
7 | #ifndef lstring_h
8 | #define lstring_h
9 |
10 | #include "lgc.h"
11 | #include "lobject.h"
12 | #include "lstate.h"
13 |
14 |
15 | #define sizelstring(l) (sizeof(union UTString) + ((l) + 1) * sizeof(char))
16 |
17 | #define sizeludata(l) (sizeof(union UUdata) + (l))
18 | #define sizeudata(u) sizeludata((u)->len)
19 |
20 | #define luaS_newliteral(L, s) (luaS_newlstr(L, "" s, \
21 | (sizeof(s)/sizeof(char))-1))
22 |
23 |
24 | /*
25 | ** test whether a string is a reserved word
26 | */
27 | #define isreserved(s) ((s)->tt == LUA_TSHRSTR && (s)->extra > 0)
28 |
29 |
30 | /*
31 | ** equality for short strings, which are always internalized
32 | */
33 | #define eqshrstr(a,b) check_exp((a)->tt == LUA_TSHRSTR, (a) == (b))
34 |
35 |
36 | LUAI_FUNC unsigned int luaS_hash (const char *str, size_t l, unsigned int seed);
37 | LUAI_FUNC unsigned int luaS_hashlongstr (TString *ts);
38 | LUAI_FUNC int luaS_eqlngstr (TString *a, TString *b);
39 | LUAI_FUNC void luaS_resize (lua_State *L, int newsize);
40 | LUAI_FUNC void luaS_clearcache (global_State *g);
41 | LUAI_FUNC void luaS_init (lua_State *L);
42 | LUAI_FUNC void luaS_remove (lua_State *L, TString *ts);
43 | LUAI_FUNC Udata *luaS_newudata (lua_State *L, size_t s);
44 | LUAI_FUNC TString *luaS_newlstr (lua_State *L, const char *str, size_t l);
45 | LUAI_FUNC TString *luaS_new (lua_State *L, const char *str);
46 | LUAI_FUNC TString *luaS_createlngstrobj (lua_State *L, size_t l);
47 |
48 |
49 | #endif
50 |
--------------------------------------------------------------------------------
/luajava/src/main/jni/lua/ltable.h:
--------------------------------------------------------------------------------
1 | /*
2 | ** $Id: ltable.h,v 2.21 2015/11/03 15:47:30 roberto Exp $
3 | ** Lua tables (hash)
4 | ** See Copyright Notice in lua.h
5 | */
6 |
7 | #ifndef ltable_h
8 | #define ltable_h
9 |
10 | #include "lobject.h"
11 |
12 |
13 | #define gnode(t,i) (&(t)->node[i])
14 | #define gval(n) (&(n)->i_val)
15 | #define gnext(n) ((n)->i_key.nk.next)
16 |
17 |
18 | /* 'const' to avoid wrong writings that can mess up field 'next' */
19 | #define gkey(n) cast(const TValue*, (&(n)->i_key.tvk))
20 |
21 | /*
22 | ** writable version of 'gkey'; allows updates to individual fields,
23 | ** but not to the whole (which has incompatible type)
24 | */
25 | #define wgkey(n) (&(n)->i_key.nk)
26 |
27 | #define invalidateTMcache(t) ((t)->flags = 0)
28 |
29 |
30 | /* returns the key, given the value of a table entry */
31 | #define keyfromval(v) \
32 | (gkey(cast(Node *, cast(char *, (v)) - offsetof(Node, i_val))))
33 |
34 |
35 | LUAI_FUNC const TValue *luaH_getint (Table *t, lua_Integer key);
36 | LUAI_FUNC void luaH_setint (lua_State *L, Table *t, lua_Integer key,
37 | TValue *value);
38 | LUAI_FUNC const TValue *luaH_getshortstr (Table *t, TString *key);
39 | LUAI_FUNC const TValue *luaH_getstr (Table *t, TString *key);
40 | LUAI_FUNC const TValue *luaH_get (Table *t, const TValue *key);
41 | LUAI_FUNC TValue *luaH_newkey (lua_State *L, Table *t, const TValue *key);
42 | LUAI_FUNC TValue *luaH_set (lua_State *L, Table *t, const TValue *key);
43 | LUAI_FUNC Table *luaH_new (lua_State *L);
44 | LUAI_FUNC void luaH_resize (lua_State *L, Table *t, unsigned int nasize,
45 | unsigned int nhsize);
46 | LUAI_FUNC void luaH_resizearray (lua_State *L, Table *t, unsigned int nasize);
47 | LUAI_FUNC void luaH_free (lua_State *L, Table *t);
48 | LUAI_FUNC int luaH_next (lua_State *L, Table *t, StkId key);
49 | LUAI_FUNC int luaH_getn (Table *t);
50 |
51 |
52 | #if defined(LUA_DEBUG)
53 | LUAI_FUNC Node *luaH_mainposition (const Table *t, const TValue *key);
54 | LUAI_FUNC int luaH_isdummy (Node *n);
55 | #endif
56 |
57 |
58 | #endif
59 |
--------------------------------------------------------------------------------
/luajava/src/main/jni/lua/ltm.c:
--------------------------------------------------------------------------------
1 | /*
2 | ** $Id: ltm.c,v 2.37 2016/02/26 19:20:15 roberto Exp $
3 | ** Tag methods
4 | ** See Copyright Notice in lua.h
5 | */
6 |
7 | #define ltm_c
8 | #define LUA_CORE
9 |
10 | #include "lprefix.h"
11 |
12 |
13 | #include
14 |
15 | #include "lua.h"
16 |
17 | #include "ldebug.h"
18 | #include "ldo.h"
19 | #include "lobject.h"
20 | #include "lstate.h"
21 | #include "lstring.h"
22 | #include "ltable.h"
23 | #include "ltm.h"
24 | #include "lvm.h"
25 |
26 |
27 | static const char udatatypename[] = "userdata";
28 |
29 | LUAI_DDEF const char *const luaT_typenames_[LUA_TOTALTAGS] = {
30 | "no value",
31 | "nil", "boolean", udatatypename, "number",
32 | "string", "table", "function", udatatypename, "thread",
33 | "proto" /* this last case is used for tests only */
34 | };
35 |
36 |
37 | void luaT_init (lua_State *L) {
38 | static const char *const luaT_eventname[] = { /* ORDER TM */
39 | "__index", "__newindex",
40 | "__gc", "__mode", "__len", "__eq",
41 | "__add", "__sub", "__mul", "__mod", "__pow",
42 | "__div", "__idiv",
43 | "__band", "__bor", "__bxor", "__shl", "__shr",
44 | "__unm", "__bnot", "__lt", "__le",
45 | "__concat", "__call"
46 | };
47 | int i;
48 | for (i=0; itmname[i] = luaS_new(L, luaT_eventname[i]);
50 | luaC_fix(L, obj2gco(G(L)->tmname[i])); /* never collect these names */
51 | }
52 | }
53 |
54 |
55 | /*
56 | ** function to be used with macro "fasttm": optimized for absence of
57 | ** tag methods
58 | */
59 | const TValue *luaT_gettm (Table *events, TMS event, TString *ename) {
60 | const TValue *tm = luaH_getshortstr(events, ename);
61 | lua_assert(event <= TM_EQ);
62 | if (ttisnil(tm)) { /* no tag method? */
63 | events->flags |= cast_byte(1u<metatable;
75 | break;
76 | case LUA_TUSERDATA:
77 | mt = uvalue(o)->metatable;
78 | break;
79 | default:
80 | mt = G(L)->mt[ttnov(o)];
81 | }
82 | return (mt ? luaH_getshortstr(mt, G(L)->tmname[event]) : luaO_nilobject);
83 | }
84 |
85 |
86 | /*
87 | ** Return the name of the type of an object. For tables and userdata
88 | ** with metatable, use their '__name' metafield, if present.
89 | */
90 | const char *luaT_objtypename (lua_State *L, const TValue *o) {
91 | Table *mt;
92 | if ((ttistable(o) && (mt = hvalue(o)->metatable) != NULL) ||
93 | (ttisfulluserdata(o) && (mt = uvalue(o)->metatable) != NULL)) {
94 | const TValue *name = luaH_getshortstr(mt, luaS_new(L, "__name"));
95 | if (ttisstring(name)) /* is '__name' a string? */
96 | return getstr(tsvalue(name)); /* use it as type name */
97 | }
98 | return ttypename(ttnov(o)); /* else use standard type name */
99 | }
100 |
101 |
102 | void luaT_callTM (lua_State *L, const TValue *f, const TValue *p1,
103 | const TValue *p2, TValue *p3, int hasres) {
104 | ptrdiff_t result = savestack(L, p3);
105 | StkId func = L->top;
106 | setobj2s(L, func, f); /* push function (assume EXTRA_STACK) */
107 | setobj2s(L, func + 1, p1); /* 1st argument */
108 | setobj2s(L, func + 2, p2); /* 2nd argument */
109 | L->top += 3;
110 | if (!hasres) /* no result? 'p3' is third argument */
111 | setobj2s(L, L->top++, p3); /* 3rd argument */
112 | /* metamethod may yield only when called from Lua code */
113 | if (isLua(L->ci))
114 | luaD_call(L, func, hasres);
115 | else
116 | luaD_callnoyield(L, func, hasres);
117 | if (hasres) { /* if has result, move it to its place */
118 | p3 = restorestack(L, result);
119 | setobjs2s(L, p3, --L->top);
120 | }
121 | }
122 |
123 |
124 | int luaT_callbinTM (lua_State *L, const TValue *p1, const TValue *p2,
125 | StkId res, TMS event) {
126 | const TValue *tm = luaT_gettmbyobj(L, p1, event); /* try first operand */
127 | if (ttisnil(tm))
128 | tm = luaT_gettmbyobj(L, p2, event); /* try second operand */
129 | if (ttisnil(tm)) return 0;
130 | luaT_callTM(L, tm, p1, p2, res, 1);
131 | return 1;
132 | }
133 |
134 |
135 | void luaT_trybinTM (lua_State *L, const TValue *p1, const TValue *p2,
136 | StkId res, TMS event) {
137 | if (!luaT_callbinTM(L, p1, p2, res, event)) {
138 | switch (event) {
139 | case TM_CONCAT:
140 | luaG_concaterror(L, p1, p2);
141 | /* call never returns, but to avoid warnings: *//* FALLTHROUGH */
142 | case TM_BAND: case TM_BOR: case TM_BXOR:
143 | case TM_SHL: case TM_SHR: case TM_BNOT: {
144 | lua_Number dummy;
145 | if (tonumber(p1, &dummy) && tonumber(p2, &dummy))
146 | luaG_tointerror(L, p1, p2);
147 | else
148 | luaG_opinterror(L, p1, p2, "perform bitwise operation on");
149 | }
150 | /* calls never return, but to avoid warnings: *//* FALLTHROUGH */
151 | default:
152 | luaG_opinterror(L, p1, p2, "perform arithmetic on");
153 | }
154 | }
155 | }
156 |
157 |
158 | int luaT_callorderTM (lua_State *L, const TValue *p1, const TValue *p2,
159 | TMS event) {
160 | if (!luaT_callbinTM(L, p1, p2, L->top, event))
161 | return -1; /* no metamethod */
162 | else
163 | return !l_isfalse(L->top);
164 | }
165 |
166 |
--------------------------------------------------------------------------------
/luajava/src/main/jni/lua/ltm.h:
--------------------------------------------------------------------------------
1 | /*
2 | ** $Id: ltm.h,v 2.22 2016/02/26 19:20:15 roberto Exp $
3 | ** Tag methods
4 | ** See Copyright Notice in lua.h
5 | */
6 |
7 | #ifndef ltm_h
8 | #define ltm_h
9 |
10 |
11 | #include "lobject.h"
12 |
13 |
14 | /*
15 | * WARNING: if you change the order of this enumeration,
16 | * grep "ORDER TM" and "ORDER OP"
17 | */
18 | typedef enum {
19 | TM_INDEX,
20 | TM_NEWINDEX,
21 | TM_GC,
22 | TM_MODE,
23 | TM_LEN,
24 | TM_EQ, /* last tag method with fast access */
25 | TM_ADD,
26 | TM_SUB,
27 | TM_MUL,
28 | TM_MOD,
29 | TM_POW,
30 | TM_DIV,
31 | TM_IDIV,
32 | TM_BAND,
33 | TM_BOR,
34 | TM_BXOR,
35 | TM_SHL,
36 | TM_SHR,
37 | TM_UNM,
38 | TM_BNOT,
39 | TM_LT,
40 | TM_LE,
41 | TM_CONCAT,
42 | TM_CALL,
43 | TM_N /* number of elements in the enum */
44 | } TMS;
45 |
46 |
47 |
48 | #define gfasttm(g,et,e) ((et) == NULL ? NULL : \
49 | ((et)->flags & (1u<<(e))) ? NULL : luaT_gettm(et, e, (g)->tmname[e]))
50 |
51 | #define fasttm(l,et,e) gfasttm(G(l), et, e)
52 |
53 | #define ttypename(x) luaT_typenames_[(x) + 1]
54 |
55 | LUAI_DDEC const char *const luaT_typenames_[LUA_TOTALTAGS];
56 |
57 |
58 | LUAI_FUNC const char *luaT_objtypename (lua_State *L, const TValue *o);
59 |
60 | LUAI_FUNC const TValue *luaT_gettm (Table *events, TMS event, TString *ename);
61 | LUAI_FUNC const TValue *luaT_gettmbyobj (lua_State *L, const TValue *o,
62 | TMS event);
63 | LUAI_FUNC void luaT_init (lua_State *L);
64 |
65 | LUAI_FUNC void luaT_callTM (lua_State *L, const TValue *f, const TValue *p1,
66 | const TValue *p2, TValue *p3, int hasres);
67 | LUAI_FUNC int luaT_callbinTM (lua_State *L, const TValue *p1, const TValue *p2,
68 | StkId res, TMS event);
69 | LUAI_FUNC void luaT_trybinTM (lua_State *L, const TValue *p1, const TValue *p2,
70 | StkId res, TMS event);
71 | LUAI_FUNC int luaT_callorderTM (lua_State *L, const TValue *p1,
72 | const TValue *p2, TMS event);
73 |
74 |
75 |
76 | #endif
77 |
--------------------------------------------------------------------------------
/luajava/src/main/jni/lua/lua.hpp:
--------------------------------------------------------------------------------
1 | // lua.hpp
2 | // Lua header files for C++
3 | // <> not supplied automatically because Lua also compiles as C++
4 |
5 | extern "C" {
6 | #include "lua.h"
7 | #include "lualib.h"
8 | #include "lauxlib.h"
9 | }
10 |
--------------------------------------------------------------------------------
/luajava/src/main/jni/lua/lualib.h:
--------------------------------------------------------------------------------
1 | /*
2 | ** $Id: lualib.h,v 1.44 2014/02/06 17:32:33 roberto Exp $
3 | ** Lua standard libraries
4 | ** See Copyright Notice in lua.h
5 | */
6 |
7 |
8 | #ifndef lualib_h
9 | #define lualib_h
10 |
11 | #include "lua.h"
12 |
13 |
14 |
15 | LUAMOD_API int (luaopen_base) (lua_State *L);
16 |
17 | #define LUA_COLIBNAME "coroutine"
18 | LUAMOD_API int (luaopen_coroutine) (lua_State *L);
19 |
20 | #define LUA_TABLIBNAME "table"
21 | LUAMOD_API int (luaopen_table) (lua_State *L);
22 |
23 | #define LUA_IOLIBNAME "io"
24 | LUAMOD_API int (luaopen_io) (lua_State *L);
25 |
26 | #define LUA_OSLIBNAME "os"
27 | LUAMOD_API int (luaopen_os) (lua_State *L);
28 |
29 | #define LUA_STRLIBNAME "string"
30 | LUAMOD_API int (luaopen_string) (lua_State *L);
31 |
32 | #define LUA_UTF8LIBNAME "utf8"
33 | LUAMOD_API int (luaopen_utf8) (lua_State *L);
34 |
35 | #define LUA_BITLIBNAME "bit32"
36 | LUAMOD_API int (luaopen_bit32) (lua_State *L);
37 |
38 | #define LUA_MATHLIBNAME "math"
39 | LUAMOD_API int (luaopen_math) (lua_State *L);
40 |
41 | #define LUA_DBLIBNAME "debug"
42 | LUAMOD_API int (luaopen_debug) (lua_State *L);
43 |
44 | #define LUA_LOADLIBNAME "package"
45 | LUAMOD_API int (luaopen_package) (lua_State *L);
46 |
47 |
48 | /* open all previous libraries */
49 | LUALIB_API void (luaL_openlibs) (lua_State *L);
50 |
51 |
52 |
53 | #if !defined(lua_assert)
54 | #define lua_assert(x) ((void)0)
55 | #endif
56 |
57 |
58 | #endif
59 |
--------------------------------------------------------------------------------
/luajava/src/main/jni/lua/lundump.c:
--------------------------------------------------------------------------------
1 | /*
2 | ** $Id: lundump.c,v 2.44 2015/11/02 16:09:30 roberto Exp $
3 | ** load precompiled Lua chunks
4 | ** See Copyright Notice in lua.h
5 | */
6 |
7 | #define lundump_c
8 | #define LUA_CORE
9 |
10 | #include "lprefix.h"
11 |
12 |
13 | #include
14 |
15 | #include "lua.h"
16 |
17 | #include "ldebug.h"
18 | #include "ldo.h"
19 | #include "lfunc.h"
20 | #include "lmem.h"
21 | #include "lobject.h"
22 | #include "lstring.h"
23 | #include "lundump.h"
24 | #include "lzio.h"
25 |
26 |
27 | #if !defined(luai_verifycode)
28 | #define luai_verifycode(L,b,f) /* empty */
29 | #endif
30 |
31 |
32 | typedef struct {
33 | lua_State *L;
34 | ZIO *Z;
35 | const char *name;
36 | } LoadState;
37 |
38 |
39 | static l_noret error(LoadState *S, const char *why) {
40 | luaO_pushfstring(S->L, "%s: %s precompiled chunk", S->name, why);
41 | luaD_throw(S->L, LUA_ERRSYNTAX);
42 | }
43 |
44 |
45 | /*
46 | ** All high-level loads go through LoadVector; you can change it to
47 | ** adapt to the endianness of the input
48 | */
49 | #define LoadVector(S,b,n) LoadBlock(S,b,(n)*sizeof((b)[0]))
50 |
51 | static void LoadBlock (LoadState *S, void *b, size_t size) {
52 | if (luaZ_read(S->Z, b, size) != 0)
53 | error(S, "truncated");
54 | }
55 |
56 |
57 | #define LoadVar(S,x) LoadVector(S,&x,1)
58 |
59 |
60 | static lu_byte LoadByte (LoadState *S) {
61 | lu_byte x;
62 | LoadVar(S, x);
63 | return x;
64 | }
65 |
66 |
67 | static int LoadInt (LoadState *S) {
68 | int x;
69 | LoadVar(S, x);
70 | return x;
71 | }
72 |
73 |
74 | static lua_Number LoadNumber (LoadState *S) {
75 | lua_Number x;
76 | LoadVar(S, x);
77 | return x;
78 | }
79 |
80 |
81 | static lua_Integer LoadInteger (LoadState *S) {
82 | lua_Integer x;
83 | LoadVar(S, x);
84 | return x;
85 | }
86 |
87 |
88 | static TString *LoadString (LoadState *S) {
89 | size_t size = LoadByte(S);
90 | if (size == 0xFF)
91 | LoadVar(S, size);
92 | if (size == 0)
93 | return NULL;
94 | else if (--size <= LUAI_MAXSHORTLEN) { /* short string? */
95 | char buff[LUAI_MAXSHORTLEN];
96 | LoadVector(S, buff, size);
97 | return luaS_newlstr(S->L, buff, size);
98 | }
99 | else { /* long string */
100 | TString *ts = luaS_createlngstrobj(S->L, size);
101 | LoadVector(S, getstr(ts), size); /* load directly in final place */
102 | return ts;
103 | }
104 | }
105 |
106 |
107 | static void LoadCode (LoadState *S, Proto *f) {
108 | int n = LoadInt(S);
109 | f->code = luaM_newvector(S->L, n, Instruction);
110 | f->sizecode = n;
111 | LoadVector(S, f->code, n);
112 | }
113 |
114 |
115 | static void LoadFunction(LoadState *S, Proto *f, TString *psource);
116 |
117 |
118 | static void LoadConstants (LoadState *S, Proto *f) {
119 | int i;
120 | int n = LoadInt(S);
121 | f->k = luaM_newvector(S->L, n, TValue);
122 | f->sizek = n;
123 | for (i = 0; i < n; i++)
124 | setnilvalue(&f->k[i]);
125 | for (i = 0; i < n; i++) {
126 | TValue *o = &f->k[i];
127 | int t = LoadByte(S);
128 | switch (t) {
129 | case LUA_TNIL:
130 | setnilvalue(o);
131 | break;
132 | case LUA_TBOOLEAN:
133 | setbvalue(o, LoadByte(S));
134 | break;
135 | case LUA_TNUMFLT:
136 | setfltvalue(o, LoadNumber(S));
137 | break;
138 | case LUA_TNUMINT:
139 | setivalue(o, LoadInteger(S));
140 | break;
141 | case LUA_TSHRSTR:
142 | case LUA_TLNGSTR:
143 | setsvalue2n(S->L, o, LoadString(S));
144 | break;
145 | default:
146 | lua_assert(0);
147 | }
148 | }
149 | }
150 |
151 |
152 | static void LoadProtos (LoadState *S, Proto *f) {
153 | int i;
154 | int n = LoadInt(S);
155 | f->p = luaM_newvector(S->L, n, Proto *);
156 | f->sizep = n;
157 | for (i = 0; i < n; i++)
158 | f->p[i] = NULL;
159 | for (i = 0; i < n; i++) {
160 | f->p[i] = luaF_newproto(S->L);
161 | LoadFunction(S, f->p[i], f->source);
162 | }
163 | }
164 |
165 |
166 | static void LoadUpvalues (LoadState *S, Proto *f) {
167 | int i, n;
168 | n = LoadInt(S);
169 | f->upvalues = luaM_newvector(S->L, n, Upvaldesc);
170 | f->sizeupvalues = n;
171 | for (i = 0; i < n; i++)
172 | f->upvalues[i].name = NULL;
173 | for (i = 0; i < n; i++) {
174 | f->upvalues[i].instack = LoadByte(S);
175 | f->upvalues[i].idx = LoadByte(S);
176 | }
177 | }
178 |
179 |
180 | static void LoadDebug (LoadState *S, Proto *f) {
181 | int i, n;
182 | n = LoadInt(S);
183 | f->lineinfo = luaM_newvector(S->L, n, int);
184 | f->sizelineinfo = n;
185 | LoadVector(S, f->lineinfo, n);
186 | n = LoadInt(S);
187 | f->locvars = luaM_newvector(S->L, n, LocVar);
188 | f->sizelocvars = n;
189 | for (i = 0; i < n; i++)
190 | f->locvars[i].varname = NULL;
191 | for (i = 0; i < n; i++) {
192 | f->locvars[i].varname = LoadString(S);
193 | f->locvars[i].startpc = LoadInt(S);
194 | f->locvars[i].endpc = LoadInt(S);
195 | }
196 | n = LoadInt(S);
197 | for (i = 0; i < n; i++)
198 | f->upvalues[i].name = LoadString(S);
199 | }
200 |
201 |
202 | static void LoadFunction (LoadState *S, Proto *f, TString *psource) {
203 | f->source = LoadString(S);
204 | if (f->source == NULL) /* no source in dump? */
205 | f->source = psource; /* reuse parent's source */
206 | f->linedefined = LoadInt(S);
207 | f->lastlinedefined = LoadInt(S);
208 | f->numparams = LoadByte(S);
209 | f->is_vararg = LoadByte(S);
210 | f->maxstacksize = LoadByte(S);
211 | LoadCode(S, f);
212 | LoadConstants(S, f);
213 | LoadUpvalues(S, f);
214 | LoadProtos(S, f);
215 | LoadDebug(S, f);
216 | }
217 |
218 |
219 | static void checkliteral (LoadState *S, const char *s, const char *msg) {
220 | char buff[sizeof(LUA_SIGNATURE) + sizeof(LUAC_DATA)]; /* larger than both */
221 | size_t len = strlen(s);
222 | LoadVector(S, buff, len);
223 | if (memcmp(s, buff, len) != 0)
224 | error(S, msg);
225 | }
226 |
227 |
228 | static void fchecksize (LoadState *S, size_t size, const char *tname) {
229 | if (LoadByte(S) != size)
230 | error(S, luaO_pushfstring(S->L, "%s size mismatch in", tname));
231 | }
232 |
233 |
234 | #define checksize(S,t) fchecksize(S,sizeof(t),#t)
235 |
236 | static void checkHeader (LoadState *S) {
237 | checkliteral(S, LUA_SIGNATURE + 1, "not a"); /* 1st char already checked */
238 | if (LoadByte(S) != LUAC_VERSION)
239 | error(S, "version mismatch in");
240 | if (LoadByte(S) != LUAC_FORMAT)
241 | error(S, "format mismatch in");
242 | checkliteral(S, LUAC_DATA, "corrupted");
243 | checksize(S, int);
244 | checksize(S, size_t);
245 | checksize(S, Instruction);
246 | checksize(S, lua_Integer);
247 | checksize(S, lua_Number);
248 | if (LoadInteger(S) != LUAC_INT)
249 | error(S, "endianness mismatch in");
250 | if (LoadNumber(S) != LUAC_NUM)
251 | error(S, "float format mismatch in");
252 | }
253 |
254 |
255 | /*
256 | ** load precompiled chunk
257 | */
258 | LClosure *luaU_undump(lua_State *L, ZIO *Z, const char *name) {
259 | LoadState S;
260 | LClosure *cl;
261 | if (*name == '@' || *name == '=')
262 | S.name = name + 1;
263 | else if (*name == LUA_SIGNATURE[0])
264 | S.name = "binary string";
265 | else
266 | S.name = name;
267 | S.L = L;
268 | S.Z = Z;
269 | checkHeader(&S);
270 | cl = luaF_newLclosure(L, LoadByte(&S));
271 | setclLvalue(L, L->top, cl);
272 | luaD_inctop(L);
273 | cl->p = luaF_newproto(L);
274 | LoadFunction(&S, cl->p, NULL);
275 | lua_assert(cl->nupvalues == cl->p->sizeupvalues);
276 | luai_verifycode(L, buff, cl->p);
277 | return cl;
278 | }
279 |
280 |
--------------------------------------------------------------------------------
/luajava/src/main/jni/lua/lundump.h:
--------------------------------------------------------------------------------
1 | /*
2 | ** $Id: lundump.h,v 1.45 2015/09/08 15:41:05 roberto Exp $
3 | ** load precompiled Lua chunks
4 | ** See Copyright Notice in lua.h
5 | */
6 |
7 | #ifndef lundump_h
8 | #define lundump_h
9 |
10 | #include "llimits.h"
11 | #include "lobject.h"
12 | #include "lzio.h"
13 |
14 |
15 | /* data to catch conversion errors */
16 | #define LUAC_DATA "\x19\x93\r\n\x1a\n"
17 |
18 | #define LUAC_INT 0x5678
19 | #define LUAC_NUM cast_num(370.5)
20 |
21 | #define MYINT(s) (s[0]-'0')
22 | #define LUAC_VERSION (MYINT(LUA_VERSION_MAJOR)*16+MYINT(LUA_VERSION_MINOR))
23 | #define LUAC_FORMAT 0 /* this is the official format */
24 |
25 | /* load one chunk; from lundump.c */
26 | LUAI_FUNC LClosure* luaU_undump (lua_State* L, ZIO* Z, const char* name);
27 |
28 | /* dump one chunk; from ldump.c */
29 | LUAI_FUNC int luaU_dump (lua_State* L, const Proto* f, lua_Writer w,
30 | void* data, int strip);
31 |
32 | #endif
33 |
--------------------------------------------------------------------------------
/luajava/src/main/jni/lua/lutf8lib.c:
--------------------------------------------------------------------------------
1 | /*
2 | ** $Id: lutf8lib.c,v 1.15 2015/03/28 19:16:55 roberto Exp $
3 | ** Standard library for UTF-8 manipulation
4 | ** See Copyright Notice in lua.h
5 | */
6 |
7 | #define lutf8lib_c
8 | #define LUA_LIB
9 |
10 | #include "lprefix.h"
11 |
12 |
13 | #include
14 | #include
15 | #include
16 | #include
17 |
18 | #include "lua.h"
19 |
20 | #include "lauxlib.h"
21 | #include "lualib.h"
22 |
23 | #define MAXUNICODE 0x10FFFF
24 |
25 | #define iscont(p) ((*(p) & 0xC0) == 0x80)
26 |
27 |
28 | /* from strlib */
29 | /* translate a relative string position: negative means back from end */
30 | static lua_Integer u_posrelat (lua_Integer pos, size_t len) {
31 | if (pos >= 0) return pos;
32 | else if (0u - (size_t)pos > len) return 0;
33 | else return (lua_Integer)len + pos + 1;
34 | }
35 |
36 |
37 | /*
38 | ** Decode one UTF-8 sequence, returning NULL if byte sequence is invalid.
39 | */
40 | static const char *utf8_decode (const char *o, int *val) {
41 | static const unsigned int limits[] = {0xFF, 0x7F, 0x7FF, 0xFFFF};
42 | const unsigned char *s = (const unsigned char *)o;
43 | unsigned int c = s[0];
44 | unsigned int res = 0; /* final result */
45 | if (c < 0x80) /* ascii? */
46 | res = c;
47 | else {
48 | int count = 0; /* to count number of continuation bytes */
49 | while (c & 0x40) { /* still have continuation bytes? */
50 | int cc = s[++count]; /* read next byte */
51 | if ((cc & 0xC0) != 0x80) /* not a continuation byte? */
52 | return NULL; /* invalid byte sequence */
53 | res = (res << 6) | (cc & 0x3F); /* add lower 6 bits from cont. byte */
54 | c <<= 1; /* to test next bit */
55 | }
56 | res |= ((c & 0x7F) << (count * 5)); /* add first byte */
57 | if (count > 3 || res > MAXUNICODE || res <= limits[count])
58 | return NULL; /* invalid byte sequence */
59 | s += count; /* skip continuation bytes read */
60 | }
61 | if (val) *val = res;
62 | return (const char *)s + 1; /* +1 to include first byte */
63 | }
64 |
65 |
66 | /*
67 | ** utf8len(s [, i [, j]]) --> number of characters that start in the
68 | ** range [i,j], or nil + current position if 's' is not well formed in
69 | ** that interval
70 | */
71 | static int utflen (lua_State *L) {
72 | int n = 0;
73 | size_t len;
74 | const char *s = luaL_checklstring(L, 1, &len);
75 | lua_Integer posi = u_posrelat(luaL_optinteger(L, 2, 1), len);
76 | lua_Integer posj = u_posrelat(luaL_optinteger(L, 3, -1), len);
77 | luaL_argcheck(L, 1 <= posi && --posi <= (lua_Integer)len, 2,
78 | "initial position out of string");
79 | luaL_argcheck(L, --posj < (lua_Integer)len, 3,
80 | "final position out of string");
81 | while (posi <= posj) {
82 | const char *s1 = utf8_decode(s + posi, NULL);
83 | if (s1 == NULL) { /* conversion error? */
84 | lua_pushnil(L); /* return nil ... */
85 | lua_pushinteger(L, posi + 1); /* ... and current position */
86 | return 2;
87 | }
88 | posi = s1 - s;
89 | n++;
90 | }
91 | lua_pushinteger(L, n);
92 | return 1;
93 | }
94 |
95 |
96 | /*
97 | ** codepoint(s, [i, [j]]) -> returns codepoints for all characters
98 | ** that start in the range [i,j]
99 | */
100 | static int codepoint (lua_State *L) {
101 | size_t len;
102 | const char *s = luaL_checklstring(L, 1, &len);
103 | lua_Integer posi = u_posrelat(luaL_optinteger(L, 2, 1), len);
104 | lua_Integer pose = u_posrelat(luaL_optinteger(L, 3, posi), len);
105 | int n;
106 | const char *se;
107 | luaL_argcheck(L, posi >= 1, 2, "out of range");
108 | luaL_argcheck(L, pose <= (lua_Integer)len, 3, "out of range");
109 | if (posi > pose) return 0; /* empty interval; return no values */
110 | if (pose - posi >= INT_MAX) /* (lua_Integer -> int) overflow? */
111 | return luaL_error(L, "string slice too long");
112 | n = (int)(pose - posi) + 1;
113 | luaL_checkstack(L, n, "string slice too long");
114 | n = 0;
115 | se = s + pose;
116 | for (s += posi - 1; s < se;) {
117 | int code;
118 | s = utf8_decode(s, &code);
119 | if (s == NULL)
120 | return luaL_error(L, "invalid UTF-8 code");
121 | lua_pushinteger(L, code);
122 | n++;
123 | }
124 | return n;
125 | }
126 |
127 |
128 | static void pushutfchar (lua_State *L, int arg) {
129 | lua_Integer code = luaL_checkinteger(L, arg);
130 | luaL_argcheck(L, 0 <= code && code <= MAXUNICODE, arg, "value out of range");
131 | lua_pushfstring(L, "%U", (long)code);
132 | }
133 |
134 |
135 | /*
136 | ** utfchar(n1, n2, ...) -> char(n1)..char(n2)...
137 | */
138 | static int utfchar (lua_State *L) {
139 | int n = lua_gettop(L); /* number of arguments */
140 | if (n == 1) /* optimize common case of single char */
141 | pushutfchar(L, 1);
142 | else {
143 | int i;
144 | luaL_Buffer b;
145 | luaL_buffinit(L, &b);
146 | for (i = 1; i <= n; i++) {
147 | pushutfchar(L, i);
148 | luaL_addvalue(&b);
149 | }
150 | luaL_pushresult(&b);
151 | }
152 | return 1;
153 | }
154 |
155 |
156 | /*
157 | ** offset(s, n, [i]) -> index where n-th character counting from
158 | ** position 'i' starts; 0 means character at 'i'.
159 | */
160 | static int byteoffset (lua_State *L) {
161 | size_t len;
162 | const char *s = luaL_checklstring(L, 1, &len);
163 | lua_Integer n = luaL_checkinteger(L, 2);
164 | lua_Integer posi = (n >= 0) ? 1 : len + 1;
165 | posi = u_posrelat(luaL_optinteger(L, 3, posi), len);
166 | luaL_argcheck(L, 1 <= posi && --posi <= (lua_Integer)len, 3,
167 | "position out of range");
168 | if (n == 0) {
169 | /* find beginning of current byte sequence */
170 | while (posi > 0 && iscont(s + posi)) posi--;
171 | }
172 | else {
173 | if (iscont(s + posi))
174 | luaL_error(L, "initial position is a continuation byte");
175 | if (n < 0) {
176 | while (n < 0 && posi > 0) { /* move back */
177 | do { /* find beginning of previous character */
178 | posi--;
179 | } while (posi > 0 && iscont(s + posi));
180 | n++;
181 | }
182 | }
183 | else {
184 | n--; /* do not move for 1st character */
185 | while (n > 0 && posi < (lua_Integer)len) {
186 | do { /* find beginning of next character */
187 | posi++;
188 | } while (iscont(s + posi)); /* (cannot pass final '\0') */
189 | n--;
190 | }
191 | }
192 | }
193 | if (n == 0) /* did it find given character? */
194 | lua_pushinteger(L, posi + 1);
195 | else /* no such character */
196 | lua_pushnil(L);
197 | return 1;
198 | }
199 |
200 |
201 | static int iter_aux (lua_State *L) {
202 | size_t len;
203 | const char *s = luaL_checklstring(L, 1, &len);
204 | lua_Integer n = lua_tointeger(L, 2) - 1;
205 | if (n < 0) /* first iteration? */
206 | n = 0; /* start from here */
207 | else if (n < (lua_Integer)len) {
208 | n++; /* skip current byte */
209 | while (iscont(s + n)) n++; /* and its continuations */
210 | }
211 | if (n >= (lua_Integer)len)
212 | return 0; /* no more codepoints */
213 | else {
214 | int code;
215 | const char *next = utf8_decode(s + n, &code);
216 | if (next == NULL || iscont(next))
217 | return luaL_error(L, "invalid UTF-8 code");
218 | lua_pushinteger(L, n + 1);
219 | lua_pushinteger(L, code);
220 | return 2;
221 | }
222 | }
223 |
224 |
225 | static int iter_codes (lua_State *L) {
226 | luaL_checkstring(L, 1);
227 | lua_pushcfunction(L, iter_aux);
228 | lua_pushvalue(L, 1);
229 | lua_pushinteger(L, 0);
230 | return 3;
231 | }
232 |
233 |
234 | /* pattern to match a single UTF-8 character */
235 | #define UTF8PATT "[\0-\x7F\xC2-\xF4][\x80-\xBF]*"
236 |
237 |
238 | static const luaL_Reg funcs[] = {
239 | {"offset", byteoffset},
240 | {"codepoint", codepoint},
241 | {"char", utfchar},
242 | {"len", utflen},
243 | {"codes", iter_codes},
244 | /* placeholders */
245 | {"charpattern", NULL},
246 | {NULL, NULL}
247 | };
248 |
249 |
250 | LUAMOD_API int luaopen_utf8 (lua_State *L) {
251 | luaL_newlib(L, funcs);
252 | lua_pushlstring(L, UTF8PATT, sizeof(UTF8PATT)/sizeof(char) - 1);
253 | lua_setfield(L, -2, "charpattern");
254 | return 1;
255 | }
256 |
257 |
--------------------------------------------------------------------------------
/luajava/src/main/jni/lua/lvm.h:
--------------------------------------------------------------------------------
1 | /*
2 | ** $Id: lvm.h,v 2.40 2016/01/05 16:07:21 roberto Exp $
3 | ** Lua virtual machine
4 | ** See Copyright Notice in lua.h
5 | */
6 |
7 | #ifndef lvm_h
8 | #define lvm_h
9 |
10 |
11 | #include "ldo.h"
12 | #include "lobject.h"
13 | #include "ltm.h"
14 |
15 |
16 | #if !defined(LUA_NOCVTN2S)
17 | #define cvt2str(o) ttisnumber(o)
18 | #else
19 | #define cvt2str(o) 0 /* no conversion from numbers to strings */
20 | #endif
21 |
22 |
23 | #if !defined(LUA_NOCVTS2N)
24 | #define cvt2num(o) ttisstring(o)
25 | #else
26 | #define cvt2num(o) 0 /* no conversion from strings to numbers */
27 | #endif
28 |
29 |
30 | /*
31 | ** You can define LUA_FLOORN2I if you want to convert floats to integers
32 | ** by flooring them (instead of raising an error if they are not
33 | ** integral values)
34 | */
35 | #if !defined(LUA_FLOORN2I)
36 | #define LUA_FLOORN2I 0
37 | #endif
38 |
39 |
40 | #define tonumber(o,n) \
41 | (ttisfloat(o) ? (*(n) = fltvalue(o), 1) : luaV_tonumber_(o,n))
42 |
43 | #define tointeger(o,i) \
44 | (ttisinteger(o) ? (*(i) = ivalue(o), 1) : luaV_tointeger(o,i,LUA_FLOORN2I))
45 |
46 | #define intop(op,v1,v2) l_castU2S(l_castS2U(v1) op l_castS2U(v2))
47 |
48 | #define luaV_rawequalobj(t1,t2) luaV_equalobj(NULL,t1,t2)
49 |
50 |
51 | /*
52 | ** fast track for 'gettable': if 't' is a table and 't[k]' is not nil,
53 | ** return 1 with 'slot' pointing to 't[k]' (final result). Otherwise,
54 | ** return 0 (meaning it will have to check metamethod) with 'slot'
55 | ** pointing to a nil 't[k]' (if 't' is a table) or NULL (otherwise).
56 | ** 'f' is the raw get function to use.
57 | */
58 | #define luaV_fastget(L,t,k,slot,f) \
59 | (!ttistable(t) \
60 | ? (slot = NULL, 0) /* not a table; 'slot' is NULL and result is 0 */ \
61 | : (slot = f(hvalue(t), k), /* else, do raw access */ \
62 | !ttisnil(slot))) /* result not nil? */
63 |
64 | /*
65 | ** standard implementation for 'gettable'
66 | */
67 | #define luaV_gettable(L,t,k,v) { const TValue *slot; \
68 | if (luaV_fastget(L,t,k,slot,luaH_get)) { setobj2s(L, v, slot); } \
69 | else luaV_finishget(L,t,k,v,slot); }
70 |
71 |
72 | /*
73 | ** Fast track for set table. If 't' is a table and 't[k]' is not nil,
74 | ** call GC barrier, do a raw 't[k]=v', and return true; otherwise,
75 | ** return false with 'slot' equal to NULL (if 't' is not a table) or
76 | ** 'nil'. (This is needed by 'luaV_finishget'.) Note that, if the macro
77 | ** returns true, there is no need to 'invalidateTMcache', because the
78 | ** call is not creating a new entry.
79 | */
80 | #define luaV_fastset(L,t,k,slot,f,v) \
81 | (!ttistable(t) \
82 | ? (slot = NULL, 0) \
83 | : (slot = f(hvalue(t), k), \
84 | ttisnil(slot) ? 0 \
85 | : (luaC_barrierback(L, hvalue(t), v), \
86 | setobj2t(L, cast(TValue *,slot), v), \
87 | 1)))
88 |
89 |
90 | #define luaV_settable(L,t,k,v) { const TValue *slot; \
91 | if (!luaV_fastset(L,t,k,slot,luaH_get,v)) \
92 | luaV_finishset(L,t,k,v,slot); }
93 |
94 |
95 |
96 | LUAI_FUNC int luaV_equalobj (lua_State *L, const TValue *t1, const TValue *t2);
97 | LUAI_FUNC int luaV_lessthan (lua_State *L, const TValue *l, const TValue *r);
98 | LUAI_FUNC int luaV_lessequal (lua_State *L, const TValue *l, const TValue *r);
99 | LUAI_FUNC int luaV_tonumber_ (const TValue *obj, lua_Number *n);
100 | LUAI_FUNC int luaV_tointeger (const TValue *obj, lua_Integer *p, int mode);
101 | LUAI_FUNC void luaV_finishget (lua_State *L, const TValue *t, TValue *key,
102 | StkId val, const TValue *slot);
103 | LUAI_FUNC void luaV_finishset (lua_State *L, const TValue *t, TValue *key,
104 | StkId val, const TValue *slot);
105 | LUAI_FUNC void luaV_finishOp (lua_State *L);
106 | LUAI_FUNC void luaV_execute (lua_State *L);
107 | LUAI_FUNC void luaV_concat (lua_State *L, int total);
108 | LUAI_FUNC lua_Integer luaV_div (lua_State *L, lua_Integer x, lua_Integer y);
109 | LUAI_FUNC lua_Integer luaV_mod (lua_State *L, lua_Integer x, lua_Integer y);
110 | LUAI_FUNC lua_Integer luaV_shiftl (lua_Integer x, lua_Integer y);
111 | LUAI_FUNC void luaV_objlen (lua_State *L, StkId ra, const TValue *rb);
112 |
113 | #endif
114 |
--------------------------------------------------------------------------------
/luajava/src/main/jni/lua/lzio.c:
--------------------------------------------------------------------------------
1 | /*
2 | ** $Id: lzio.c,v 1.37 2015/09/08 15:41:05 roberto Exp $
3 | ** Buffered streams
4 | ** See Copyright Notice in lua.h
5 | */
6 |
7 | #define lzio_c
8 | #define LUA_CORE
9 |
10 | #include "lprefix.h"
11 |
12 |
13 | #include
14 |
15 | #include "lua.h"
16 |
17 | #include "llimits.h"
18 | #include "lmem.h"
19 | #include "lstate.h"
20 | #include "lzio.h"
21 |
22 |
23 | int luaZ_fill (ZIO *z) {
24 | size_t size;
25 | lua_State *L = z->L;
26 | const char *buff;
27 | lua_unlock(L);
28 | buff = z->reader(L, z->data, &size);
29 | lua_lock(L);
30 | if (buff == NULL || size == 0)
31 | return EOZ;
32 | z->n = size - 1; /* discount char being returned */
33 | z->p = buff;
34 | return cast_uchar(*(z->p++));
35 | }
36 |
37 |
38 | void luaZ_init (lua_State *L, ZIO *z, lua_Reader reader, void *data) {
39 | z->L = L;
40 | z->reader = reader;
41 | z->data = data;
42 | z->n = 0;
43 | z->p = NULL;
44 | }
45 |
46 |
47 | /* --------------------------------------------------------------- read --- */
48 | size_t luaZ_read (ZIO *z, void *b, size_t n) {
49 | while (n) {
50 | size_t m;
51 | if (z->n == 0) { /* no bytes in buffer? */
52 | if (luaZ_fill(z) == EOZ) /* try to read more */
53 | return n; /* no more input; return number of missing bytes */
54 | else {
55 | z->n++; /* luaZ_fill consumed first byte; put it back */
56 | z->p--;
57 | }
58 | }
59 | m = (n <= z->n) ? n : z->n; /* min. between n and z->n */
60 | memcpy(b, z->p, m);
61 | z->n -= m;
62 | z->p += m;
63 | b = (char *)b + m;
64 | n -= m;
65 | }
66 | return 0;
67 | }
68 |
69 |
--------------------------------------------------------------------------------
/luajava/src/main/jni/lua/lzio.h:
--------------------------------------------------------------------------------
1 | /*
2 | ** $Id: lzio.h,v 1.31 2015/09/08 15:41:05 roberto Exp $
3 | ** Buffered streams
4 | ** See Copyright Notice in lua.h
5 | */
6 |
7 |
8 | #ifndef lzio_h
9 | #define lzio_h
10 |
11 | #include "lua.h"
12 |
13 | #include "lmem.h"
14 |
15 |
16 | #define EOZ (-1) /* end of stream */
17 |
18 | typedef struct Zio ZIO;
19 |
20 | #define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z))
21 |
22 |
23 | typedef struct Mbuffer {
24 | char *buffer;
25 | size_t n;
26 | size_t buffsize;
27 | } Mbuffer;
28 |
29 | #define luaZ_initbuffer(L, buff) ((buff)->buffer = NULL, (buff)->buffsize = 0)
30 |
31 | #define luaZ_buffer(buff) ((buff)->buffer)
32 | #define luaZ_sizebuffer(buff) ((buff)->buffsize)
33 | #define luaZ_bufflen(buff) ((buff)->n)
34 |
35 | #define luaZ_buffremove(buff,i) ((buff)->n -= (i))
36 | #define luaZ_resetbuffer(buff) ((buff)->n = 0)
37 |
38 |
39 | #define luaZ_resizebuffer(L, buff, size) \
40 | ((buff)->buffer = luaM_reallocvchar(L, (buff)->buffer, \
41 | (buff)->buffsize, size), \
42 | (buff)->buffsize = size)
43 |
44 | #define luaZ_freebuffer(L, buff) luaZ_resizebuffer(L, buff, 0)
45 |
46 |
47 | LUAI_FUNC void luaZ_init (lua_State *L, ZIO *z, lua_Reader reader,
48 | void *data);
49 | LUAI_FUNC size_t luaZ_read (ZIO* z, void *b, size_t n); /* read next n bytes */
50 |
51 |
52 |
53 | /* --------- Private Part ------------------ */
54 |
55 | struct Zio {
56 | size_t n; /* bytes still unread */
57 | const char *p; /* current position in buffer */
58 | lua_Reader reader; /* reader function */
59 | void *data; /* additional data */
60 | lua_State *L; /* Lua state (for reader) */
61 | };
62 |
63 |
64 | LUAI_FUNC int luaZ_fill (ZIO *z);
65 |
66 | #endif
67 |
--------------------------------------------------------------------------------
/luajava/src/main/jni/luajava/Android.mk:
--------------------------------------------------------------------------------
1 | LOCAL_PATH := $(call my-dir)
2 |
3 | include $(CLEAR_VARS)
4 |
5 | LOCAL_C_INCLUDES += $(LOCAL_PATH)/../lua
6 | LOCAL_MODULE := luajava
7 | LOCAL_SRC_FILES := luajava.c
8 | LOCAL_STATIC_LIBRARIES := liblua
9 |
10 | LOCAL_LDLIBS := -llog
11 |
12 | LOCAL_CFLAGS += -DLUA_DL_DLOPEN -DLUA_USE_C89 -DLUA_COMPAT_5_1 -DLUA_COMPAT_5_2 -DLUA_USE_LINUX
13 |
14 | include $(BUILD_SHARED_LIBRARY)
15 |
--------------------------------------------------------------------------------
/luajava/src/main/jni/luajava/log.h:
--------------------------------------------------------------------------------
1 | //
2 | // Created by leon on 16/3/10.
3 | //
4 |
5 | #ifndef LUA_LOG_H
6 | #define LUA_LOG_H
7 |
8 | #include
9 |
10 | #define LOG_LEVEL 10
11 | #define LOG_TAG "LUA-JNI"
12 |
13 | #define LOGI(level, ...) if (level <= LOG_LEVEL) {__android_log_print(ANDROID_LOG_INFO, LOG_TAG, __VA_ARGS__);}
14 | #define LOGE(level, ...) if (level <= LOG_LEVEL + 10) {__android_log_print(ANDROID_LOG_ERROR, LOG_TAG, __VA_ARGS__);}
15 | #define LOGW(level, ...) if (level <= LOG_LEVEL + 5) {__android_log_print(ANDROID_LOG_WARN, LOG_TAG, __VA_ARGS__);}
16 |
17 | #endif //LUA_LOG_H
18 |
--------------------------------------------------------------------------------
/luajava/src/main/jniLibs/arm64-v8a/libluajava.so:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/haodynasty/AndroidLuaExample/f51699da7c2a07e8c7ddc4ebb3fd29a5cccf0f45/luajava/src/main/jniLibs/arm64-v8a/libluajava.so
--------------------------------------------------------------------------------
/luajava/src/main/jniLibs/armeabi-v7a/libluajava.so:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/haodynasty/AndroidLuaExample/f51699da7c2a07e8c7ddc4ebb3fd29a5cccf0f45/luajava/src/main/jniLibs/armeabi-v7a/libluajava.so
--------------------------------------------------------------------------------
/luajava/src/main/jniLibs/armeabi/libluajava.so:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/haodynasty/AndroidLuaExample/f51699da7c2a07e8c7ddc4ebb3fd29a5cccf0f45/luajava/src/main/jniLibs/armeabi/libluajava.so
--------------------------------------------------------------------------------
/luajava/src/main/jniLibs/mips/libluajava.so:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/haodynasty/AndroidLuaExample/f51699da7c2a07e8c7ddc4ebb3fd29a5cccf0f45/luajava/src/main/jniLibs/mips/libluajava.so
--------------------------------------------------------------------------------
/luajava/src/main/jniLibs/mips64/libluajava.so:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/haodynasty/AndroidLuaExample/f51699da7c2a07e8c7ddc4ebb3fd29a5cccf0f45/luajava/src/main/jniLibs/mips64/libluajava.so
--------------------------------------------------------------------------------
/luajava/src/main/jniLibs/x86/libluajava.so:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/haodynasty/AndroidLuaExample/f51699da7c2a07e8c7ddc4ebb3fd29a5cccf0f45/luajava/src/main/jniLibs/x86/libluajava.so
--------------------------------------------------------------------------------
/luajava/src/main/jniLibs/x86_64/libluajava.so:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/haodynasty/AndroidLuaExample/f51699da7c2a07e8c7ddc4ebb3fd29a5cccf0f45/luajava/src/main/jniLibs/x86_64/libluajava.so
--------------------------------------------------------------------------------
/luajava/src/main/res/values/strings.xml:
--------------------------------------------------------------------------------
1 |
2 | luajava
3 |
4 |
--------------------------------------------------------------------------------
/luajava/src/test/java/org/keplerproject/luajava/ExampleUnitTest.java:
--------------------------------------------------------------------------------
1 | package org.keplerproject.luajava;
2 |
3 | import org.junit.Test;
4 |
5 | import static org.junit.Assert.*;
6 |
7 | /**
8 | * Example local unit test, which will execute on the development machine (host).
9 | *
10 | * @see Testing documentation
11 | */
12 | public class ExampleUnitTest {
13 | @Test
14 | public void addition_isCorrect() throws Exception {
15 | assertEquals(4, 2 + 2);
16 | }
17 | }
--------------------------------------------------------------------------------
/old/AndroLua.jar:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/haodynasty/AndroidLuaExample/f51699da7c2a07e8c7ddc4ebb3fd29a5cccf0f45/old/AndroLua.jar
--------------------------------------------------------------------------------
/old/armeabi/libluajava.so:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/haodynasty/AndroidLuaExample/f51699da7c2a07e8c7ddc4ebb3fd29a5cccf0f45/old/armeabi/libluajava.so
--------------------------------------------------------------------------------
/settings.gradle:
--------------------------------------------------------------------------------
1 | include ':app',':luajava'
2 |
--------------------------------------------------------------------------------