Add support for Java with basic type definitions

awulkiew · awulkiew · commit 9f2f0580dd41 · 2024-08-05T23:30:34.000+02:00
Update readme, changelog
Bump version
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -8,6 +8,11 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 ### Known issues
 - The visualization is not shown after hiding the webview with another window and showing it again
 
+## [0.10.0]
+### Added
+- Support for Java
+- Visualization of Java arrays, numbers and points
+
 ## [0.9.0]
 ### Added
 - Support for debugpy Python debugger
diff --git a/README.md b/README.md
@@ -48,6 +48,17 @@ You can download this extension from [Visual Studio Marketplace](https://marketp
 * 2D values/geometries
   * System.Drawing: `Point`
 
+##### Java (java)
+
+* Containers of values, points and other geometries
+  * Array
+  * java.util: `ArrayList`, `LinkedList`, `Vector`
+* 1D values
+  * java.lang: `Byte`, `Double`, `Float`, `Integer`, `Long`, `Short`
+* 2D values/geometries
+  * java.awt: `Point`
+  * java.awt.geom: `Point2D.Double`, `Point2D.Float`
+
 ##### Javascript (chrome, msedge, node, pwa-node, pwa-chrome, pwa-msedge)
 
 * Containers of values, points and other geometries
diff --git a/package.json b/package.json
@@ -1,6 +1,6 @@
 {
 	"name": "graphicaldebugging-vscode",
-	"version": "0.9.0",
+	"version": "0.10.0",
 	"publisher": "AdamWulkiewicz",
 	"author": {
 		"name": "Adam Wulkiewicz"
@@ -17,8 +17,8 @@
 		"Other"		
 	],
 	"keywords": [
-		"2d", "array", "boost", "box", "c", "c++", "cartesian", "chart", "complex", "container", "curve",
-		"debug", "debugging", "deque", "geographic", "geometry", "gis", "graphical", "javascript", "linestring", "list",
+		"2d", "array", "boost", "box", "c", "c++", "c#", "cartesian", "chart", "complex", "container", "curve",
+		"debug", "debugging", "deque", "geographic", "geometry", "gis", "graphical", "java", "javascript", "linestring", "list",
 		"plot", "point", "polygon", "python", "rgeo", "ring", "ruby", "segment", "shapely", "spherical", "std", "stl", "tuple", "vector",
 		"visualization", "visualize"
 	],
diff --git a/resources/java.json b/resources/java.json
@@ -0,0 +1,96 @@
+{
+    "name": "graphicaldebugging",
+    "language": "java",
+    "types": [
+        {
+            "type": "[a-zA-Z_][\\w<,>:\\s]*\\[\\]",
+            "kind": "container",
+            "array": {
+                "start": "$this",
+                "size": "$this.length"
+            },
+            "_comment": "Java array"
+        },
+        {
+            "type": "ArrayList",
+            "kind": "container",
+            "iarray": {
+                "element": "$this.get($i)",
+                "size": "$this.size()"
+            }
+        },
+        {
+            "type": "LinkedList",
+            "kind": "container",
+            "iarray": {
+                "element": "$this.get($i)",
+                "size": "$this.size()"
+            }
+        },
+        {
+            "type": "Vector",
+            "kind": "container",
+            "iarray": {
+                "element": "$this.get($i)",
+                "size": "$this.size()"
+            }
+        },
+        {
+            "type": "Point",
+            "kind": "point",
+            "system": "cartesian",
+            "coordinates": {
+                "x": "$this.x",
+                "y": "$this.y"
+            }
+        },
+        {
+            "type": "Point2D.Double",
+            "kind": "point",
+            "system": "cartesian",
+            "coordinates": {
+                "x": "$this.x",
+                "y": "$this.y"
+            }
+        },
+        {
+            "type": "Point2D.Float",
+            "kind": "point",
+            "system": "cartesian",
+            "coordinates": {
+                "x": "$this.x",
+                "y": "$this.y"
+            }
+        },
+        {
+            "type": "Byte",
+            "kind": "value",
+            "name": "$this.value"
+        },
+        {
+            "type": "Double",
+            "kind": "value",
+            "name": "$this.value"
+        },
+        {
+            "type": "Float",
+            "kind": "value",
+            "name": "$this.value"
+        },
+        {
+            "type": "Integer",
+            "kind": "value",
+            "name": "$this.value"
+        },
+        {
+            "type": "Long",
+            "kind": "value",
+            "name": "$this.value"
+        },
+        {
+            "type": "Short",
+            "kind": "value",
+            "name": "$this.value"
+        }        
+    ]
+}
diff --git a/src/loader.ts b/src/loader.ts
@@ -100,24 +100,27 @@ export class Variable {
 
 
 interface IExpressionPart {
-    toString(variable: Variable): string;
+    toString(variable: Variable, parameter: number | undefined): string;
 }
 class ExpressionString implements IExpressionPart {
     constructor(private _str: string) {}
-    toString(variable: Variable): string { return this._str; }
+    toString(variable: Variable, parameter: number | undefined): string { return this._str; }
 }
 class ExpressionThis implements IExpressionPart {
-    toString(variable: Variable): string { return '(' + variable.name + ')'; }
+    toString(variable: Variable, parameter: number | undefined): string { return '(' + variable.name + ')'; }
 }
 class ExpressionNParam implements IExpressionPart {
     constructor(protected _i: number) {}
-    toString(variable: Variable): string { return variable.nparam(this._i); }
+    toString(variable: Variable, parameter: number | undefined): string { return variable.nparam(this._i); }
 }
 class ExpressionTParam extends ExpressionNParam {
-    toString(variable: Variable): string { return variable.tparam(this._i); }
+    toString(variable: Variable, parameter: number | undefined): string { return variable.tparam(this._i); }
 }
 class ExpressionType implements IExpressionPart {
-    toString(variable: Variable): string { return variable.type; }
+    toString(variable: Variable, parameter: number | undefined): string { return variable.type; }
+}
+class ExpressionIndex implements IExpressionPart {
+    toString(variable: Variable, parameter: number | undefined): string { return parameter !== undefined ? parameter.toString() : "0"; }
 }
 export class Expression
 {
@@ -148,17 +151,21 @@ export class Expression
                     this._parts.push(new ExpressionNParam(parseInt(match[0].substr(2))));
                     index = match.index + match[0].length;
                 }
+                else if (match[0] === '$i') {
+                    this._parts.push(new ExpressionIndex());
+                    index = match.index + 2;
+                }
             }
         }
         if (index < expression.length) {
             this._parts.push(new ExpressionString(expression.substr(index)));
         }
     }
 
