mirror of
https://github.com/adelphes/android-dev-ext.git
synced 2025-12-23 01:48:18 +00:00
Compare commits
45 Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
f92f247ef6 | ||
|
|
133b7061b2 | ||
|
|
7e958620a8 | ||
|
|
989de8254a | ||
|
|
8f2f7d2fd4 | ||
|
|
99544b527d | ||
|
|
614fcbd2ba | ||
|
|
b04e4328a6 | ||
|
|
1a00cdb291 | ||
|
d1fd889433 | ||
|
|
a7e4cac6df | ||
|
|
c6df24ab95 | ||
|
|
23184ea4c2 | ||
|
b7ba47b811 | ||
|
|
033f5c80ab | ||
|
|
0cbb56ca9b | ||
|
|
684dd39181 | ||
|
52ab704acd | ||
|
|
45e2dc2fe1 | ||
|
|
30ed5dea3b | ||
|
|
0eb44130a6 | ||
|
|
d1e7c86092 | ||
|
|
690f9dc23a | ||
|
|
27ecd41b68 | ||
|
|
756a1cea29 | ||
|
|
fc2ce97a23 | ||
|
|
de8abc62bc | ||
|
|
8cc31476b3 | ||
|
|
494bb83cbf | ||
|
|
9fca5cbe8c | ||
|
|
5f0a02b17f | ||
|
|
da36e8e457 | ||
|
|
3dbfd8ef2a | ||
|
|
4a31b83eb9 | ||
|
|
261c06f1d6 | ||
|
|
130d79f6c2 | ||
|
|
8baf894fc9 | ||
|
|
92bd003122 | ||
|
|
13f116b3b3 | ||
|
|
140e48cbd1 | ||
|
|
7e8f471df4 | ||
|
|
09905eb85a | ||
|
|
e76773e8e4 | ||
|
|
c98c962172 | ||
|
|
b3501d529a |
47
CHANGELOG.md
47
CHANGELOG.md
@@ -1,5 +1,50 @@
|
||||
# Change Log
|
||||
|
||||
### version 0.8.0
|
||||
* Try to extract Android manifest directly from APK
|
||||
* Added `manifestFile` launch configuration property
|
||||
* Allow `pm install` arguments to be customised as a launch configuration property
|
||||
* Document `launchActivity` launch configuration property
|
||||
* Fix critical security advisory https://www.npmjs.com/advisories/1118
|
||||
|
||||
### version 0.7.1
|
||||
* Added the [Buy Me A Coffee](https://www.buymeacoffee.com/adelphes) link to the README
|
||||
|
||||
### version 0.7.0
|
||||
* Fix logcat not displaying
|
||||
* Fix breakpoints not triggering on Windows
|
||||
* Added kotlin folder to list of known source locations
|
||||
* Upgraded dependencies to resolve a number of security vulnerabilites
|
||||
* Updated README with info about prelaunch build task
|
||||
* Added MIT license file
|
||||
|
||||
### version 0.6.2
|
||||
* Fix broken logcat command due to missing dependency
|
||||
|
||||
### version 0.6.1
|
||||
* Regenerate package-lock.json to remove event-stream vulnerability - https://github.com/dominictarr/event-stream/issues/116
|
||||
|
||||
### version 0.6.0
|
||||
* Fix issue with breakpoints not enabling correctly
|
||||
* Fix issue with JDWP failure on breakpoint hit
|
||||
* Added support for diagnostic logs using trace configuration option
|
||||
* Updated default apkFile path to match current releases of Android Studio
|
||||
* Updated package dependencies
|
||||
|
||||
### version 0.5.0
|
||||
* Debugger support for Kotlin source files
|
||||
* Exception UI
|
||||
* Fixed some console display issues
|
||||
|
||||
### version 0.4.1
|
||||
* One day I will learn to update the changelog **before** I hit publish
|
||||
* Updated changelog
|
||||
|
||||
### version 0.4.0
|
||||
* Debugger performance improvements
|
||||
* Fixed exception details not being displayed in locals
|
||||
* Fixed some logcat display issues
|
||||
|
||||
### version 0.3.1
|
||||
* Bug fixes
|
||||
* Fix issue with exception breaks crashing debugger
|
||||
@@ -29,4 +74,4 @@ Initial release
|
||||
* Simple watch expressions
|
||||
* Breakpoints
|
||||
* Large array chunking (performance)
|
||||
* Stale build detection
|
||||
* Stale build detection
|
||||
|
||||
21
LICENSE
Normal file
21
LICENSE
Normal file
@@ -0,0 +1,21 @@
|
||||
MIT License
|
||||
|
||||
Copyright (c) 2017 Dave Holoway
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
of this software and associated documentation files (the "Software"), to deal
|
||||
in the Software without restriction, including without limitation the rights
|
||||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
copies of the Software, and to permit persons to whom the Software is
|
||||
furnished to do so, subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in all
|
||||
copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
SOFTWARE.
|
||||
60
README.md
60
README.md
@@ -20,7 +20,7 @@ You must have [Android SDK Platform Tools](https://developer.android.com/studio/
|
||||
* This is a preview version so expect the unexpected. Please log any issues you find on [GitHub](https://github.com/adelphes/android-dev-ext/issues).
|
||||
* This extension **will not build your app**.
|
||||
If you use gradle (or Android Studio), you can build your app from the command-line using `./gradlew assembleDebug`.
|
||||
> You must use gradle or some other build procedure to create your APK. Once built, the extension can deploy and launch your app, allowing you to debug it in the normal way.
|
||||
> You must use gradle or some other build procedure to create your APK. Once built, the extension can deploy and launch your app, allowing you to debug it in the normal way. See the section below on how to configure a VSCode task to automatically build your app before launching a debug session.
|
||||
* Some debugger options are yet to be implemented. You cannot set conditional breakpoints and watch expressions must be simple variables.
|
||||
* If you require a must-have feature that isn't there yet, let us know on [GitHub](https://github.com/adelphes/android-dev-ext/issues).
|
||||
* This extension does not provide any additional code completion or other editing enhancements.
|
||||
@@ -29,7 +29,7 @@ If you use gradle (or Android Studio), you can build your app from the command-l
|
||||
|
||||
This extension allows you to debug your App by creating a new Android configuration in `launch.json`.
|
||||
The following settings are used to configure the debugger:
|
||||
|
||||
```jsonc
|
||||
{
|
||||
"version": "0.2.0",
|
||||
"configurations": [
|
||||
@@ -50,9 +50,65 @@ The following settings are used to configure the debugger:
|
||||
|
||||
// Launch behaviour if source files have been saved after the APK was built. One of: [ ignore warn stop ]. Default: warn
|
||||
"staleBuild": "warn",
|
||||
|
||||
// Fully qualified path to the AndroidManifest.xml file compiled in the APK. Default: appSrcRoot/AndroidManifest.xml
|
||||
"manifestFile": "${workspaceRoot}/app/src/main/AndroidManifest.xml",
|
||||
|
||||
// APK install arguments passed to the Android package manager. Run 'adb shell pm' to show valid arguments. Default: ["-r"]
|
||||
"pmInstallArgs": ["-r"],
|
||||
|
||||
// Manually specify the activity to run when the app is started.
|
||||
"launchActivity": ".MainActivity"
|
||||
}
|
||||
]
|
||||
}
|
||||
```
|
||||
|
||||
## Building your app automatically
|
||||
|
||||
This extension will not build your App. If you would like to run a build each time a debug session is started, you can add a `preLaunchTask` option to your `launch.json` configuration which invokes a build task.
|
||||
|
||||
#### .vscode/launch.json
|
||||
Add a `preLaunchTask` item to the launch configuration:
|
||||
```json
|
||||
{
|
||||
"version": "0.2.0",
|
||||
"configurations": [
|
||||
{
|
||||
"type": "android",
|
||||
"request": "launch",
|
||||
"name": "App Build & Launch",
|
||||
"preLaunchTask": "run gradle",
|
||||
}
|
||||
]
|
||||
}
|
||||
```
|
||||
Add a new task to run the build command:
|
||||
#### .vscode/tasks.json
|
||||
```json
|
||||
{
|
||||
"version": "2.0.0",
|
||||
"tasks": [
|
||||
{
|
||||
"label": "run gradle",
|
||||
"type": "shell",
|
||||
"command": "${workspaceFolder}/gradlew",
|
||||
"args": ["assembleDebug"]
|
||||
}
|
||||
]
|
||||
}
|
||||
```
|
||||
|
||||
## Powered by coffee
|
||||
|
||||
The Android Developer Extension is a completely free, fully open-source project. If you've found the extension useful, you
|
||||
can support it by [buying me a coffee](https://www.buymeacoffee.com/adelphes).
|
||||
|
||||
If you use ApplePay or Google Pay, you can scan the code with your phone camera:
|
||||
|
||||
|
||||
|
||||
Every coffee makes a difference, so thanks for adding your support.
|
||||
|
||||
## Questions / Problems
|
||||
|
||||
|
||||
@@ -3,6 +3,7 @@
|
||||
const vscode = require('vscode');
|
||||
const { AndroidContentProvider } = require('./src/contentprovider');
|
||||
const { openLogcatWindow } = require('./src/logcat');
|
||||
const state = require('./src/state');
|
||||
|
||||
function getADBPort() {
|
||||
var defaultPort = 5037;
|
||||
@@ -38,6 +39,7 @@ function activate(context) {
|
||||
var spliceparams = [context.subscriptions.length,0].concat(disposables);
|
||||
Array.prototype.splice.apply(context.subscriptions,spliceparams);
|
||||
}
|
||||
|
||||
exports.activate = activate;
|
||||
|
||||
// this method is called when your extension is deactivated
|
||||
|
||||
BIN
images/bmac-code.png
Normal file
BIN
images/bmac-code.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 1.6 KiB |
2753
package-lock.json
generated
Normal file
2753
package-lock.json
generated
Normal file
File diff suppressed because it is too large
Load Diff
65
package.json
65
package.json
@@ -2,7 +2,7 @@
|
||||
"name": "android-dev-ext",
|
||||
"displayName": "Android",
|
||||
"description": "Android debugging support for VS Code",
|
||||
"version": "0.4.0",
|
||||
"version": "0.8.0",
|
||||
"publisher": "adelphes",
|
||||
"preview": true,
|
||||
"license": "MIT",
|
||||
@@ -35,12 +35,15 @@
|
||||
"breakpoints": [
|
||||
{
|
||||
"language": "java"
|
||||
},
|
||||
{
|
||||
"language": "kotlin"
|
||||
}
|
||||
],
|
||||
"debuggers": [
|
||||
{
|
||||
"type": "android",
|
||||
"label": "Android Debug",
|
||||
"label": "Android",
|
||||
"program": "./src/debugMain.js",
|
||||
"runtime": "node",
|
||||
"configurationAttributes": {
|
||||
@@ -59,7 +62,7 @@
|
||||
"apkFile": {
|
||||
"type": "string",
|
||||
"description": "Fully qualified path to the built APK (Android Application Package)",
|
||||
"default": "${workspaceRoot}/app/build/outputs/apk/app-debug.apk"
|
||||
"default": "${workspaceRoot}/app/build/outputs/apk/debug/app-debug.apk"
|
||||
},
|
||||
"adbPort": {
|
||||
"type": "integer",
|
||||
@@ -76,11 +79,28 @@
|
||||
"description": "Number of entries to display in call stack views (for locations outside of the project source). 0 shows the entire call stack. Default: 1",
|
||||
"default": 1
|
||||
},
|
||||
"launchActivity": {
|
||||
"type": "string",
|
||||
"description": "Manually specify the activity to run when the app is started.",
|
||||
"default": ""
|
||||
},
|
||||
"logcatPort": {
|
||||
"type": "integer",
|
||||
"description": "Port number to use for the internal logcat websocket link. Changes to this value only apply when the extension is restarted. Default: 7038",
|
||||
"default": 7038
|
||||
},
|
||||
"manifestFile": {
|
||||
"type": "string",
|
||||
"description": "Overrides the default location of AndroidManifest.xml",
|
||||
"default": "${workspaceRoot}/app/src/main/AndroidManifest.xml"
|
||||
},
|
||||
"pmInstallArgs": {
|
||||
"type": "array",
|
||||
"description": "APK install arguments passed to the Android package manager. Run 'adb shell pm' to show valid arguments. Default: [\"-r\"]",
|
||||
"default": [
|
||||
"-r"
|
||||
]
|
||||
},
|
||||
"staleBuild": {
|
||||
"type": "string",
|
||||
"description": "Launch behaviour if source files have been saved after the APK was built. One of: [\"ignore\" \"warn\" \"stop\"]. Default: \"warn\"",
|
||||
@@ -90,6 +110,11 @@
|
||||
"type": "string",
|
||||
"description": "Target Device ID (as indicated by 'adb devices'). Use this to specify which device is used for deployment when multiple devices are connected.",
|
||||
"default": ""
|
||||
},
|
||||
"trace": {
|
||||
"type": "boolean",
|
||||
"description": "Set to true to output debugging logs for diagnostics",
|
||||
"default": false
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -97,10 +122,10 @@
|
||||
"initialConfigurations": [
|
||||
{
|
||||
"type": "android",
|
||||
"name": "Android Debug",
|
||||
"name": "Android",
|
||||
"request": "launch",
|
||||
"appSrcRoot": "${workspaceRoot}/app/src/main",
|
||||
"apkFile": "${workspaceRoot}/app/build/outputs/apk/app-debug.apk",
|
||||
"apkFile": "${workspaceRoot}/app/build/outputs/apk/debug/app-debug.apk",
|
||||
"adbPort": 5037
|
||||
}
|
||||
],
|
||||
@@ -113,7 +138,7 @@
|
||||
"request": "launch",
|
||||
"name": "${2:Launch App}",
|
||||
"appSrcRoot": "^\"\\${workspaceRoot}/app/src/main\"",
|
||||
"apkFile": "^\"\\${workspaceRoot}/app/build/outputs/apk/app-debug.apk\"",
|
||||
"apkFile": "^\"\\${workspaceRoot}/app/build/outputs/apk/debug/app-debug.apk\"",
|
||||
"adbPort": 5037
|
||||
}
|
||||
}
|
||||
@@ -123,23 +148,25 @@
|
||||
]
|
||||
},
|
||||
"scripts": {
|
||||
"postinstall": "node ./node_modules/vscode/bin/install",
|
||||
"prepare": "node ./node_modules/vscode/bin/install",
|
||||
"test": "node ./node_modules/vscode/bin/test"
|
||||
},
|
||||
"dependencies": {
|
||||
"vscode-debugprotocol": "^1.15.0",
|
||||
"vscode-debugadapter": "^1.15.0",
|
||||
"long": "^3.2.0",
|
||||
"ws": "^1.1.1",
|
||||
"long": "^4.0.0",
|
||||
"unzipper": "^0.10.4",
|
||||
"uuid": "^3.3.2",
|
||||
"vscode-debugadapter": "^1.32.0",
|
||||
"vscode-debugprotocol": "^1.32.0",
|
||||
"ws": "^7.1.2",
|
||||
"xmldom": "^0.1.27",
|
||||
"xpath": "^0.0.23"
|
||||
"xpath": "^0.0.27"
|
||||
},
|
||||
"devDependencies": {
|
||||
"typescript": "^2.0.3",
|
||||
"vscode": "^1.0.0",
|
||||
"mocha": "^2.3.3",
|
||||
"eslint": "^3.6.0",
|
||||
"@types/node": "^6.0.40",
|
||||
"@types/mocha": "^2.2.32"
|
||||
"@types/mocha": "^5.2.5",
|
||||
"@types/node": "^10.12.5",
|
||||
"eslint": "^5.9.0",
|
||||
"mocha": "^5.2.0",
|
||||
"typescript": "^3.1.6",
|
||||
"vscode": "^1.1.26"
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
281
src/apkdecoder.js
Normal file
281
src/apkdecoder.js
Normal file
@@ -0,0 +1,281 @@
|
||||
const START_NAMESPACE_SPEC = {
|
||||
hdr: '0x0100',
|
||||
hdrsz: '0x0010',
|
||||
sz: '0x00000018',
|
||||
startline: 4,
|
||||
commentId: 4,
|
||||
nameId: 4,
|
||||
valueId: 4,
|
||||
}
|
||||
const END_NAMESPACE_SPEC = {
|
||||
hdr: '0x0101',
|
||||
hdrsz: '0x0010',
|
||||
sz: '0x00000018',
|
||||
startline: 4,
|
||||
commentId: 4,
|
||||
nameId: 4,
|
||||
valueId: 4,
|
||||
}
|
||||
const BEGIN_NODE_SPEC = {
|
||||
hdr: '0x0102',
|
||||
hdrsz: '0x0010',
|
||||
sz: 4,
|
||||
startline: 4,
|
||||
commentId: 4,
|
||||
namespaceId: 4,
|
||||
nameId: 4,
|
||||
attr: {
|
||||
offset: 2,
|
||||
size: 2,
|
||||
count: 2,
|
||||
},
|
||||
id_attr_offset: 2,
|
||||
cls_attr_offset: 2,
|
||||
style_attr_offset: 2,
|
||||
attributes: [{
|
||||
length: main => main.attr.count,
|
||||
element_spec: {
|
||||
ns: 4,
|
||||
nameId: 4,
|
||||
commentId: 4,
|
||||
sz: '0x0008',
|
||||
zero: '0x00',
|
||||
type: 1,
|
||||
value: 4,
|
||||
}
|
||||
}]
|
||||
}
|
||||
|
||||
const END_NODE_SPEC = {
|
||||
hdr: '0x0103',
|
||||
hdrsz: '0x0010',
|
||||
sz: 4,
|
||||
startline: 4,
|
||||
commentId: 4,
|
||||
namespaceId: 4,
|
||||
nameId: 4,
|
||||
}
|
||||
|
||||
function decode_spec_value(o, key, value, buf, idx, main) {
|
||||
let byteLength;
|
||||
switch (true) {
|
||||
case typeof value === 'number': {
|
||||
// raw integer value
|
||||
byteLength = value;
|
||||
o[key] = buf.readIntLE(idx, byteLength);
|
||||
break;
|
||||
}
|
||||
case Array.isArray(value): {
|
||||
// known-length array of values
|
||||
const length = value[0].length(main);
|
||||
byteLength = 0;
|
||||
o[key] = new Array(length);
|
||||
for (let i = 0; i < length; i++) {
|
||||
const bytes = decode_spec_value(o[key], i, value[0].element_spec, buf, idx, main);
|
||||
idx += bytes;
|
||||
byteLength += bytes;
|
||||
}
|
||||
break;
|
||||
}
|
||||
case typeof value === 'object': {
|
||||
// named sub-spec
|
||||
o[key] = {};
|
||||
byteLength = decode_spec(buf, value, o[key], o, idx);
|
||||
break
|
||||
}
|
||||
case /^0x[\da-fA-F]/.test(value): {
|
||||
// exact integer value
|
||||
byteLength = (value.length - 2) / 2;
|
||||
o[key] = buf.readUIntLE(idx, byteLength);
|
||||
if (parseInt(value) !== o[key]) {
|
||||
throw new Error(`Bad value. Expected ${value}, got 0x${o[key].toString(16)}`);
|
||||
}
|
||||
break;
|
||||
}
|
||||
case value === 'length-utf16-null': {
|
||||
// 2-byte length, utf16 chars, null char
|
||||
const string_byte_length = buf.readUInt16LE(idx) * 2; // 1 char = 2 bytes
|
||||
idx += 2;
|
||||
o[key] = buf.slice(idx, idx + string_byte_length).toString('ucs2');
|
||||
idx += string_byte_length;
|
||||
if (buf.readUInt16LE(idx) !== 0) {
|
||||
throw new Error(`Bad value. Nul char expected but not found.`);
|
||||
}
|
||||
byteLength = 2 + string_byte_length + 2;
|
||||
break;
|
||||
}
|
||||
case /^align:\d+$/.test(value): {
|
||||
// used for arbitrary padding to a specified alignment
|
||||
const align = parseInt(value.split(':')[1], 10);
|
||||
byteLength = align - (idx % align);
|
||||
o[key] = buf.slice(idx, idx + byteLength);
|
||||
break;
|
||||
}
|
||||
default: throw new Error(`Unknown spec value definition: ${value}`);
|
||||
}
|
||||
return byteLength;
|
||||
}
|
||||
|
||||
function decode_spec(buf, spec, o = {}, main = o, idx = 0) {
|
||||
|
||||
let byteLength = 0;
|
||||
for (let key of Object.keys(spec)) {
|
||||
const value = spec[key];
|
||||
const bytes = decode_spec_value(o, key, value, buf, idx, main);
|
||||
idx += bytes;
|
||||
byteLength += bytes;
|
||||
}
|
||||
|
||||
return byteLength;
|
||||
}
|
||||
|
||||
/**
|
||||
* Converts a binary XML file back into a readable XML document
|
||||
* @param {Buffer} buf binary XMl content
|
||||
*/
|
||||
function decode_binary_xml(buf) {
|
||||
const xml_spec = {
|
||||
header: '0x00080003',
|
||||
headerSize: 4,
|
||||
stringPool: {
|
||||
header: '0x0001',
|
||||
hdrsize: '0x001c',
|
||||
sz: 4,
|
||||
stringCount: 4,
|
||||
styleCount: 4,
|
||||
flags: 4,
|
||||
stringStart: 4,
|
||||
styleStart: 4,
|
||||
stringOffsets: [{
|
||||
length: main => main.stringPool.stringCount,
|
||||
element_spec: 4,
|
||||
}],
|
||||
strings: [{
|
||||
length: main => main.stringPool.stringCount,
|
||||
element_spec: 'length-utf16-null',
|
||||
}],
|
||||
padding: 'align:4',
|
||||
},
|
||||
resourceIDPool: {
|
||||
hdr: '0x0180',
|
||||
hdrsize: '0x0008',
|
||||
sz: 4,
|
||||
resIDs: [{
|
||||
length: main => (main.resourceIDPool.sz - main.resourceIDPool.hdrsize) / 4,
|
||||
element_spec: 4,
|
||||
}]
|
||||
}
|
||||
}
|
||||
|
||||
const decoded = {};
|
||||
let idx = decode_spec(buf, xml_spec, decoded);
|
||||
|
||||
// after we've extracted the string and id's, it should be time to parse the xml
|
||||
const node_stack = [{ nodes: [] }];
|
||||
const namespaces = [];
|
||||
while (idx < buf.byteLength) {
|
||||
const id = buf.readUInt16LE(idx);
|
||||
switch (id) {
|
||||
case 0x0100: {
|
||||
// start namespace
|
||||
const node = {};
|
||||
idx += decode_spec(buf, START_NAMESPACE_SPEC, node, node, idx);
|
||||
namespaces.push(node);
|
||||
break;
|
||||
}
|
||||
case 0x0101: {
|
||||
// end namespace
|
||||
const node = {};
|
||||
idx += decode_spec(buf, END_NAMESPACE_SPEC, node, node, idx);
|
||||
const i = namespaces.findIndex(ns => ns.nameId === node.nameId);
|
||||
namespaces.splice(i, 1);
|
||||
break;
|
||||
}
|
||||
case 0x0102: {
|
||||
// begin node
|
||||
const node = {};
|
||||
idx += decode_spec(buf, BEGIN_NODE_SPEC, node, node, idx);
|
||||
node.namespaces = namespaces.slice();
|
||||
node.namespaces.forEach(ns => {
|
||||
if (!ns.node) ns.node = node;
|
||||
});
|
||||
node.nodes = [];
|
||||
node_stack[0].nodes.push(node);
|
||||
node_stack.unshift(node);
|
||||
break;
|
||||
}
|
||||
case 0x0103: {
|
||||
// end node
|
||||
const spec = END_NODE_SPEC;
|
||||
const node = {};
|
||||
idx += decode_spec(buf, spec, node, node, idx);
|
||||
node_stack.shift();
|
||||
break;
|
||||
}
|
||||
default: throw new Error(`Unknown XML element ${id.toString(16)}`);
|
||||
}
|
||||
}
|
||||
decoded.nodes = node_stack[0].nodes;
|
||||
|
||||
const xml = toXMLDocument(decoded);
|
||||
return xml;
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert the decoded binary XML to a readable XML document
|
||||
* @param {*} decoded
|
||||
*/
|
||||
function toXMLDocument(decoded) {
|
||||
const strings = decoded.stringPool.strings;
|
||||
const format = {
|
||||
nodes: (nodes, indent) => {
|
||||
return nodes.map(node => format.node(node, indent)).join('\n');
|
||||
},
|
||||
node: (node, indent) => {
|
||||
const parts = [indent, '<', strings[node.nameId]];
|
||||
for (let ns of node.namespaces.filter(ns => ns.node === node)) {
|
||||
parts.push(' ', `xmlns:${strings[ns.nameId]}="${strings[ns.valueId]}"`);
|
||||
}
|
||||
const attr_indent = node.attributes.length > 1 ? `\n${indent} ` : ' ';
|
||||
for (let attr of node.attributes) {
|
||||
parts.push(attr_indent, format.attribute(attr, node.namespaces));
|
||||
}
|
||||
if (node.nodes.length) {
|
||||
parts.push('>\n', format.nodes(node.nodes, indent + ' '), '\n', indent, '</', strings[node.nameId], '>');
|
||||
} else {
|
||||
parts.push(' />');
|
||||
}
|
||||
|
||||
return parts.join('');
|
||||
},
|
||||
attribute: (attr, namespaces) => {
|
||||
let value = attr.value;
|
||||
switch (attr.type) {
|
||||
case 3:
|
||||
value = strings[value];
|
||||
break;
|
||||
case 16:
|
||||
value |= 0; // convert to signed integer
|
||||
break;
|
||||
case 18:
|
||||
value = value ? true : false;
|
||||
break;
|
||||
case 1: // resource id
|
||||
case 17: // flags
|
||||
default:
|
||||
value = '0x' + value.toString(`16`);
|
||||
break;
|
||||
}
|
||||
let ns = '';
|
||||
if (attr.ns >= 0) {
|
||||
ns = `${strings[namespaces.find(ns => ns.valueId === attr.ns).nameId]}:`;
|
||||
}
|
||||
return `${ns}${strings[attr.nameId]}="${value}"`;
|
||||
}
|
||||
}
|
||||
return '<?xml version="1.0" encoding="utf-8"?>\n' + format.nodes(decoded.nodes, '');
|
||||
}
|
||||
|
||||
module.exports = {
|
||||
decode_binary_xml,
|
||||
}
|
||||
@@ -44,7 +44,7 @@ class AndroidContentProvider /*extends TextDocumentContentProvider*/ {
|
||||
provideLogcatDocumentContent(uri) {
|
||||
// LogcatContent depends upon AndroidContentProvider, so we must delay-load this
|
||||
const { LogcatContent } = require('./logcat');
|
||||
var doc = this._docs[uri] = new LogcatContent(this, uri);
|
||||
var doc = this._docs[uri] = new LogcatContent(uri.query);
|
||||
return doc.content;
|
||||
}
|
||||
}
|
||||
|
||||
743
src/debugMain.js
743
src/debugMain.js
File diff suppressed because it is too large
Load Diff
@@ -525,7 +525,7 @@ Debugger.prototype = {
|
||||
},
|
||||
|
||||
_splitsrcfpn: function (srcfpn) {
|
||||
var m = srcfpn.match(/^\/([^/]+(?:\/[^/]+)*)?\/([^./]+)\.java$/);
|
||||
var m = srcfpn.match(/^\/([^/]+(?:\/[^/]+)*)?\/([^./]+)\.(java|kt)$/);
|
||||
return {
|
||||
pkg: m[1].replace(/\/+/g, '.'),
|
||||
type: m[2],
|
||||
@@ -1054,6 +1054,50 @@ Debugger.prototype = {
|
||||
return this.invokeMethod(objectid, threadid, type_signature || 'Ljava/lang/Object;', 'toString', '()Ljava/lang/String;', [], extra);
|
||||
},
|
||||
|
||||
findNamedMethods(type_signature, name, method_signature) {
|
||||
var x = { type_signature, name, method_signature }
|
||||
const ismatch = function(x, y) {
|
||||
if (!x || (x === y)) return true;
|
||||
return (x instanceof RegExp) && x.test(y);
|
||||
}
|
||||
return this.gettypedebuginfo(x.type_signature)
|
||||
.then(dbgtype => this._ensuremethods(dbgtype[x.type_signature]))
|
||||
.then(typeinfo => ({
|
||||
// resolving the methods only resolves the non-inherited methods
|
||||
// if we can't find a matching method, we need to search the super types
|
||||
dbgr: this,
|
||||
def: $.Deferred(),
|
||||
matches:[],
|
||||
find_methods(typeinfo) {
|
||||
for (var mid in typeinfo.methods) {
|
||||
var m = typeinfo.methods[mid];
|
||||
// does the name match
|
||||
if (!ismatch(x.name, m.name)) continue;
|
||||
// does the signature match
|
||||
if (!ismatch(x.method_signature, m.genericsig || m.sig)) continue;
|
||||
// add it to the results
|
||||
this.matches.push(m);
|
||||
}
|
||||
// search the supertype
|
||||
if (typeinfo.type.signature === 'Ljava/lang/Object;') {
|
||||
this.def.resolveWith(this.dbgr, [this.matches]);
|
||||
return this;
|
||||
}
|
||||
this.dbgr._ensuresuper(typeinfo)
|
||||
.then(typeinfo => {
|
||||
return this.dbgr.gettypedebuginfo(typeinfo.super.signature, typeinfo.super.signature)
|
||||
})
|
||||
.then((dbgtype, sig) => {
|
||||
return this.dbgr._ensuremethods(dbgtype[sig])
|
||||
})
|
||||
.then(typeinfo => {
|
||||
this.find_methods(typeinfo)
|
||||
});
|
||||
return this;
|
||||
}
|
||||
}).find_methods(typeinfo).def)
|
||||
},
|
||||
|
||||
getstringchars: function (stringref, extra) {
|
||||
return this.session.adbclient.jdwp_command({
|
||||
ths: this,
|
||||
@@ -1269,8 +1313,10 @@ Debugger.prototype = {
|
||||
return $.Deferred().resolveWith(this, [typeinfo]);
|
||||
}
|
||||
if (typeinfo.info.reftype.string !== 'class' || typeinfo.type.signature[0] !== 'L' || typeinfo.type.signature === 'Ljava/lang/Object;') {
|
||||
typeinfo.super = null;
|
||||
return $.Deferred().resolveWith(this, [typeinfo]);
|
||||
if (typeinfo.info.reftype.string !== 'array') {
|
||||
typeinfo.super = null;
|
||||
return $.Deferred().resolveWith(this, [typeinfo]);
|
||||
}
|
||||
}
|
||||
|
||||
typeinfo.super = $.Deferred();
|
||||
@@ -1379,6 +1425,15 @@ Debugger.prototype = {
|
||||
cmd: this.JDWP.Commands.lineTable(methodinfo.owningclass, methodinfo),
|
||||
})
|
||||
.then(function (linetable, methodinfo) {
|
||||
// if the request failed, just return a blank table
|
||||
if (linetable.errorcode) {
|
||||
linetable = {
|
||||
errorcode: linetable.errorcode,
|
||||
start: '00000000000000000000000000000000',
|
||||
end: '00000000000000000000000000000000',
|
||||
lines:[],
|
||||
}
|
||||
}
|
||||
// the linetable does not correlate code indexes with line numbers
|
||||
// - location searching relies on the table being ordered by code indexes
|
||||
linetable.lines.sort(function (a, b) {
|
||||
|
||||
535
src/expressions.js
Normal file
535
src/expressions.js
Normal file
@@ -0,0 +1,535 @@
|
||||
'use strict'
|
||||
const Long = require('long');
|
||||
const $ = require('./jq-promise');
|
||||
const { D } = require('./util');
|
||||
const { JTYPES, exmsg_var_name, decode_char, createJavaString } = require('./globals');
|
||||
|
||||
/*
|
||||
Asynchronously evaluate an expression
|
||||
*/
|
||||
exports.evaluate = function(expression, thread, locals, vars, dbgr) {
|
||||
D('evaluate: ' + expression);
|
||||
|
||||
const reject_evaluation = (msg) => $.Deferred().rejectWith(this, [new Error(msg)]);
|
||||
const resolve_evaluation = (value, variablesReference) => $.Deferred().resolveWith(this, [value, variablesReference]);
|
||||
|
||||
if (thread && !thread.paused)
|
||||
return reject_evaluation('not available');
|
||||
|
||||
// special case for evaluating exception messages
|
||||
// - this is called if the user tries to evaluate ':msg' from the locals
|
||||
if (expression === exmsg_var_name) {
|
||||
if (thread && thread.paused.last_exception && thread.paused.last_exception.cached) {
|
||||
var msglocal = thread.paused.last_exception.cached.find(v => v.name === exmsg_var_name);
|
||||
if (msglocal) {
|
||||
return resolve_evaluation(vars._local_to_variable(msglocal).value);
|
||||
}
|
||||
}
|
||||
return reject_evaluation('not available');
|
||||
}
|
||||
|
||||
const parse_array_or_fncall = function (e) {
|
||||
var arg, res = { arr: [], call: null };
|
||||
// pre-call array indexes
|
||||
while (e.expr[0] === '[') {
|
||||
e.expr = e.expr.slice(1).trim();
|
||||
if ((arg = parse_expression(e)) === null) return null;
|
||||
res.arr.push(arg);
|
||||
if (e.expr[0] !== ']') return null;
|
||||
e.expr = e.expr.slice(1).trim();
|
||||
}
|
||||
if (res.arr.length) return res;
|
||||
// method call
|
||||
if (e.expr[0] === '(') {
|
||||
res.call = []; e.expr = e.expr.slice(1).trim();
|
||||
if (e.expr[0] !== ')') {
|
||||
for (; ;) {
|
||||
if ((arg = parse_expression(e)) === null) return null;
|
||||
res.call.push(arg);
|
||||
if (e.expr[0] === ')') break;
|
||||
if (e.expr[0] !== ',') return null;
|
||||
e.expr = e.expr.slice(1).trim();
|
||||
}
|
||||
}
|
||||
e.expr = e.expr.slice(1).trim();
|
||||
// post-call array indexes
|
||||
while (e.expr[0] === '[') {
|
||||
e.expr = e.expr.slice(1).trim();
|
||||
if ((arg = parse_expression(e)) === null) return null;
|
||||
res.arr.push(arg);
|
||||
if (e.expr[0] !== ']') return null;
|
||||
e.expr = e.expr.slice(1).trim();
|
||||
}
|
||||
}
|
||||
return res;
|
||||
}
|
||||
const parse_expression_term = function (e) {
|
||||
if (e.expr[0] === '(') {
|
||||
e.expr = e.expr.slice(1).trim();
|
||||
var subexpr = { expr: e.expr };
|
||||
var res = parse_expression(subexpr);
|
||||
if (res) {
|
||||
if (subexpr.expr[0] !== ')') return null;
|
||||
e.expr = subexpr.expr.slice(1).trim();
|
||||
if (/^(int|long|byte|short|double|float|char|boolean)$/.test(res.root_term) && !res.members.length && !res.array_or_fncall.call && !res.array_or_fncall.arr.length) {
|
||||
// primitive typecast
|
||||
var castexpr = parse_expression_term(e);
|
||||
if (castexpr) castexpr.typecast = res.root_term;
|
||||
res = castexpr;
|
||||
}
|
||||
}
|
||||
return res;
|
||||
}
|
||||
var unop = e.expr.match(/^(?:(!\s?)+|(~\s?)+|(?:([+-]\s?)+(?![\d.])))/);
|
||||
if (unop) {
|
||||
var op = unop[0].replace(/\s/g, '');
|
||||
e.expr = e.expr.slice(unop[0].length).trim();
|
||||
var res = parse_expression_term(e);
|
||||
if (res) {
|
||||
for (var i = op.length - 1; i >= 0; --i)
|
||||
res = { operator: op[i], rhs: res };
|
||||
}
|
||||
return res;
|
||||
}
|
||||
var root_term = e.expr.match(/^(?:(true(?![\w$]))|(false(?![\w$]))|(null(?![\w$]))|([a-zA-Z_$][a-zA-Z0-9_$]*)|([+-]?0x[0-9a-fA-F]+[lL]?)|([+-]?0[0-7]+[lL]?)|([+-]?\d+\.\d+(?:[eE][+-]?\d+)?[fFdD]?)|([+-]?\d+[lL]?)|('[^\\']')|('\\[bfrntv0]')|('\\u[0-9a-fA-F]{4}')|("[^"]*"))/);
|
||||
if (!root_term) return null;
|
||||
var res = {
|
||||
root_term: root_term[0],
|
||||
root_term_type: ['boolean', 'boolean', 'null', 'ident', 'hexint', 'octint', 'decfloat', 'decint', 'char', 'echar', 'uchar', 'string'][[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12].find(x => root_term[x]) - 1],
|
||||
array_or_fncall: null,
|
||||
members: [],
|
||||
typecast: ''
|
||||
}
|
||||
e.expr = e.expr.slice(res.root_term.length).trim();
|
||||
if ((res.array_or_fncall = parse_array_or_fncall(e)) === null) return null;
|
||||
// the root term is not allowed to be a method call
|
||||
if (res.array_or_fncall.call) return null;
|
||||
while (e.expr[0] === '.') {
|
||||
// member expression
|
||||
e.expr = e.expr.slice(1).trim();
|
||||
var m, member_name = e.expr.match(/^:?[a-zA-Z_$][a-zA-Z0-9_$]*/); // allow : at start for :super and :msg
|
||||
if (!member_name) return null;
|
||||
res.members.push(m = { member: member_name[0], array_or_fncall: null })
|
||||
e.expr = e.expr.slice(m.member.length).trim();
|
||||
if ((m.array_or_fncall = parse_array_or_fncall(e)) === null) return null;
|
||||
}
|
||||
return res;
|
||||
}
|
||||
const prec = {
|
||||
'*': 1, '%': 1, '/': 1,
|
||||
'+': 2, '-': 2,
|
||||
'<<': 3, '>>': 3, '>>>': 3,
|
||||
'<': 4, '>': 4, '<=': 4, '>=': 4, 'instanceof': 4,
|
||||
'==': 5, '!=': 5,
|
||||
'&': 6, '^': 7, '|': 8, '&&': 9, '||': 10, '?': 11,
|
||||
}
|
||||
const parse_expression = function (e) {
|
||||
var res = parse_expression_term(e);
|
||||
|
||||
if (!e.currprec) e.currprec = [12];
|
||||
for (; ;) {
|
||||
var binary_operator = e.expr.match(/^([/%*&|^+-]=|<<=|>>>?=|[><!=]=|=|<<|>>>?|[><]|&&|\|\||[/%*&|^]|\+(?=[^+]|[+][\w\d.])|\-(?=[^-]|[-][\w\d.])|instanceof\b|\?)/);
|
||||
if (!binary_operator) break;
|
||||
var precdiff = (prec[binary_operator[0]] || 12) - e.currprec[0];
|
||||
if (precdiff > 0) {
|
||||
// bigger number -> lower precendence -> end of (sub)expression
|
||||
break;
|
||||
}
|
||||
if (precdiff === 0 && binary_operator[0] !== '?') {
|
||||
// equal precedence, ltr evaluation
|
||||
break;
|
||||
}
|
||||
// higher or equal precendence
|
||||
e.currprec.unshift(e.currprec[0] + precdiff);
|
||||
e.expr = e.expr.slice(binary_operator[0].length).trim();
|
||||
// current or higher precendence
|
||||
if (binary_operator[0] === '?') {
|
||||
res = { condition: res, operator: binary_operator[0], ternary_true: null, ternary_false: null };
|
||||
res.ternary_true = parse_expression(e);
|
||||
if (e.expr[0] === ':') {
|
||||
e.expr = e.expr.slice(1).trim();
|
||||
res.ternary_false = parse_expression(e);
|
||||
}
|
||||
} else {
|
||||
res = { lhs: res, operator: binary_operator[0], rhs: parse_expression(e) };
|
||||
}
|
||||
e.currprec.shift();
|
||||
}
|
||||
return res;
|
||||
}
|
||||
const hex_long = long => ('000000000000000' + long.toUnsigned().toString(16)).slice(-16);
|
||||
const evaluate_number = (n) => {
|
||||
n += '';
|
||||
var numtype, m = n.match(/^([+-]?)0([bBxX0-7])(.+)/), base = 10;
|
||||
if (m) {
|
||||
switch (m[2]) {
|
||||
case 'b': base = 2; n = m[1] + m[3]; break;
|
||||
case 'x': base = 16; n = m[1] + m[3]; break;
|
||||
default: base = 8; break;
|
||||
}
|
||||
}
|
||||
if (base !== 16 && /[fFdD]$/.test(n)) {
|
||||
numtype = /[fF]$/.test(n) ? 'float' : 'double';
|
||||
n = n.slice(0, -1);
|
||||
} else if (/[lL]$/.test(n)) {
|
||||
numtype = 'long'
|
||||
n = n.slice(0, -1);
|
||||
} else {
|
||||
numtype = /\./.test(n) ? 'double' : 'int';
|
||||
}
|
||||
if (numtype === 'long') n = hex_long(Long.fromString(n, false, base));
|
||||
else if (/^[fd]/.test(numtype)) n = (base === 10) ? parseFloat(n) : parseInt(n, base);
|
||||
else n = parseInt(n, base) | 0;
|
||||
|
||||
const iszero = /^[+-]?0+(\.0*)?$/.test(n);
|
||||
return { vtype: 'literal', name: '', hasnullvalue: iszero, type: JTYPES[numtype], value: n, valid: true };
|
||||
}
|
||||
const evaluate_char = (char) => {
|
||||
return { vtype: 'literal', name: '', char: char, hasnullvalue: false, type: JTYPES.char, value: char.charCodeAt(0), valid: true };
|
||||
}
|
||||
const numberify = (local) => {
|
||||
//if (local.type.signature==='C') return local.char.charCodeAt(0);
|
||||
if (/^[FD]$/.test(local.type.signature))
|
||||
return parseFloat(local.value);
|
||||
if (local.type.signature === 'J')
|
||||
return parseInt(local.value, 16);
|
||||
return parseInt(local.value, 10);
|
||||
}
|
||||
const stringify = (local) => {
|
||||
var s;
|
||||
if (JTYPES.isString(local.type)) s = local.string;
|
||||
else if (JTYPES.isChar(local.type)) s = local.char;
|
||||
else if (JTYPES.isPrimitive(local.type)) s = '' + local.value;
|
||||
else if (local.hasnullvalue) s = '(null)';
|
||||
if (typeof s === 'string')
|
||||
return $.Deferred().resolveWith(this, [s]);
|
||||
return dbgr.invokeToString(local.value, local.info.frame.threadid, local.type.signature)
|
||||
.then(s => s.string);
|
||||
}
|
||||
const evaluate_expression = (expr) => {
|
||||
var q = $.Deferred(), local;
|
||||
if (expr.operator) {
|
||||
const invalid_operator = (unary) => reject_evaluation(`Invalid ${unary ? 'type' : 'types'} for operator '${expr.operator}'`),
|
||||
divide_by_zero = () => reject_evaluation('ArithmeticException: divide by zero');
|
||||
var lhs_local;
|
||||
return !expr.lhs
|
||||
? // unary operator
|
||||
evaluate_expression(expr.rhs)
|
||||
.then(rhs_local => {
|
||||
if (expr.operator === '!' && JTYPES.isBoolean(rhs_local.type)) {
|
||||
rhs_local.value = !rhs_local.value;
|
||||
return rhs_local;
|
||||
}
|
||||
else if (expr.operator === '~' && JTYPES.isInteger(rhs_local.type)) {
|
||||
switch (rhs_local.type.typename) {
|
||||
case 'long': rhs_local.value = rhs_local.value.replace(/./g, c => (15 - parseInt(c, 16)).toString(16)); break;
|
||||
default: rhs_local = evaluate_number('' + ~rhs_local.value); break;
|
||||
}
|
||||
return rhs_local;
|
||||
}
|
||||
else if (/[+-]/.test(expr.operator) && JTYPES.isInteger(rhs_local.type)) {
|
||||
if (expr.operator === '+') return rhs_local;
|
||||
switch (rhs_local.type.typename) {
|
||||
case 'long': rhs_local.value = hex_long(Long.fromString(rhs_local.value, false, 16).neg()); break;
|
||||
default: rhs_local = evaluate_number('' + (-rhs_local.value)); break;
|
||||
}
|
||||
return rhs_local;
|
||||
}
|
||||
return invalid_operator('unary');
|
||||
})
|
||||
: // binary operator
|
||||
evaluate_expression(expr.lhs)
|
||||
.then(x => (lhs_local = x) && evaluate_expression(expr.rhs))
|
||||
.then(rhs_local => {
|
||||
if ((lhs_local.type.signature === 'J' && JTYPES.isInteger(rhs_local.type))
|
||||
|| (rhs_local.type.signature === 'J' && JTYPES.isInteger(lhs_local.type))) {
|
||||
// one operand is a long, the other is an integer -> the result is a long
|
||||
var a, b, lbase, rbase;
|
||||
lbase = lhs_local.type.signature === 'J' ? 16 : 10;
|
||||
rbase = rhs_local.type.signature === 'J' ? 16 : 10;
|
||||
a = Long.fromString('' + lhs_local.value, false, lbase);
|
||||
b = Long.fromString('' + rhs_local.value, false, rbase);
|
||||
switch (expr.operator) {
|
||||
case '+': a = a.add(b); break;
|
||||
case '-': a = a.subtract(b); break;
|
||||
case '*': a = a.multiply(b); break;
|
||||
case '/': if (!b.isZero()) { a = a.divide(b); break } return divide_by_zero();
|
||||
case '%': if (!b.isZero()) { a = a.mod(b); break; } return divide_by_zero();
|
||||
case '<<': a = a.shl(b); break;
|
||||
case '>>': a = a.shr(b); break;
|
||||
case '>>>': a = a.shru(b); break;
|
||||
case '&': a = a.and(b); break;
|
||||
case '|': a = a.or(b); break;
|
||||
case '^': a = a.xor(b); break;
|
||||
case '==': a = a.eq(b); break;
|
||||
case '!=': a = !a.eq(b); break;
|
||||
case '<': a = a.lt(b); break;
|
||||
case '<=': a = a.lte(b); break;
|
||||
case '>': a = a.gt(b); break;
|
||||
case '>=': a = a.gte(b); break;
|
||||
default: return invalid_operator();
|
||||
}
|
||||
if (typeof a === 'boolean')
|
||||
return { vtype: 'literal', name: '', hasnullvalue: false, type: JTYPES.boolean, value: a, valid: true };
|
||||
return { vtype: 'literal', name: '', hasnullvalue: false, type: JTYPES.long, value: hex_long(a), valid: true };
|
||||
}
|
||||
else if (JTYPES.isInteger(lhs_local.type) && JTYPES.isInteger(rhs_local.type)) {
|
||||
// both are (non-long) integer types
|
||||
var a = numberify(lhs_local), b = numberify(rhs_local);
|
||||
switch (expr.operator) {
|
||||
case '+': a += b; break;
|
||||
case '-': a -= b; break;
|
||||
case '*': a *= b; break;
|
||||
case '/': if (b) { a = Math.trunc(a / b); break } return divide_by_zero();
|
||||
case '%': if (b) { a %= b; break; } return divide_by_zero();
|
||||
case '<<': a <<= b; break;
|
||||
case '>>': a >>= b; break;
|
||||
case '>>>': a >>>= b; break;
|
||||
case '&': a &= b; break;
|
||||
case '|': a |= b; break;
|
||||
case '^': a ^= b; break;
|
||||
case '==': a = a === b; break;
|
||||
case '!=': a = a !== b; break;
|
||||
case '<': a = a < b; break;
|
||||
case '<=': a = a <= b; break;
|
||||
case '>': a = a > b; break;
|
||||
case '>=': a = a >= b; break;
|
||||
default: return invalid_operator();
|
||||
}
|
||||
if (typeof a === 'boolean')
|
||||
return { vtype: 'literal', name: '', hasnullvalue: false, type: JTYPES.boolean, value: a, valid: true };
|
||||
return { vtype: 'literal', name: '', hasnullvalue: false, type: JTYPES.int, value: '' + a, valid: true };
|
||||
}
|
||||
else if (JTYPES.isNumber(lhs_local.type) && JTYPES.isNumber(rhs_local.type)) {
|
||||
var a = numberify(lhs_local), b = numberify(rhs_local);
|
||||
switch (expr.operator) {
|
||||
case '+': a += b; break;
|
||||
case '-': a -= b; break;
|
||||
case '*': a *= b; break;
|
||||
case '/': a /= b; break;
|
||||
case '==': a = a === b; break;
|
||||
case '!=': a = a !== b; break;
|
||||
case '<': a = a < b; break;
|
||||
case '<=': a = a <= b; break;
|
||||
case '>': a = a > b; break;
|
||||
case '>=': a = a >= b; break;
|
||||
default: return invalid_operator();
|
||||
}
|
||||
if (typeof a === 'boolean')
|
||||
return { vtype: 'literal', name: '', hasnullvalue: false, type: JTYPES.boolean, value: a, valid: true };
|
||||
// one of them must be a float or double
|
||||
var result_type = 'float double'.split(' ')[Math.max("FD".indexOf(lhs_local.type.signature), "FD".indexOf(rhs_local.type.signature))];
|
||||
return { vtype: 'literal', name: '', hasnullvalue: false, type: JTYPES[result_type], value: '' + a, valid: true };
|
||||
}
|
||||
else if (lhs_local.type.signature === 'Z' && rhs_local.type.signature === 'Z') {
|
||||
// boolean operands
|
||||
var a = lhs_local.value, b = rhs_local.value;
|
||||
switch (expr.operator) {
|
||||
case '&': case '&&': a = a && b; break;
|
||||
case '|': case '||': a = a || b; break;
|
||||
case '^': a = !!(a ^ b); break;
|
||||
case '==': a = a === b; break;
|
||||
case '!=': a = a !== b; break;
|
||||
default: return invalid_operator();
|
||||
}
|
||||
return { vtype: 'literal', name: '', hasnullvalue: false, type: JTYPES.boolean, value: a, valid: true };
|
||||
}
|
||||
else if (expr.operator === '+' && JTYPES.isString(lhs_local.type)) {
|
||||
return stringify(rhs_local).then(rhs_str => createJavaString(dbgr, lhs_local.string + rhs_str, { israw: true }));
|
||||
}
|
||||
return invalid_operator();
|
||||
});
|
||||
}
|
||||
switch (expr.root_term_type) {
|
||||
case 'boolean':
|
||||
local = { vtype: 'literal', name: '', hasnullvalue: false, type: JTYPES.boolean, value: expr.root_term !== 'false', valid: true };
|
||||
break;
|
||||
case 'null':
|
||||
const nullvalue = '0000000000000000'; // null reference value
|
||||
local = { vtype: 'literal', name: '', hasnullvalue: true, type: JTYPES.null, value: nullvalue, valid: true };
|
||||
break;
|
||||
case 'ident':
|
||||
local = locals && locals.find(l => l.name === expr.root_term);
|
||||
break;
|
||||
case 'hexint':
|
||||
case 'octint':
|
||||
case 'decint':
|
||||
case 'decfloat':
|
||||
local = evaluate_number(expr.root_term);
|
||||
break;
|
||||
case 'char':
|
||||
case 'echar':
|
||||
case 'uchar':
|
||||
local = evaluate_char(decode_char(expr.root_term.slice(1, -1)))
|
||||
break;
|
||||
case 'string':
|
||||
// we must get the runtime to create string instances
|
||||
q = createJavaString(dbgr, expr.root_term);
|
||||
local = { valid: true }; // make sure we don't fail the evaluation
|
||||
break;
|
||||
}
|
||||
if (!local || !local.valid) return reject_evaluation('not available');
|
||||
// we've got the root term variable - work out the rest
|
||||
q = expr.array_or_fncall.arr.reduce((q, index_expr) => {
|
||||
return q.then(function (index_expr, local) { return evaluate_array_element.call(this, index_expr, local) }.bind(this, index_expr));
|
||||
}, q);
|
||||
q = expr.members.reduce((q, m) => {
|
||||
return q.then(function (m, local) { return evaluate_member.call(this, m, local) }.bind(this, m));
|
||||
}, q);
|
||||
if (expr.typecast) {
|
||||
q = q.then(function (type, local) { return evaluate_cast.call(this, type, local) }.bind(this, expr.typecast))
|
||||
}
|
||||
// if it's a string literal, we are already waiting for the runtime to create the string
|
||||
// - otherwise, start the evalaution...
|
||||
if (expr.root_term_type !== 'string')
|
||||
q.resolveWith(this, [local]);
|
||||
return q;
|
||||
}
|
||||
const evaluate_array_element = (index_expr, arr_local) => {
|
||||
if (arr_local.type.signature[0] !== '[') return reject_evaluation(`TypeError: cannot apply array index to non-array type '${arr_local.type.typename}'`);
|
||||
if (arr_local.hasnullvalue) return reject_evaluation('NullPointerException');
|
||||
return evaluate_expression(index_expr)
|
||||
.then(function (arr_local, idx_local) {
|
||||
if (!JTYPES.isInteger(idx_local.type)) return reject_evaluation('TypeError: array index is not an integer value');
|
||||
var idx = numberify(idx_local);
|
||||
if (idx < 0 || idx >= arr_local.arraylen) return reject_evaluation(`BoundsError: array index (${idx}) out of bounds. Array length = ${arr_local.arraylen}`);
|
||||
return dbgr.getarrayvalues(arr_local, idx, 1)
|
||||
}.bind(this, arr_local))
|
||||
.then(els => els[0])
|
||||
}
|
||||
const evaluate_methodcall = (m, obj_local) => {
|
||||
// until we can figure out why method invokes with parameters crash the debugger, disallow parameterised calls
|
||||
if (m.array_or_fncall.call.length)
|
||||
return reject_evaluation('Error: method calls with parameter values are not supported');
|
||||
|
||||
// find any methods matching the member name with any parameters in the signature
|
||||
return dbgr.findNamedMethods(obj_local.type.signature, m.member, /^/)
|
||||
.then(methods => {
|
||||
if (!methods[0])
|
||||
return reject_evaluation(`Error: method '${m.member}()' not found`);
|
||||
// evaluate any parameters (and wait for the results)
|
||||
return $.when({methods},...m.array_or_fncall.call.map(evaluate_expression));
|
||||
})
|
||||
.then((x,...paramValues) => {
|
||||
// filter the method based upon the types of parameters - note that null types and integer literals can match multiple types
|
||||
paramValues = paramValues = paramValues.map(p => p[0]);
|
||||
var matchers = paramValues.map(p => {
|
||||
switch(true) {
|
||||
case p.type.signature === 'I':
|
||||
// match bytes/shorts/ints/longs/floats/doubles within range
|
||||
if (p.value >= -128 && p.value <= 127) return /^[BSIJFD]$/
|
||||
if (p.value >= -32768 && p.value <= 32767) return /^[SIJFD]$/
|
||||
return /^[IJFD]$/;
|
||||
case p.type.signature === 'F':
|
||||
return /^[FD]$/;
|
||||
case p.type.signature === 'Lnull;':
|
||||
return /^[LT\[]/; // any reference type
|
||||
default:
|
||||
// anything else must be an exact signature match (for now - in reality we should allow subclassed type)
|
||||
return new RegExp(`^${p.type.signature.replace(/[$]/g,x=>'\\'+x)}$`);
|
||||
}
|
||||
});
|
||||
var methods = x.methods.filter(m => {
|
||||
// extract a list of parameter types
|
||||
var paramtypere = /\[*([BSIJFDCZ]|([LT][^;]+;))/g;
|
||||
for (var x, ptypes=[]; x = paramtypere.exec(m.sig); ) {
|
||||
ptypes.push(x[0]);
|
||||
}
|
||||
// the last paramter type is the return value
|
||||
ptypes.pop();
|
||||
// check if they match
|
||||
if (ptypes.length !== paramValues.length)
|
||||
return;
|
||||
return matchers.filter(m => {
|
||||
return !m.test(ptypes.shift())
|
||||
}).length === 0;
|
||||
});
|
||||
if (!methods[0])
|
||||
return reject_evaluation(`Error: incompatible parameters for method '${m.member}'`);
|
||||
// convert the parameters to exact debugger-compatible values
|
||||
paramValues = paramValues.map(p => {
|
||||
if (p.type.signature.length === 1)
|
||||
return { type: p.type.typename, value: p.value};
|
||||
return { type: 'oref', value: p.value };
|
||||
})
|
||||
return dbgr.invokeMethod(obj_local.value, thread.threadid, obj_local.type.signature, m.member, methods[0].genericsig || methods[0].sig, paramValues, {});
|
||||
});
|
||||
}
|
||||
const evaluate_member = (m, obj_local) => {
|
||||
if (!JTYPES.isReference(obj_local.type)) return reject_evaluation('TypeError: value is not a reference type');
|
||||
if (obj_local.hasnullvalue) return reject_evaluation('NullPointerException');
|
||||
var chain;
|
||||
if (m.array_or_fncall.call) {
|
||||
chain = evaluate_methodcall(m, obj_local);
|
||||
}
|
||||
// length is a 'fake' field of arrays, so special-case it
|
||||
else if (JTYPES.isArray(obj_local.type) && m.member === 'length') {
|
||||
chain = $.Deferred().resolve(evaluate_number(obj_local.arraylen));
|
||||
}
|
||||
// we also special-case :super (for object instances)
|
||||
else if (JTYPES.isObject(obj_local.type) && m.member === ':super') {
|
||||
chain = dbgr.getsuperinstance(obj_local);
|
||||
}
|
||||
// anything else must be a real field
|
||||
else {
|
||||
chain = dbgr.getFieldValue(obj_local, m.member, true)
|
||||
}
|
||||
|
||||
return chain.then(local => {
|
||||
if (m.array_or_fncall.arr.length) {
|
||||
var q = $.Deferred();
|
||||
m.array_or_fncall.arr.reduce((q, index_expr) => {
|
||||
return q.then(function (index_expr, local) { return evaluate_array_element(index_expr, local) }.bind(this, index_expr));
|
||||
}, q);
|
||||
return q.resolveWith(this, [local]);
|
||||
}
|
||||
});
|
||||
}
|
||||
const evaluate_cast = (type, local) => {
|
||||
if (type === local.type.typename) return local;
|
||||
const incompatible_cast = () => reject_evaluation(`Incompatible cast from ${local.type.typename} to ${type}`);
|
||||
// boolean cannot be converted from anything else
|
||||
if (type === 'boolean' || local.type.typename === 'boolean') return incompatible_cast();
|
||||
if (local.type.typename === 'long') {
|
||||
// long to something else
|
||||
var value = Long.fromString(local.value, true, 16);
|
||||
switch (true) {
|
||||
case (type === 'byte'): local = evaluate_number((parseInt(value.toString(16).slice(-2), 16) << 24) >> 24); break;
|
||||
case (type === 'short'): local = evaluate_number((parseInt(value.toString(16).slice(-4), 16) << 16) >> 16); break;
|
||||
case (type === 'int'): local = evaluate_number((parseInt(value.toString(16).slice(-8), 16) | 0)); break;
|
||||
case (type === 'char'): local = evaluate_char(String.fromCharCode(parseInt(value.toString(16).slice(-4), 16))); break;
|
||||
case (type === 'float'): local = evaluate_number(value.toSigned().toNumber() + 'F'); break;
|
||||
case (type === 'double'): local = evaluate_number(value.toSigned().toNumber() + 'D'); break;
|
||||
default: return incompatible_cast();
|
||||
}
|
||||
} else {
|
||||
switch (true) {
|
||||
case (type === 'byte'): local = evaluate_number((local.value << 24) >> 24); break;
|
||||
case (type === 'short'): local = evaluate_number((local.value << 16) >> 16); break;
|
||||
case (type === 'int'): local = evaluate_number((local.value | 0)); break;
|
||||
case (type === 'long'): local = evaluate_number(local.value + 'L'); break;
|
||||
case (type === 'char'): local = evaluate_char(String.fromCharCode(local.value | 0)); break;
|
||||
case (type === 'float'): break;
|
||||
case (type === 'double'): break;
|
||||
default: return incompatible_cast();
|
||||
}
|
||||
}
|
||||
local.type = JTYPES[type];
|
||||
return local;
|
||||
}
|
||||
|
||||
var e = { expr: expression.trim() };
|
||||
var parsed_expression = parse_expression(e);
|
||||
// if there's anything left, it's an error
|
||||
if (parsed_expression && !e.expr) {
|
||||
// the expression is well-formed - start the (asynchronous) evaluation
|
||||
return evaluate_expression(parsed_expression)
|
||||
.then(local => {
|
||||
var v = vars._local_to_variable(local);
|
||||
return resolve_evaluation(v.value, v.variablesReference);
|
||||
});
|
||||
}
|
||||
|
||||
// the expression is not well-formed
|
||||
return reject_evaluation('not available');
|
||||
}
|
||||
@@ -27,6 +27,22 @@ const JTYPES = {
|
||||
fromPrimSig(sig) { return JTYPES['byte,short,int,long,float,double,char,boolean'.split(',')['BSIJFDCZ'.indexOf(sig)]] },
|
||||
}
|
||||
|
||||
function signatureToFullyQualifiedType(sig) {
|
||||
var arr = sig.match(/^\[+/) || '';
|
||||
if (arr) {
|
||||
arr = '[]'.repeat(arr[0].length);
|
||||
sig = sig.slice(0, arr.length/2);
|
||||
}
|
||||
var m = sig.match(/^((L([^<;]+).)|T([^;]+).|.)/);
|
||||
if (!m) return '';
|
||||
if (m[3]) {
|
||||
return m[3].replace(/[/$]/g,'.') + arr;
|
||||
} else if (m[4]) {
|
||||
return m[4].replace(/[/$]/g, '.') + arr;
|
||||
}
|
||||
return JTYPES.fromPrimSig(sig[0]) + arr;
|
||||
}
|
||||
|
||||
// the special name given to exception message fields
|
||||
const exmsg_var_name = ':msg';
|
||||
|
||||
@@ -67,5 +83,5 @@ function variableRefToThreadId(variablesReference) {
|
||||
|
||||
|
||||
Object.assign(exports, {
|
||||
JTYPES,exmsg_var_name,ensure_path_end_slash,is_subpath_of,decode_char,variableRefToThreadId,createJavaString
|
||||
JTYPES, exmsg_var_name, ensure_path_end_slash, is_subpath_of, decode_char, variableRefToThreadId, createJavaString, signatureToFullyQualifiedType
|
||||
});
|
||||
|
||||
15
src/jdwp.js
15
src/jdwp.js
@@ -1,5 +1,5 @@
|
||||
const $ = require('./jq-promise');
|
||||
const { atob,btoa,D,getutf8bytes,fromutf8bytes,intToHex } = require('./util');
|
||||
const { btoa,D,E,getutf8bytes,fromutf8bytes,intToHex } = require('./util');
|
||||
/*
|
||||
JDWP - The Java Debug Wire Protocol
|
||||
*/
|
||||
@@ -96,8 +96,8 @@ function _JDWP() {
|
||||
return;
|
||||
}
|
||||
|
||||
if (this.errorcode != 0) {
|
||||
console.error("Command failed: error " + this.errorcode, this);
|
||||
if (this.errorcode !== 0) {
|
||||
E(`JDWP command failed '${this.command.name}'. Error ${this.errorcode}`, this);
|
||||
}
|
||||
|
||||
if (!this.errorcode && this.command && this.command.replydecodefn) {
|
||||
@@ -109,7 +109,10 @@ function _JDWP() {
|
||||
return;
|
||||
}
|
||||
|
||||
this.decoded = {empty:true};
|
||||
this.decoded = {
|
||||
empty: true,
|
||||
errorcode: this.errorcode,
|
||||
};
|
||||
}
|
||||
|
||||
this.decodereply = function(ths,s) {
|
||||
@@ -537,12 +540,12 @@ function _JDWP() {
|
||||
}
|
||||
m = signature.match(/^(\[+)(.+)$/);
|
||||
if (m) {
|
||||
var elementtype = this.signaturetotype(m[2]);
|
||||
var elementtype = this.signaturetotype(m[1].slice(0,-1) + m[2]);
|
||||
return {
|
||||
signature:signature,
|
||||
arraydims:m[1].length,
|
||||
elementtype: elementtype,
|
||||
typename:elementtype.typename+m[1].replace(/\[/g,'[]'),
|
||||
typename:elementtype.typename+'[]',
|
||||
}
|
||||
}
|
||||
var primitivetypes = {
|
||||
|
||||
@@ -40,7 +40,7 @@ var Deferred = exports.Deferred = function(p, parent) {
|
||||
var faildef = $.Deferred(null, this);
|
||||
var p = this._promise.catch(function(a) {
|
||||
if (a.stack) {
|
||||
console.error(a.stack);
|
||||
util.E(a.stack);
|
||||
a = [a];
|
||||
}
|
||||
if (this.def._context === null && this.def._parent)
|
||||
|
||||
@@ -1,6 +1,4 @@
|
||||
'use strict'
|
||||
// vscode stuff
|
||||
const { EventEmitter, Uri } = require('vscode');
|
||||
// node and external modules
|
||||
const fs = require('fs');
|
||||
const os = require('os');
|
||||
@@ -17,10 +15,8 @@ const { D } = require('./util');
|
||||
*/
|
||||
class LogcatContent {
|
||||
|
||||
constructor(provider/*: AndroidContentProvider*/, uri/*: Uri*/) {
|
||||
this._provider = provider;
|
||||
this._uri = uri;
|
||||
this._logcatid = uri.query;
|
||||
constructor(deviceid) {
|
||||
this._logcatid = deviceid;
|
||||
this._logs = [];
|
||||
this._htmllogs = [];
|
||||
this._oldhtmllogs = [];
|
||||
@@ -29,7 +25,7 @@ class LogcatContent {
|
||||
this._refreshRate = 200; // ms
|
||||
this._state = '';
|
||||
this._htmltemplate = '';
|
||||
this._adbclient = new ADBClient(uri.query);
|
||||
this._adbclient = new ADBClient(deviceid);
|
||||
this._initwait = new Promise((resolve, reject) => {
|
||||
this._state = 'connecting';
|
||||
LogcatContent.initWebSocketServer()
|
||||
@@ -38,7 +34,7 @@ class LogcatContent {
|
||||
onlog: this.onLogcatContent.bind(this),
|
||||
onclose: this.onLogcatDisconnect.bind(this),
|
||||
});
|
||||
}).then(x => {
|
||||
}).then(() => {
|
||||
this._state = 'connected';
|
||||
this._initwait = null;
|
||||
resolve(this.content);
|
||||
@@ -55,20 +51,20 @@ class LogcatContent {
|
||||
return this.htmlBootstrap({connected:true, status:'',oldlogs:''});
|
||||
// if we're in the disconnected state, and this.content is called, it means the user has requested
|
||||
// this logcat again - check if the device has reconnected
|
||||
return this._initwait = new Promise((resolve, reject) => {
|
||||
return this._initwait = new Promise((resolve/*, reject*/) => {
|
||||
// clear the logs first - if we successfully reconnect, we will be retrieving the entire logcat again
|
||||
this._prevlogs = {_logs: this._logs, _htmllogs: this._htmllogs, _oldhtmllogs: this._oldhtmllogs };
|
||||
this._logs = []; this._htmllogs = []; this._oldhtmllogs = [];
|
||||
this._adbclient.logcat({
|
||||
onlog: this.onLogcatContent.bind(this),
|
||||
onclose: this.onLogcatDisconnect.bind(this),
|
||||
}).then(x => {
|
||||
}).then(() => {
|
||||
// we successfully reconnected
|
||||
this._state = 'connected';
|
||||
this._prevlogs = null;
|
||||
this._initwait = null;
|
||||
resolve(this.content);
|
||||
}).fail(e => {
|
||||
}).fail((/*e*/) => {
|
||||
// reconnection failed - put the logs back and return the cached info
|
||||
this._logs = this._prevlogs._logs;
|
||||
this._htmllogs = this._prevlogs._htmllogs;
|
||||
@@ -81,8 +77,11 @@ class LogcatContent {
|
||||
});
|
||||
}
|
||||
sendClientMessage(msg) {
|
||||
var clients = LogcatContent._wss.clients.filter(client => client._logcatid === this._logcatid);
|
||||
clients.forEach(client => client.send(msg+'\n')); // include a newline to try and persuade a buffer write
|
||||
LogcatContent._wss.clients.forEach(client => {
|
||||
if (client._logcatid === this._logcatid) {
|
||||
client.send(msg + '\n'); // include a newline to try and persuade a buffer write
|
||||
}
|
||||
})
|
||||
}
|
||||
sendDisconnectMsg() {
|
||||
this.sendClientMessage(':disconnect');
|
||||
@@ -115,7 +114,7 @@ class LogcatContent {
|
||||
}
|
||||
updateLogs() {
|
||||
// no point in formatting the data if there are no connected clients
|
||||
var clients = LogcatContent._wss.clients.filter(client => client._logcatid === this._logcatid);
|
||||
var clients = [...LogcatContent._wss.clients].filter(client => client._logcatid === this._logcatid);
|
||||
if (clients.length) {
|
||||
var lines = '<div class="logblock">' + this._htmllogs.join('') + '</div>';
|
||||
clients.forEach(client => client.send(lines));
|
||||
@@ -161,7 +160,7 @@ class LogcatContent {
|
||||
this.renotify();
|
||||
}
|
||||
}
|
||||
onLogcatDisconnect(e) {
|
||||
onLogcatDisconnect(/*e*/) {
|
||||
if (this._state === 'disconnected') return;
|
||||
this._state = 'disconnected';
|
||||
this.sendDisconnectMsg();
|
||||
@@ -191,14 +190,19 @@ LogcatContent.initWebSocketServer = function () {
|
||||
port: wssport,
|
||||
retries: 0,
|
||||
tryCreateWSS() {
|
||||
this.wss = new WebSocketServer({ host: '127.0.0.1', port: this.port }, () => {
|
||||
const wsopts = {
|
||||
host: '127.0.0.1',
|
||||
port: this.port,
|
||||
clientTracking: true,
|
||||
};
|
||||
this.wss = new WebSocketServer(wsopts, () => {
|
||||
// success - save the info and resolve the deferred
|
||||
LogcatContent._wssport = this.port;
|
||||
LogcatContent._wssstartport = this.startport;
|
||||
LogcatContent._wss = this.wss;
|
||||
this.wss.on('connection', client => {
|
||||
this.wss.on('connection', (client, req) => {
|
||||
// the client uses the url path to signify which logcat data it wants
|
||||
client._logcatid = client.upgradeReq.url.match(/^\/?(.*)$/)[1];
|
||||
client._logcatid = req.url.match(/^\/?(.*)$/)[1];
|
||||
var lc = LogcatContent.byLogcatID[client._logcatid];
|
||||
if (lc) lc.onClientConnect(client);
|
||||
else client.close();
|
||||
@@ -215,7 +219,7 @@ LogcatContent.initWebSocketServer = function () {
|
||||
this.wss = null;
|
||||
LogcatContent._wssdone.resolveWith(LogcatContent, []);
|
||||
});
|
||||
this.wss.on('error', err => {
|
||||
this.wss.on('error', (/*err*/) => {
|
||||
if (!LogcatContent._wss) {
|
||||
// listen failed -try the next port
|
||||
this.retries++ , this.port++;
|
||||
@@ -245,7 +249,7 @@ function openLogcatWindow(vscode) {
|
||||
var adbpath = path.join(process.env.ANDROID_HOME, 'platform-tools', /^win/.test(process.platform)?'adb.exe':'adb');
|
||||
var adbargs = ['-P',''+adbport,'start-server'];
|
||||
try {
|
||||
var stdout = require('child_process').execFileSync(adbpath, adbargs, {cwd:process.env.ANDROID_HOME, encoding:'utf8'});
|
||||
/*var stdout = */require('child_process').execFileSync(adbpath, adbargs, {cwd:process.env.ANDROID_HOME, encoding:'utf8'});
|
||||
} catch (ex) {} // if we fail, it doesn't matter - the device query will fail and the user will have to work it out themselves
|
||||
}
|
||||
})
|
||||
@@ -278,11 +282,26 @@ function openLogcatWindow(vscode) {
|
||||
.then(devices => {
|
||||
if (!Array.isArray(devices)) return; // user cancelled (or no devices connected)
|
||||
devices.forEach(device => {
|
||||
if (vscode.window.createWebviewPanel) {
|
||||
const panel = vscode.window.createWebviewPanel(
|
||||
'androidlogcat', // Identifies the type of the webview. Used internally
|
||||
`logcat-${device.serial}`, // Title of the panel displayed to the user
|
||||
vscode.ViewColumn.One, // Editor column to show the new webview panel in.
|
||||
{
|
||||
enableScripts: true,
|
||||
}
|
||||
);
|
||||
const logcat = new LogcatContent(device.serial);
|
||||
logcat.content.then(html => {
|
||||
panel.webview.html = html;
|
||||
});
|
||||
return;
|
||||
}
|
||||
var uri = AndroidContentProvider.getReadLogcatUri(device.serial);
|
||||
return vscode.commands.executeCommand("vscode.previewHtml",uri,vscode.ViewColumn.Two);
|
||||
});
|
||||
})
|
||||
.fail(e => {
|
||||
.fail((/*e*/) => {
|
||||
vscode.window.showInformationMessage('Logcat cannot be displayed. Querying the connected devices list failed. Is ADB running?');
|
||||
});
|
||||
}
|
||||
|
||||
11
src/state.js
Normal file
11
src/state.js
Normal file
@@ -0,0 +1,11 @@
|
||||
const vscode = require('vscode');
|
||||
const fs = require('fs');
|
||||
const path = require('path');
|
||||
const os = require('os');
|
||||
|
||||
var adext = {};
|
||||
try {
|
||||
Object.assign(adext, JSON.parse(fs.readFileSync(path.join(path.dirname(__dirname),'package.json'),'utf8')));
|
||||
} catch (ex) { }
|
||||
|
||||
exports.adext = adext;
|
||||
608
src/util.js
608
src/util.js
@@ -1,43 +1,48 @@
|
||||
const crypto = require('crypto');
|
||||
|
||||
var nofn=function(){};
|
||||
var D=exports.D=console.log.bind(console);
|
||||
var E=exports.E=console.error.bind(console);
|
||||
var W=exports.W=console.warn.bind(console);
|
||||
var DD=nofn,cl=D,printf=D;
|
||||
var nofn = function () { };
|
||||
const messagePrintCallbacks = new Set();
|
||||
var D = exports.D = (...args) => (console.log(...args), messagePrintCallbacks.forEach(cb => cb(...args)))
|
||||
var E = exports.E = (...args) => (console.error(...args), messagePrintCallbacks.forEach(cb => cb(...args)))
|
||||
var W = exports.W = (...args) => (console.warn(...args), messagePrintCallbacks.forEach(cb => cb(...args)))
|
||||
var DD = nofn, cl = D, printf = D;
|
||||
var print_jdwp_data = nofn;// _print_jdwp_data;
|
||||
var print_packet = nofn;//_print_packet;
|
||||
|
||||
Array.first = function(arr, fn, defaultvalue) {
|
||||
exports.onMessagePrint = function(cb) {
|
||||
messagePrintCallbacks.add(cb);
|
||||
}
|
||||
|
||||
Array.first = function (arr, fn, defaultvalue) {
|
||||
var idx = Array.indexOfFirst(arr, fn);
|
||||
return idx < 0 ? defaultvalue : arr[idx];
|
||||
}
|
||||
|
||||
Array.indexOfFirst = function(arr, fn) {
|
||||
Array.indexOfFirst = function (arr, fn) {
|
||||
if (!Array.isArray(arr)) return -1;
|
||||
for (var i=0; i < arr.length; i++)
|
||||
for (var i = 0; i < arr.length; i++)
|
||||
if (fn(arr[i], i, arr))
|
||||
return i;
|
||||
return -1;
|
||||
}
|
||||
|
||||
var isEmptyObject = exports.isEmptyObject = function(o) {
|
||||
return typeof(o)==='object' && !Object.keys(o).length;
|
||||
var isEmptyObject = exports.isEmptyObject = function (o) {
|
||||
return typeof (o) === 'object' && !Object.keys(o).length;
|
||||
}
|
||||
|
||||
var leftpad = exports.leftpad = function(char, len, s) {
|
||||
var leftpad = exports.leftpad = function (char, len, s) {
|
||||
while (s.length < len)
|
||||
s = char + s;
|
||||
return s;
|
||||
}
|
||||
|
||||
var intToHex = exports.intToHex = function(i, minlen) {
|
||||
var intToHex = exports.intToHex = function (i, minlen) {
|
||||
var s = i.toString(16);
|
||||
if (minlen) s = leftpad('0', minlen, s);
|
||||
return s;
|
||||
}
|
||||
|
||||
var intFromHex = exports.intFromHex = function(s, maxlen, defaultvalue) {
|
||||
var intFromHex = exports.intFromHex = function (s, maxlen, defaultvalue) {
|
||||
s = s.slice(0, maxlen);
|
||||
if (!/^[0-9a-fA-F]+$/.test(s)) return defaultvalue;
|
||||
return parseInt(s, 16);
|
||||
@@ -45,53 +50,53 @@ var intFromHex = exports.intFromHex = function(s, maxlen, defaultvalue) {
|
||||
|
||||
var fdcache = [];
|
||||
|
||||
var index_of_file_fdn = function(n) {
|
||||
var index_of_file_fdn = function (n) {
|
||||
if (n <= 0) return -1;
|
||||
for (var i=0; i < fdcache.length; i++) {
|
||||
for (var i = 0; i < fdcache.length; i++) {
|
||||
if (fdcache[i] && fdcache[i].n === n)
|
||||
return i;
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
var get_file_fd_from_fdn = function(n) {
|
||||
var get_file_fd_from_fdn = function (n) {
|
||||
var idx = index_of_file_fdn(n);
|
||||
if (idx < 0) return null;
|
||||
return fdcache[idx];
|
||||
}
|
||||
|
||||
var remove_fd_from_cache = function(fd) {
|
||||
var remove_fd_from_cache = function (fd) {
|
||||
if (!fd) return;
|
||||
var idx = index_of_file_fdn(fd.n);
|
||||
if (idx>=0) fdcache.splice(idx, 1);
|
||||
if (idx >= 0) fdcache.splice(idx, 1);
|
||||
}
|
||||
|
||||
// add an offset so we don't conflict with tcp socketIds
|
||||
var min_fd_num = 100000;
|
||||
var _new_fd_count = 0;
|
||||
var new_fd = this.new_fd = function(name, raw) {
|
||||
var new_fd = this.new_fd = function (name, raw) {
|
||||
var rwpipe = raw ? new Uint8Array(0) : [];
|
||||
var fd = {
|
||||
name: name,
|
||||
n: min_fd_num + (++_new_fd_count),
|
||||
raw: !!raw,
|
||||
readpipe:rwpipe,
|
||||
writepipe:rwpipe,
|
||||
reader:null,
|
||||
readerlen:0,
|
||||
kickingreader:false,
|
||||
total:{read:0,written:0},
|
||||
readpipe: rwpipe,
|
||||
writepipe: rwpipe,
|
||||
reader: null,
|
||||
readerlen: 0,
|
||||
kickingreader: false,
|
||||
total: { read: 0, written: 0 },
|
||||
duplex: null,
|
||||
closed:'',
|
||||
read:function(cb) {
|
||||
closed: '',
|
||||
read: function (cb) {
|
||||
if (this.raw)
|
||||
throw 'Cannot read from raw fd';
|
||||
if (this.reader && this.reader !== cb)
|
||||
throw 'multiple readers?';
|
||||
this.reader = cb;
|
||||
this._kickreader();
|
||||
this.reader = cb;
|
||||
this._kickreader();
|
||||
},
|
||||
write:function(data) {
|
||||
write: function (data) {
|
||||
if (this.closed) {
|
||||
D('Ignoring attempt to write to closed file: %o', this);
|
||||
return;
|
||||
@@ -100,23 +105,23 @@ var new_fd = this.new_fd = function(name, raw) {
|
||||
D('Ignoring attempt to write object to raw file: %o', this);
|
||||
return;
|
||||
}
|
||||
this.writepipe.push(data);
|
||||
if (this.duplex) {
|
||||
this.duplex._kickreader();
|
||||
}
|
||||
this.writepipe.push(data);
|
||||
if (this.duplex) {
|
||||
this.duplex._kickreader();
|
||||
}
|
||||
},
|
||||
|
||||
readbytes:function(len, cb) {
|
||||
readbytes: function (len, cb) {
|
||||
if (!this.raw)
|
||||
throw 'Cannot readbytes from non-raw fd';
|
||||
if (this.reader)
|
||||
throw 'multiple readers?';
|
||||
this.reader = cb;
|
||||
this.reader = cb;
|
||||
this.readerlen = len;
|
||||
this._kickreader();
|
||||
this._kickreader();
|
||||
},
|
||||
|
||||
writebytes:function(buffer) {
|
||||
writebytes: function (buffer) {
|
||||
if (this.closed) {
|
||||
D('Ignoring attempt to write to closed file: %o', this);
|
||||
return;
|
||||
@@ -135,35 +140,35 @@ var new_fd = this.new_fd = function(name, raw) {
|
||||
newbuf.set(this.writepipe);
|
||||
newbuf.set(buffer, this.writepipe.byteLength);
|
||||
this.writepipe = newbuf;
|
||||
if (this.duplex)
|
||||
if (this.duplex)
|
||||
this.duplex.readpipe = newbuf;
|
||||
else
|
||||
this.readpipe = newbuf;
|
||||
D('new buffer size: %d (fd:%d)',this.writepipe.byteLength, this.n);
|
||||
D('new buffer size: %d (fd:%d)', this.writepipe.byteLength, this.n);
|
||||
this._kickreaders();
|
||||
},
|
||||
|
||||
cancelread:function(flushfirst) {
|
||||
cancelread: function (flushfirst) {
|
||||
if (flushfirst)
|
||||
this.flush();
|
||||
this.reader = null;
|
||||
this.readerlen = 0;
|
||||
},
|
||||
|
||||
write_eof:function() {
|
||||
write_eof: function () {
|
||||
this.flush();
|
||||
// eof is only relevant for read-until-close readers
|
||||
if (this.raw && this.reader && this.readerlen === -1) {
|
||||
this.reader({err:'eof'});
|
||||
this.reader({ err: 'eof' });
|
||||
}
|
||||
},
|
||||
|
||||
flush:function() {
|
||||
flush: function () {
|
||||
this._doread();
|
||||
},
|
||||
|
||||
close:function() {
|
||||
if (this.closed)
|
||||
close: function () {
|
||||
if (this.closed)
|
||||
return;
|
||||
console.trace('Closing file %d: %o', this.n, this);
|
||||
this.closed = 'closed';
|
||||
@@ -175,24 +180,24 @@ var new_fd = this.new_fd = function(name, raw) {
|
||||
remove_fd_from_cache(this);
|
||||
},
|
||||
|
||||
_kickreaders:function() {
|
||||
_kickreaders: function () {
|
||||
if (this.duplex)
|
||||
this.duplex._kickreader();
|
||||
else
|
||||
this._kickreader();
|
||||
},
|
||||
|
||||
_kickreader:function() {
|
||||
if (!this.reader) return;
|
||||
if (this.kickingreader) return;
|
||||
var t = this;
|
||||
t.kickingreader = setTimeout(function() {
|
||||
t.kickingreader = false;
|
||||
t._doreadcheckclose();
|
||||
}, 0);
|
||||
_kickreader: function () {
|
||||
if (!this.reader) return;
|
||||
if (this.kickingreader) return;
|
||||
var t = this;
|
||||
t.kickingreader = setTimeout(function () {
|
||||
t.kickingreader = false;
|
||||
t._doreadcheckclose();
|
||||
}, 0);
|
||||
},
|
||||
|
||||
_doreadcheckclose:function() {
|
||||
|
||||
_doreadcheckclose: function () {
|
||||
var cs = this.closed;
|
||||
this._doread();
|
||||
if (cs) {
|
||||
@@ -203,13 +208,13 @@ var new_fd = this.new_fd = function(name, raw) {
|
||||
this.readerlen = 0;
|
||||
if (rucreader && rucreadercb) {
|
||||
// terminate the read-until-close reader
|
||||
D('terminating ruc reader. fd: %o',this);
|
||||
rucreadercb({err:'File closed'});
|
||||
D('terminating ruc reader. fd: %o', this);
|
||||
rucreadercb({ err: 'File closed' });
|
||||
}
|
||||
}
|
||||
},
|
||||
|
||||
_doread:function() {
|
||||
_doread: function () {
|
||||
if (this.raw) {
|
||||
if (!this.reader) return;
|
||||
if (this.readerlen > this.readpipe.byteLength) return;
|
||||
@@ -218,7 +223,7 @@ var new_fd = this.new_fd = function(name, raw) {
|
||||
this.reader = null, this.readerlen = 0;
|
||||
var data;
|
||||
if (len) {
|
||||
var readlen = len>0?len:this.readpipe.byteLength;
|
||||
var readlen = len > 0 ? len : this.readpipe.byteLength;
|
||||
data = this.readpipe.subarray(0, readlen);
|
||||
this.readpipe = this.readpipe.subarray(readlen);
|
||||
if (this.duplex)
|
||||
@@ -230,17 +235,17 @@ var new_fd = this.new_fd = function(name, raw) {
|
||||
data = new Uint8Array(0);
|
||||
}
|
||||
|
||||
data.asString = function() {
|
||||
data.asString = function () {
|
||||
return uint8ArrayToString(this);
|
||||
};
|
||||
data.intFromHex = function(len) {
|
||||
len = len||this.byteLength;
|
||||
var x = this.asString().slice(0,len);
|
||||
data.intFromHex = function (len) {
|
||||
len = len || this.byteLength;
|
||||
var x = this.asString().slice(0, len);
|
||||
if (!/^[0-9a-fA-F]+/.test(x)) return -1;
|
||||
return parseInt(x, 16);
|
||||
}
|
||||
cb(null, data);
|
||||
|
||||
|
||||
if (len < 0) {
|
||||
// reset the reader
|
||||
this.readbytes(len, cb);
|
||||
@@ -259,103 +264,103 @@ var new_fd = this.new_fd = function(name, raw) {
|
||||
return fd;
|
||||
}
|
||||
|
||||
var intToCharString = function(n) {
|
||||
var intToCharString = function (n) {
|
||||
return String.fromCharCode(
|
||||
(n>>0)&255,
|
||||
(n>>8)&255,
|
||||
(n>>16)&255,
|
||||
(n>>24)&255
|
||||
(n >> 0) & 255,
|
||||
(n >> 8) & 255,
|
||||
(n >> 16) & 255,
|
||||
(n >> 24) & 255
|
||||
);
|
||||
}
|
||||
|
||||
var stringToUint8Array = function(s) {
|
||||
var stringToUint8Array = function (s) {
|
||||
var x = new Uint8Array(s.length);
|
||||
for (var i=0; i < s.length; i++)
|
||||
for (var i = 0; i < s.length; i++)
|
||||
x[i] = s.charCodeAt(i);
|
||||
return x;
|
||||
}
|
||||
|
||||
var uint8ArrayToString = function(a) {
|
||||
var uint8ArrayToString = function (a) {
|
||||
var s = new Array(a.byteLength);
|
||||
for (var i=0; i < a.byteLength; i++)
|
||||
for (var i = 0; i < a.byteLength; i++)
|
||||
s[i] = a[i];
|
||||
return String.fromCharCode.apply(String, s);
|
||||
}
|
||||
|
||||
// asynchronous array iterater
|
||||
var iterate = function(arr, o) {
|
||||
var isrange = typeof(arr)==='number';
|
||||
if (isrange)
|
||||
arr = { length: arr<0?0:arr };
|
||||
var iterate = function (arr, o) {
|
||||
var isrange = typeof (arr) === 'number';
|
||||
if (isrange)
|
||||
arr = { length: arr < 0 ? 0 : arr };
|
||||
var x = {
|
||||
value:arr,
|
||||
isrange:isrange,
|
||||
first:o.first||nofn,
|
||||
each:o.each||(function() { this.next(); }),
|
||||
last:o.last||nofn,
|
||||
success:o.success||nofn,
|
||||
error:o.error||nofn,
|
||||
complete:o.complete||nofn,
|
||||
_idx:0,
|
||||
_donefirst:false,
|
||||
_donelast:false,
|
||||
abort:function(err) {
|
||||
value: arr,
|
||||
isrange: isrange,
|
||||
first: o.first || nofn,
|
||||
each: o.each || (function () { this.next(); }),
|
||||
last: o.last || nofn,
|
||||
success: o.success || nofn,
|
||||
error: o.error || nofn,
|
||||
complete: o.complete || nofn,
|
||||
_idx: 0,
|
||||
_donefirst: false,
|
||||
_donelast: false,
|
||||
abort: function (err) {
|
||||
this.error(err);
|
||||
this.complete();
|
||||
return;
|
||||
},
|
||||
finish:function(res) {
|
||||
finish: function (res) {
|
||||
// finish early
|
||||
if (typeof(res)!=='undefined') this.result = res;
|
||||
this.success(res||this.result);
|
||||
if (typeof (res) !== 'undefined') this.result = res;
|
||||
this.success(res || this.result);
|
||||
this.complete();
|
||||
return;
|
||||
},
|
||||
iteratefirst:function() {
|
||||
iteratefirst: function () {
|
||||
if (!this.value.length) {
|
||||
this.finish();
|
||||
return;
|
||||
}
|
||||
this.first(this.value[this._idx],this._idx,this);
|
||||
this.each(this.value[this._idx],this._idx,this);
|
||||
this.first(this.value[this._idx], this._idx, this);
|
||||
this.each(this.value[this._idx], this._idx, this);
|
||||
},
|
||||
iteratenext:function() {
|
||||
iteratenext: function () {
|
||||
if (++this._idx >= this.value.length) {
|
||||
this.last(this.value[this._idx],this._idx,this);
|
||||
this.last(this.value[this._idx], this._idx, this);
|
||||
this.finish();
|
||||
return;
|
||||
}
|
||||
this.each(this.value[this._idx],this._idx,this);
|
||||
this.each(this.value[this._idx], this._idx, this);
|
||||
},
|
||||
next:function() {
|
||||
next: function () {
|
||||
var t = this;
|
||||
setTimeout(function() {
|
||||
t.iteratenext();
|
||||
},0);
|
||||
setTimeout(function () {
|
||||
t.iteratenext();
|
||||
}, 0);
|
||||
},
|
||||
nextorabort:function(err) {
|
||||
if (err) this.abort(err);
|
||||
else this.next();
|
||||
nextorabort: function (err) {
|
||||
if (err) this.abort(err);
|
||||
else this.next();
|
||||
},
|
||||
};
|
||||
setTimeout(function() { x.iteratefirst(); }, 0);
|
||||
setTimeout(function () { x.iteratefirst(); }, 0);
|
||||
return x;
|
||||
};
|
||||
|
||||
var iterate_repeat = function(arr, count, o, j) {
|
||||
var iterate_repeat = function (arr, count, o, j) {
|
||||
iterate(arr, {
|
||||
each: function(value, i, it) {
|
||||
o.each(value, i, j||0, it);
|
||||
each: function (value, i, it) {
|
||||
o.each(value, i, j || 0, it);
|
||||
},
|
||||
success: function() {
|
||||
success: function () {
|
||||
if (!--count) {
|
||||
o.success && o.success();
|
||||
o.complete && o.complete();
|
||||
return;
|
||||
}
|
||||
iterate_repeat(arr, count, o, (j||0)+1);
|
||||
iterate_repeat(arr, count, o, (j || 0) + 1);
|
||||
},
|
||||
error:function(err) {
|
||||
error: function (err) {
|
||||
o.error && o.error();
|
||||
o.complete && o.complete();
|
||||
}
|
||||
@@ -367,13 +372,13 @@ var iterate_repeat = function(arr, count, o, j) {
|
||||
* @param {ArrayBuffer} buffer The array buffer to convert.
|
||||
* @return {string} The textual representation of the array.
|
||||
*/
|
||||
var arrayBufferToString = exports.arrayBufferToString = function(buffer) {
|
||||
var array = new Uint8Array(buffer);
|
||||
var str = '';
|
||||
for (var i = 0; i < array.length; ++i) {
|
||||
str += String.fromCharCode(array[i]);
|
||||
}
|
||||
return str;
|
||||
var arrayBufferToString = exports.arrayBufferToString = function (buffer) {
|
||||
var array = new Uint8Array(buffer);
|
||||
var str = '';
|
||||
for (var i = 0; i < array.length; ++i) {
|
||||
str += String.fromCharCode(array[i]);
|
||||
}
|
||||
return str;
|
||||
};
|
||||
|
||||
/**
|
||||
@@ -381,59 +386,59 @@ var arrayBufferToString = exports.arrayBufferToString = function(buffer) {
|
||||
* @param {array} UTF-8 array
|
||||
* @return {string} UTF-8 string
|
||||
*/
|
||||
var ary2utf8 = (function() {
|
||||
var ary2utf8 = (function () {
|
||||
|
||||
var patterns = [
|
||||
{pattern: '0xxxxxxx', bytes: 1},
|
||||
{pattern: '110xxxxx', bytes: 2},
|
||||
{pattern: '1110xxxx', bytes: 3},
|
||||
{pattern: '11110xxx', bytes: 4},
|
||||
{pattern: '111110xx', bytes: 5},
|
||||
{pattern: '1111110x', bytes: 6}
|
||||
];
|
||||
patterns.forEach(function(item) {
|
||||
item.header = item.pattern.replace(/[^10]/g, '');
|
||||
item.pattern01 = item.pattern.replace(/[^10]/g, '0');
|
||||
item.pattern01 = parseInt(item.pattern01, 2);
|
||||
item.mask_length = item.header.length;
|
||||
item.data_length = 8 - item.header.length;
|
||||
var mask = '';
|
||||
for (var i = 0, len = item.mask_length; i < len; i++) {
|
||||
mask += '1';
|
||||
}
|
||||
for (var i = 0, len = item.data_length; i < len; i++) {
|
||||
mask += '0';
|
||||
}
|
||||
item.mask = mask;
|
||||
item.mask = parseInt(item.mask, 2);
|
||||
});
|
||||
var patterns = [
|
||||
{ pattern: '0xxxxxxx', bytes: 1 },
|
||||
{ pattern: '110xxxxx', bytes: 2 },
|
||||
{ pattern: '1110xxxx', bytes: 3 },
|
||||
{ pattern: '11110xxx', bytes: 4 },
|
||||
{ pattern: '111110xx', bytes: 5 },
|
||||
{ pattern: '1111110x', bytes: 6 }
|
||||
];
|
||||
patterns.forEach(function (item) {
|
||||
item.header = item.pattern.replace(/[^10]/g, '');
|
||||
item.pattern01 = item.pattern.replace(/[^10]/g, '0');
|
||||
item.pattern01 = parseInt(item.pattern01, 2);
|
||||
item.mask_length = item.header.length;
|
||||
item.data_length = 8 - item.header.length;
|
||||
var mask = '';
|
||||
for (var i = 0, len = item.mask_length; i < len; i++) {
|
||||
mask += '1';
|
||||
}
|
||||
for (var i = 0, len = item.data_length; i < len; i++) {
|
||||
mask += '0';
|
||||
}
|
||||
item.mask = mask;
|
||||
item.mask = parseInt(item.mask, 2);
|
||||
});
|
||||
|
||||
return function(ary) {
|
||||
var codes = [];
|
||||
var cur = 0;
|
||||
while(cur < ary.length) {
|
||||
var first = ary[cur];
|
||||
var pattern = null;
|
||||
for (var i = 0, len = patterns.length; i < len; i++) {
|
||||
if ((first & patterns[i].mask) == patterns[i].pattern01) {
|
||||
pattern = patterns[i];
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (pattern == null) {
|
||||
throw 'utf-8 decode error';
|
||||
}
|
||||
var rest = ary.slice(cur + 1, cur + pattern.bytes);
|
||||
cur += pattern.bytes;
|
||||
var code = '';
|
||||
code += ('00000000' + (first & (255 ^ pattern.mask)).toString(2)).slice(-pattern.data_length);
|
||||
for (var i = 0, len = rest.length; i < len; i++) {
|
||||
code += ('00000000' + (rest[i] & parseInt('111111', 2)).toString(2)).slice(-6);
|
||||
}
|
||||
codes.push(parseInt(code, 2));
|
||||
}
|
||||
return String.fromCharCode.apply(null, codes);
|
||||
};
|
||||
return function (ary) {
|
||||
var codes = [];
|
||||
var cur = 0;
|
||||
while (cur < ary.length) {
|
||||
var first = ary[cur];
|
||||
var pattern = null;
|
||||
for (var i = 0, len = patterns.length; i < len; i++) {
|
||||
if ((first & patterns[i].mask) == patterns[i].pattern01) {
|
||||
pattern = patterns[i];
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (pattern == null) {
|
||||
throw 'utf-8 decode error';
|
||||
}
|
||||
var rest = ary.slice(cur + 1, cur + pattern.bytes);
|
||||
cur += pattern.bytes;
|
||||
var code = '';
|
||||
code += ('00000000' + (first & (255 ^ pattern.mask)).toString(2)).slice(-pattern.data_length);
|
||||
for (var i = 0, len = rest.length; i < len; i++) {
|
||||
code += ('00000000' + (rest[i] & parseInt('111111', 2)).toString(2)).slice(-6);
|
||||
}
|
||||
codes.push(parseInt(code, 2));
|
||||
}
|
||||
return String.fromCharCode.apply(null, codes);
|
||||
};
|
||||
|
||||
})();
|
||||
|
||||
@@ -442,52 +447,52 @@ var ary2utf8 = (function() {
|
||||
* @param {string} UTF-8 string
|
||||
* @return {array} UTF-8 array
|
||||
*/
|
||||
var utf82ary = (function() {
|
||||
var utf82ary = (function () {
|
||||
|
||||
var patterns = [
|
||||
{pattern: '0xxxxxxx', bytes: 1},
|
||||
{pattern: '110xxxxx', bytes: 2},
|
||||
{pattern: '1110xxxx', bytes: 3},
|
||||
{pattern: '11110xxx', bytes: 4},
|
||||
{pattern: '111110xx', bytes: 5},
|
||||
{pattern: '1111110x', bytes: 6}
|
||||
];
|
||||
patterns.forEach(function(item) {
|
||||
item.header = item.pattern.replace(/[^10]/g, '');
|
||||
item.mask_length = item.header.length;
|
||||
item.data_length = 8 - item.header.length;
|
||||
item.max_bit_length = (item.bytes - 1) * 6 + item.data_length;
|
||||
});
|
||||
var patterns = [
|
||||
{ pattern: '0xxxxxxx', bytes: 1 },
|
||||
{ pattern: '110xxxxx', bytes: 2 },
|
||||
{ pattern: '1110xxxx', bytes: 3 },
|
||||
{ pattern: '11110xxx', bytes: 4 },
|
||||
{ pattern: '111110xx', bytes: 5 },
|
||||
{ pattern: '1111110x', bytes: 6 }
|
||||
];
|
||||
patterns.forEach(function (item) {
|
||||
item.header = item.pattern.replace(/[^10]/g, '');
|
||||
item.mask_length = item.header.length;
|
||||
item.data_length = 8 - item.header.length;
|
||||
item.max_bit_length = (item.bytes - 1) * 6 + item.data_length;
|
||||
});
|
||||
|
||||
var code2utf8array = function(code) {
|
||||
var pattern = null;
|
||||
var code01 = code.toString(2);
|
||||
for (var i = 0, len = patterns.length; i < len; i++) {
|
||||
if (code01.length <= patterns[i].max_bit_length) {
|
||||
pattern = patterns[i];
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (pattern == null) {
|
||||
throw 'utf-8 encode error';
|
||||
}
|
||||
var ary = [];
|
||||
for (var i = 0, len = pattern.bytes - 1; i < len; i++) {
|
||||
ary.unshift(parseInt('10' + ('000000' + code01.slice(-6)).slice(-6), 2));
|
||||
code01 = code01.slice(0, -6);
|
||||
}
|
||||
ary.unshift(parseInt(pattern.header + ('00000000' + code01).slice(-pattern.data_length), 2));
|
||||
return ary;
|
||||
};
|
||||
var code2utf8array = function (code) {
|
||||
var pattern = null;
|
||||
var code01 = code.toString(2);
|
||||
for (var i = 0, len = patterns.length; i < len; i++) {
|
||||
if (code01.length <= patterns[i].max_bit_length) {
|
||||
pattern = patterns[i];
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (pattern == null) {
|
||||
throw 'utf-8 encode error';
|
||||
}
|
||||
var ary = [];
|
||||
for (var i = 0, len = pattern.bytes - 1; i < len; i++) {
|
||||
ary.unshift(parseInt('10' + ('000000' + code01.slice(-6)).slice(-6), 2));
|
||||
code01 = code01.slice(0, -6);
|
||||
}
|
||||
ary.unshift(parseInt(pattern.header + ('00000000' + code01).slice(-pattern.data_length), 2));
|
||||
return ary;
|
||||
};
|
||||
|
||||
return function(str) {
|
||||
var codes = [];
|
||||
for (var i = 0, len = str.length; i < len; i++) {
|
||||
var code = str.charCodeAt(i);
|
||||
Array.prototype.push.apply(codes, code2utf8array(code));
|
||||
}
|
||||
return codes;
|
||||
};
|
||||
return function (str) {
|
||||
var codes = [];
|
||||
for (var i = 0, len = str.length; i < len; i++) {
|
||||
var code = str.charCodeAt(i);
|
||||
Array.prototype.push.apply(codes, code2utf8array(code));
|
||||
}
|
||||
return codes;
|
||||
};
|
||||
|
||||
})();
|
||||
|
||||
@@ -496,89 +501,88 @@ var utf82ary = (function() {
|
||||
* @param {string} string The string to convert.
|
||||
* @return {ArrayBuffer} An array buffer whose bytes correspond to the string.
|
||||
*/
|
||||
var stringToArrayBuffer = exports.stringToArrayBuffer = function(string) {
|
||||
var buffer = new ArrayBuffer(string.length);
|
||||
var bufferView = new Uint8Array(buffer);
|
||||
for (var i = 0; i < string.length; i++) {
|
||||
bufferView[i] = string.charCodeAt(i);
|
||||
}
|
||||
return buffer;
|
||||
var stringToArrayBuffer = exports.stringToArrayBuffer = function (string) {
|
||||
var buffer = new ArrayBuffer(string.length);
|
||||
var bufferView = new Uint8Array(buffer);
|
||||
for (var i = 0; i < string.length; i++) {
|
||||
bufferView[i] = string.charCodeAt(i);
|
||||
}
|
||||
return buffer;
|
||||
};
|
||||
|
||||
var str2ab = exports.str2ab = stringToArrayBuffer;
|
||||
var ab2str = exports.ab2str = arrayBufferToString;
|
||||
var str2u8arr = exports.str2u8arr = function(s) {
|
||||
var str2u8arr = exports.str2u8arr = function (s) {
|
||||
return new Uint8Array(str2ab(s));
|
||||
}
|
||||
|
||||
exports.getutf8bytes = function(str) {
|
||||
var utf8 = [];
|
||||
for (var i=0; i < str.length; i++) {
|
||||
var charcode = str.charCodeAt(i);
|
||||
if (charcode < 0x80) utf8.push(charcode);
|
||||
else if (charcode < 0x800) {
|
||||
utf8.push(0xc0 | (charcode >> 6),
|
||||
0x80 | (charcode & 0x3f));
|
||||
}
|
||||
else if (charcode < 0xd800 || charcode >= 0xe000) {
|
||||
utf8.push(0xe0 | (charcode >> 12),
|
||||
0x80 | ((charcode>>6) & 0x3f),
|
||||
0x80 | (charcode & 0x3f));
|
||||
}
|
||||
// surrogate pair
|
||||
else {
|
||||
i++;
|
||||
// UTF-16 encodes 0x10000-0x10FFFF by
|
||||
// subtracting 0x10000 and splitting the
|
||||
// 20 bits of 0x0-0xFFFFF into two halves
|
||||
charcode = 0x10000 + (((charcode & 0x3ff)<<10)
|
||||
| (str.charCodeAt(i) & 0x3ff));
|
||||
utf8.push(0xf0 | (charcode >>18),
|
||||
0x80 | ((charcode>>12) & 0x3f),
|
||||
0x80 | ((charcode>>6) & 0x3f),
|
||||
0x80 | (charcode & 0x3f));
|
||||
}
|
||||
}
|
||||
return utf8;
|
||||
}
|
||||
|
||||
exports.fromutf8bytes = function(array) {
|
||||
var out, i, len, c;
|
||||
var char2, char3;
|
||||
|
||||
out = "";
|
||||
len = array.length;
|
||||
i = 0;
|
||||
while(i < len) {
|
||||
c = array[i++];
|
||||
switch(c >> 4)
|
||||
{
|
||||
case 0: case 1: case 2: case 3: case 4: case 5: case 6: case 7:
|
||||
// 0xxxxxxx
|
||||
out += String.fromCharCode(c);
|
||||
break;
|
||||
case 12: case 13:
|
||||
// 110x xxxx 10xx xxxx
|
||||
char2 = array[i++];
|
||||
out += String.fromCharCode(((c & 0x1F) << 6) | (char2 & 0x3F));
|
||||
break;
|
||||
case 14:
|
||||
// 1110 xxxx 10xx xxxx 10xx xxxx
|
||||
char2 = array[i++];
|
||||
char3 = array[i++];
|
||||
out += String.fromCharCode(((c & 0x0F) << 12) |
|
||||
((char2 & 0x3F) << 6) |
|
||||
((char3 & 0x3F) << 0));
|
||||
break;
|
||||
exports.getutf8bytes = function (str) {
|
||||
var utf8 = [];
|
||||
for (var i = 0; i < str.length; i++) {
|
||||
var charcode = str.charCodeAt(i);
|
||||
if (charcode < 0x80) utf8.push(charcode);
|
||||
else if (charcode < 0x800) {
|
||||
utf8.push(0xc0 | (charcode >> 6),
|
||||
0x80 | (charcode & 0x3f));
|
||||
}
|
||||
}
|
||||
|
||||
return out;
|
||||
else if (charcode < 0xd800 || charcode >= 0xe000) {
|
||||
utf8.push(0xe0 | (charcode >> 12),
|
||||
0x80 | ((charcode >> 6) & 0x3f),
|
||||
0x80 | (charcode & 0x3f));
|
||||
}
|
||||
// surrogate pair
|
||||
else {
|
||||
i++;
|
||||
// UTF-16 encodes 0x10000-0x10FFFF by
|
||||
// subtracting 0x10000 and splitting the
|
||||
// 20 bits of 0x0-0xFFFFF into two halves
|
||||
charcode = 0x10000 + (((charcode & 0x3ff) << 10)
|
||||
| (str.charCodeAt(i) & 0x3ff));
|
||||
utf8.push(0xf0 | (charcode >> 18),
|
||||
0x80 | ((charcode >> 12) & 0x3f),
|
||||
0x80 | ((charcode >> 6) & 0x3f),
|
||||
0x80 | (charcode & 0x3f));
|
||||
}
|
||||
}
|
||||
return utf8;
|
||||
}
|
||||
|
||||
exports.arraybuffer_concat = function() {
|
||||
var bufs=[], total=0;
|
||||
for (var i=0; i < arguments.length; i++) {
|
||||
exports.fromutf8bytes = function (array) {
|
||||
var out, i, len, c;
|
||||
var char2, char3;
|
||||
|
||||
out = "";
|
||||
len = array.length;
|
||||
i = 0;
|
||||
while (i < len) {
|
||||
c = array[i++];
|
||||
switch (c >> 4) {
|
||||
case 0: case 1: case 2: case 3: case 4: case 5: case 6: case 7:
|
||||
// 0xxxxxxx
|
||||
out += String.fromCharCode(c);
|
||||
break;
|
||||
case 12: case 13:
|
||||
// 110x xxxx 10xx xxxx
|
||||
char2 = array[i++];
|
||||
out += String.fromCharCode(((c & 0x1F) << 6) | (char2 & 0x3F));
|
||||
break;
|
||||
case 14:
|
||||
// 1110 xxxx 10xx xxxx 10xx xxxx
|
||||
char2 = array[i++];
|
||||
char3 = array[i++];
|
||||
out += String.fromCharCode(((c & 0x0F) << 12) |
|
||||
((char2 & 0x3F) << 6) |
|
||||
((char3 & 0x3F) << 0));
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
return out;
|
||||
}
|
||||
|
||||
exports.arraybuffer_concat = function () {
|
||||
var bufs = [], total = 0;
|
||||
for (var i = 0; i < arguments.length; i++) {
|
||||
var a = arguments[i];
|
||||
if (!a || !a.byteLength) continue;
|
||||
bufs.push(a);
|
||||
@@ -589,16 +593,16 @@ exports.arraybuffer_concat = function() {
|
||||
case 1: return new Uint8Array(bufs[0]);
|
||||
}
|
||||
var res = new Uint8Array(total);
|
||||
for (var i=0, j=0; i < bufs.length; i++) {
|
||||
for (var i = 0, j = 0; i < bufs.length; i++) {
|
||||
res.set(bufs[i], j);
|
||||
j += bufs[i].byteLength;
|
||||
}
|
||||
return res;
|
||||
}
|
||||
|
||||
exports.remove_from_list = function(arr, item, searchfn) {
|
||||
if (!searchfn) searchfn = function(a,b) { return a===b; };
|
||||
for (var i=0; i < arr.length; i++) {
|
||||
exports.remove_from_list = function (arr, item, searchfn) {
|
||||
if (!searchfn) searchfn = function (a, b) { return a === b; };
|
||||
for (var i = 0; i < arr.length; i++) {
|
||||
var found = searchfn(arr[i], item);
|
||||
if (found) {
|
||||
return {
|
||||
@@ -610,22 +614,22 @@ exports.remove_from_list = function(arr, item, searchfn) {
|
||||
D('Object %o not removed from list %o', item, arr);
|
||||
}
|
||||
|
||||
exports.dumparr = function(arr, offset, count) {
|
||||
offset=offset||0;
|
||||
count = count||(count===0?0:arr.length);
|
||||
if (count > arr.length-offset)
|
||||
count = arr.length-offset;
|
||||
exports.dumparr = function (arr, offset, count) {
|
||||
offset = offset || 0;
|
||||
count = count || (count === 0 ? 0 : arr.length);
|
||||
if (count > arr.length - offset)
|
||||
count = arr.length - offset;
|
||||
var s = '';
|
||||
while (count--) {
|
||||
s += ' '+('00'+arr[offset++].toString(16)).slice(-2);
|
||||
s += ' ' + ('00' + arr[offset++].toString(16)).slice(-2);
|
||||
}
|
||||
return s.slice(1);
|
||||
}
|
||||
|
||||
exports.btoa = function(arr) {
|
||||
return new Buffer(arr,'binary').toString('base64');
|
||||
exports.btoa = function (arr) {
|
||||
return Buffer.from(arr, 'binary').toString('base64');
|
||||
}
|
||||
|
||||
exports.atob = function(base64) {
|
||||
return new Buffer(base64, 'base64').toString('binary');
|
||||
exports.atob = function (base64) {
|
||||
return Buffer.from(base64, 'base64').toString('binary');
|
||||
}
|
||||
|
||||
@@ -79,6 +79,8 @@ class AndroidVariables {
|
||||
value: x.varinfo.objvar.value,
|
||||
valid:true,
|
||||
});
|
||||
// create the fully qualified names to use for evaluation
|
||||
fields.forEach(f => f.fqname = `${x.varinfo.objvar.fqname || x.varinfo.objvar.name}.${f.name}`);
|
||||
x.varinfo.cached = fields;
|
||||
return this._local_to_variable(fields);
|
||||
});
|
||||
@@ -100,9 +102,10 @@ class AndroidVariables {
|
||||
return $.Deferred().resolve(variables);
|
||||
}
|
||||
// get the elements for the specified range
|
||||
return this.dbgr.getarrayvalues(varinfo.arrvar, range[0], count)
|
||||
.then((elements) => {
|
||||
varinfo.cached = elements;
|
||||
return this.dbgr.getarrayvalues(varinfo.arrvar, range[0], count, {varinfo})
|
||||
.then((elements, x) => {
|
||||
elements.forEach(el => el.fqname = `${x.varinfo.arrvar.fqname || x.varinfo.arrvar.name}[${el.name}]`);
|
||||
x.varinfo.cached = elements;
|
||||
return this._local_to_variable(elements);
|
||||
});
|
||||
}
|
||||
@@ -158,7 +161,7 @@ class AndroidVariables {
|
||||
*/
|
||||
_local_to_variable(v) {
|
||||
if (Array.isArray(v)) return v.filter(v => v.valid).map(v => this._local_to_variable(v));
|
||||
var varref = 0, objvalue, typename = v.type.package ? `${v.type.package}.${v.type.typename}` : v.type.typename;
|
||||
var varref = 0, objvalue, evaluateName = v.fqname || v.name, formats = {}, typename = v.type.package ? `${v.type.package}.${v.type.typename}` : v.type.typename;
|
||||
switch(true) {
|
||||
case v.hasnullvalue && JTYPES.isReference(v.type):
|
||||
// null object or array type
|
||||
@@ -188,7 +191,7 @@ class AndroidVariables {
|
||||
varref = this._getObjectIdReference(v.type, v.value);
|
||||
this.variableHandles[varref] = { varref:varref, arrvar:v, range:[0,v.arraylen] };
|
||||
}
|
||||
objvalue = v.type.typename.replace(/]$/, v.arraylen+']'); // insert len as the final array bound
|
||||
objvalue = v.type.typename.replace(/]/, v.arraylen+']'); // insert len as the first array bound
|
||||
break;
|
||||
case JTYPES.isObject(v.type):
|
||||
// non-null object instance - add another variable reference so the user can expand
|
||||
@@ -207,10 +210,27 @@ class AndroidVariables {
|
||||
case v.type.signature === 'J':
|
||||
// because JS cannot handle 64bit ints, we need a bit of extra work
|
||||
var v64hex = v.value.replace(/[^0-9a-fA-F]/g,'');
|
||||
objvalue = NumberBaseConverter.hexToDec(v64hex, true);
|
||||
objvalue = formats.dec = NumberBaseConverter.hexToDec(v64hex, true);
|
||||
formats.hex = '0x' + v64hex.replace(/^0+/, '0');
|
||||
formats.oct = formats.bin = '';
|
||||
// 24 bit chunks...
|
||||
for (var s=v64hex,uint; s; s = s.slice(0,-6)) {
|
||||
uint = parseInt(s.slice(-6), 16) >>> 0; // 6*4 = 24 bits
|
||||
formats.oct = uint.toString(8) + formats.oct;
|
||||
formats.bin = uint.toString(2) + formats.bin;
|
||||
}
|
||||
formats.oct = '0c' + formats.oct.replace(/^0+/, '0');
|
||||
formats.bin = '0b' + formats.bin.replace(/^0+/, '0');
|
||||
break;
|
||||
case /^[BIS]$/.test(v.type.signature):
|
||||
objvalue = formats.dec = v.value.toString();
|
||||
var uint = (v.value >>> 0);
|
||||
formats.hex = '0x' + uint.toString(16);
|
||||
formats.oct = '0c' + uint.toString(8);
|
||||
formats.bin = '0b' + uint.toString(2);
|
||||
break;
|
||||
default:
|
||||
// other primitives: int, boolean, etc
|
||||
// other primitives: boolean, etc
|
||||
objvalue = v.value.toString();
|
||||
break;
|
||||
}
|
||||
@@ -223,6 +243,7 @@ class AndroidVariables {
|
||||
name: v.name,
|
||||
type: typename,
|
||||
value: objvalue,
|
||||
evaluateName,
|
||||
variablesReference: varref,
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user