feat: generalize config file records for HTAB and List ptr custom

Now they are in same format as internal represenatation: type, parent,
member - no specialization for member or variable.

Compatibility with previous format is saved, but schema.json changed to
new version without syntax help.

This is required to more convenient updating of configuration file in
callbacks (for now this is single update after new NodeTags found).

Author: ashenBlade

docs/config_file.md

@@ -191,11 +191,13 @@ This information stored in `customListTypes` member. This is array of objects:
     "customListTypes": [
         {
             "type": "MyCustomType *",
-            "member": ["ParentStruct", "parent_member"]
+            "parent": "ParentStruct",
+            "member": "parent_member"
         },
         {
             "type": "MyCustomType *",
-            "variable": ["ParentFunction", "variable_name"]
+            "parent": "ParentFunction",
+            "member": "variable_name"
         }
     ]
 }
@@ -204,24 +206,23 @@ This information stored in `customListTypes` member. This is array of objects:
 Each object contain:
 
 - `type` - fully-qualified type name (that is `struct` or `pointer` should be included) to which pointer will be casted.
-- `member` - pair of struct name and member of this struct. Definition looks like this:
-
-    ```c
-    typedef struct ParentStruct
-    {
-        List *parent_member;
-    } ParentStruct;
-    ```
-
-- `variable` - pair of function name and variable inside it. Definition looks like this:
-
-    ```c
-    void
-    ParentFunction()
-    {
-        List *variable_name;
-    }
-    ```
+- `parent` - name of struct or function (parent entity) containing this member or variable.
+- `member` - name of member or variable that contains `List *` value.
+
+As you can mention this configuration is generalized, because it's clear from context how to handle `parent`. Example above is for following code:
+
+```c
+typedef struct ParentStruct
+{
+    List *parent_member;
+} ParentStruct;
+
+void
+ParentFunction()
+{
+    List *variable_name;
+}
+```
 
 With this 2 strategies extension detects `List`s with custom types.
 
@@ -237,11 +238,13 @@ This information stored in `htab` member. This is an array of objects similar to
     "htab": [
         {
             "type": "SampleType *",
-            "member": ["ParentStruct", "parent_member"]
+            "parent": "ParentStruct",
+            "member": "parent_member"
         },
         {
             "type": "SampleType *",
-            "variable": ["ParentFunction", "variable_name"]
+            "parent": "ParentFunction",
+            "member": "variable_name"
         }
     ]
 }
@@ -250,23 +253,24 @@ This information stored in `htab` member. This is an array of objects similar to
 Each object contain:
 
 - `type` - fully qualified type name of entry in `HTAB`
-- `member` - array of struct name and member inside this struct with `HTAB *` type. Definition looks like this:
+- `parent` - name of struct or function (parent entity) containing this member or variable.
+- `member` - name of member or variable that contains `List *` value.
 
-    ```c
-    typedef struct ParentStruct
-    {
-        HTAB *parent_member;
-    } ParentStruct;
-    ```
+> You can notice that schema is the same as for custom `List *` type.
 
-- `variable` - array of function name and variable inside this function with `HTAB *` type. Definition looks like this
+Example aboves is for following code:
 
-    ```c
-    void ParentFunction()
-    {
-        HTAB *variable_name;
-    }
-    ```
+```c
+typedef struct ParentStruct
+{
+    HTAB *parent_member;
+}
+
+void ParentFunction()
+{
+    HTAB *variable_name;
+}
+```
 
 Also, there is support for `simplehash.c` hash tables ("simplehash" further). They are code generated using macros, so for each specific hash table there are functions and structures defined.
 Several builtin simplehashes exists and using configuration file you can add your own.
@@ -323,3 +327,31 @@ Fields:
 - `member` - name of the member with enum type (`type->member`)
 - `flags` - array of enum value definitions: MACRO VALUE + NUMERIC VALUE
 - `fields` - array of inner fields: human readable name of field + MACRO MASK for member + numeric value of mask
+
+Example above is for following code:
+
+```c
+#define EM_FIRST   0x01
+#define EM_SECOND  0x02
+#define EM_THIRD   0x04
+
+#define EM_FIELD_MASK 0xF
+
+typedef struct ParentType
+{
+    int enum_member;
+}
+
+void function()
+{
+    ParentType *value;
+    if (value->enum_member & EM_FIRST) {
+        /* ... */
+    }
+    
+    int innerField = value->enum_member & EM_FIELD_MASK;
+    if (innerField == 4) {
+        /* ... */
+    }
+}
+```

docs/pg_variables.md

@@ -10,7 +10,7 @@ While debug session there is `Pg variables` view available in debug view contain
 
 It contains all variables that available in default `variables` view, but
 stored variables are processed by extension.
-Description of processing methods are [below](#type-investigation).
+Description of processing methods are [below](#type-exploring).
 
 This view refreshed after each step, but you can force refresh it using
 refresh button in right upper corner.

properties.schema.json

@@ -79,21 +79,17 @@
                     "pattern": "\\*$",
                     "description": "Type to which 'ListCell's will be casted. Must be pointer."
                 },
-                "member": {
-                    "type": "array",
-                    "minItems": 2,
-                    "maxItems": 2,
-                    "description": "Pair of parent struct name and member name inside this struct, identifying this List*"
+                "parent": {
+                    "type": "string",
+                    "description": "Name of struct or function which this 'List *' belongs to. If this is a member then name of structure, otherwise if this is variable in function, then enter function name."
                 },
-                "variable": {
-                    "type": "array",
-                    "minItems": 2,
-                    "maxItems": 2,
-                    "description": "Pair of function name and variable name inside this function, identifying this List*"
+                "member": {
+                    "type": "string",
+                    "description": "Name of member of variable which contains this 'List *'."
                 }
             },
             "required": [
-                "type"
+                "type", "parent", "member"
             ]
         },
         "htab": {
@@ -103,23 +99,19 @@
                 "type": {
                     "type": "string",
                     "pattern": "\\*$",
-                    "description": "Type of entry in Hash Table. Must be pointer."
+                    "description": "Type of entry in Hash Table to which entry will be casted. Must be pointer."
                 },
-                "member": {
-                    "type": "array",
-                    "minItems": 2,
-                    "maxItems": 2,
-                    "description": "Pair of parent struct name and member name inside this struct, identifying this HTAB*"
+                "parent": {
+                    "type": "string",
+                    "description": "Name of struct or function which this 'HTAB *' belongs to. If this is a member then name of structure, otherwise if this is variable in function, then enter function name."
                 },
-                "variable": {
-                    "type": "array",
-                    "minItems": 2,
-                    "maxItems": 2,
-                    "description": "Pair of function name and variable inside this function, identifying this HTAB*"
+                "member": {
+                    "type": "string",
+                    "description": "Name of member of variable which contains this 'HTAB *'"
                 }
             },
             "required": [
-                "type"
+                "type", "parent", "member"
             ]
         },
         "simplehash": {