-    toString(variable: Variable): string {
+    toString(variable: Variable, parameter: number | undefined = undefined): string {
         let result: string = '';
         for (let part of this._parts) {
-            result += part.toString(variable);            
+            result += part.toString(variable, parameter);            
         }
         // TODO: do this only for C++ ?
         // It is possible that this should depend on the debugger
@@ -197,6 +204,15 @@ async function evaluateExpression(dbg: debug.Debugger, variable: Variable, expre
     return new EvaluatedExpression(expr, str, vt[1]);
 }
 
+async function evaluateIndexedExpression(dbg: debug.Debugger, variable: Variable, expressionName: string, parameter: number): Promise<EvaluatedExpression | undefined> {
+	const expr = new Expression(expressionName);
+    const str = expr.toString(variable, parameter);
+    let vt = await dbg.getValueAndRawType(str);
+    if (vt === undefined)
+        return undefined;
+    return new EvaluatedExpression(expr, str, vt[1]);
+}
+
 function getValueFromExpressionStr(dbg: debug.Debugger, str: string): number | boolean | undefined {
     const language = dbg.language();
     if (language != undefined) {
@@ -240,10 +256,9 @@ export class Container {
 }
 
 export class RandomAccessContainer extends Container {}
-
 export class ContiguousContainer extends RandomAccessContainer {}
 
-// Static array
+// Indexed array
 export class Array extends ContiguousContainer
 {
     constructor(private _start: Expression, private _size: Expression) {
@@ -276,8 +291,8 @@ export class Array extends ContiguousContainer
     }
 }
 
-// Dynamic array
-export class DArray extends RandomAccessContainer {
+// Indexed array with size defined by two pointers
+export class DArray extends ContiguousContainer {
     constructor(private _start: Expression, private _finish: Expression) {
         super();
     }
@@ -303,6 +318,38 @@ export class DArray extends RandomAccessContainer {
     }
 }
 
+export class IArray extends RandomAccessContainer
+{
+    constructor(private _element: Expression, private _size: Expression) {
+        super();
+    }
+
+    element(variable: Variable): string | undefined {
+        return this._element.toString(variable, 0);
+    }
+
+    async size(dbg: debug.Debugger, variable: Variable): Promise<number> {
+        const sizeStr = this._size.toString(variable);
+        // TODO: Check if it's possible to parse size at this point
+        const sizeVal = await dbg.getValue(sizeStr);
+        return sizeVal !== undefined ? parseInt(sizeVal) : 0;
+    }
+
+    async *elements(dbg: debug.Debugger, variable: Variable): AsyncGenerator<string, void, unknown> {
+        const size = await this.size(dbg, variable);
+        if (! (size > 0)) // also handle NaN
+            return;
+        // NOTE: This loop could be done asynchroniously with await Promise.all()
+        //   but an array can potentially store great number of objects so there
+        //   would be great number of promises. And it will not be possible to
+        //   end fast in case of error because the program would wait for all.
+        for (let i = 0; i < size; ++i) {
+            const elStr = this._element.toString(variable, i);
+            yield elStr;
+        }
+    }
+}
+
 // TODO: Later when direct memory access is implemented allow passing pointers
 export class LinkedList extends Container
 {
@@ -1262,6 +1309,12 @@ async function _getContainer(dbg: debug.Debugger, variable: Variable, entry: any
         if (start && finish) {
             return new DArray(start.expression, finish.expression);
         }
+    } else if (entry.iarray && entry.iarray.element && entry.iarray.size) {
+        const element = await evaluateIndexedExpression(dbg, variable, entry.iarray.element, 0);
+        const size = await evaluateExpression(dbg, variable, entry.iarray.size);
+        if (element && size) {
+            return new IArray(element.expression, size.expression);
+        }
     } else if (entry.linkedlist && entry.linkedlist.size && entry.linkedlist.value) {
         if (entry.linkedlist.head && entry.linkedlist.next) {
             const size = await evaluateExpression(dbg, variable, entry.linkedlist.size);
