i-c-fn-head 0.0.5

package/src/show_doc_symbs.ts

@@ -0,0 +1,66 @@
+import * as vscode from 'vscode';
+import { _c_fn_body, _rust_fn_body, c_fn_body } from './fn_body_n_head';
+export class ShowDocumentSymbols implements vscode.DocumentSymbolProvider {
+    provideDocumentSymbols(document: vscode.TextDocument, token: vscode.CancellationToken): vscode.ProviderResult<vscode.SymbolInformation[]> {
+        let symbols: vscode.SymbolInformation[] = [];
+        let text0 = document.getText();
+        const text = text0.split("\n");
+
+        // Regular expression patterns for different symbols
+        const functionPattern: RegExp[] = [
+            /(^(\s*if))/g,
+        ];
+        const classPattern = /class\s+([a-zA-Z_$][0-9a-zA-Z_$]*)/g;
+        const variablePattern = /const\s+([a-zA-Z_$][0-9a-zA-Z_$]*)|let\s+([a-zA-Z_$][0-9a-zA-Z_$]*)|var\s+([a-zA-Z_$][0-9a-zA-Z_$]*)/g;
+        let wrong_ending = /;[\s]*}?$/
+        const func_ret = /^return\s/;
+        const while_op = /[\s]*while[\s]*\(/;
+        const for_op = /\s*for[\s]*\(?/;
+        const switch_op = /[\s]*switch[\s]*\(?/;
+        const if_op = /^[\s]*if[\s]*\(/;
+        const scope_op_in_D = /^scope\s*\(/;
+        const bad_symbs = /[=+\-]/;
+        // Extract functions
+        let match: RegExpExecArray | null | undefined = null;
+        //console.log("start");
+        //console.log(text);
+        let yes_D = vscode.window.activeTextEditor?.document.languageId.toLowerCase() === "d";
+        let functionName: string = "";
+        let _1st: boolean = true;
+        let line: number = 0;
+        let pos: vscode.Range | undefined = new vscode.Range(0, 0, 0, 100);
+        let point: vscode.Position = new vscode.Position(0, 0);
+        let set_rng: vscode.Range;
+        let default_range = new vscode.Range(0, 0, 0, 100);
+        /*	while ((match = select_lang_n_tst_fn_head (text0) ) !== null) {
+                const fnName = match[1];
+                const position = document.positionAt(match.index);
+                symbols.push(new vscode.SymbolInformation(fnName, vscode.SymbolKind.Function, '', new vscode.Location(document.uri, position)));
+            }*/
+        //dont_clobbe_line_w_curly_bracket(text0, document.uri);
+        //	if (manage_output(text0, document.uri, symbols) != _manage_output.Rust) { return symbols; }
+        manage_output(text0, document.uri, symbols);
+        return symbols;
+    }
+}
+enum _manage_output {
+    C,
+    D,
+    Rust,
+    CPP
+}
+export function manage_output(doc: string, uri: vscode.Uri, symbols: & vscode.SymbolInformation[]): _manage_output | RegExp | null {
+    const langId = vscode.window.activeTextEditor?.document.uri.fsPath ?? "";
+    let regex = /rs$|c$|cpp$|d$/g;
+    let lang: string = regex.exec(langId)?.[0] ?? "";
+    const msg = "Active lang: " + langId?.toString();
+    //vscode.window.showInformationMessage(msg);
+    switch (lang) {
+        case "c": { c_fn_body(doc, uri, symbols); return _manage_output.C }
+        case "cpp": { c_fn_body(doc, uri, symbols); return _manage_output.CPP }
+        case "d": { _c_fn_body(doc, uri, symbols); return _manage_output.D }
+        case "rs": { _rust_fn_body(doc, uri, symbols); return _manage_output.Rust }// { return rust_head() }
+    }
+    //	prnt(msg);
+    return null
+}

package/src/test/extension.test.ts

@@ -0,0 +1,15 @@
+import * as assert from 'assert';
+
+// You can import and use all API from the 'vscode' module
+// as well as import your extension to test it
+import * as vscode from 'vscode';
+// import * as myExtension from '../../extension';
+
+suite('Extension Test Suite', () => {
+	vscode.window.showInformationMessage('Start all tests.');
+
+	test('Sample test', () => {
+		assert.strictEqual(-1, [1, 2, 3].indexOf(5));
+		assert.strictEqual(-1, [1, 2, 3].indexOf(0));
+	});
+});

package/tsconfig.json

@@ -0,0 +1,23 @@
+{
+	"compilerOptions": {
+		"module": "Node16",
+		"target": "ES2022",
+		"lib": [
+			"ES2022"
+		],
+		"sourceMap": true,
+		"outDir": "./dist",
+		"rootDir": "./src",
+		"strict": true
+	},
+	"exclude": [
+        "./github"
+        ],
+      "keybindings": [
+            {
+                "command": "i_c_fn_head.onKeyPress",
+                "key": "up",
+                "when": "editorTextFocus"
+            }
+        ]
+}

package/vsc-extension-quickstart.md

@@ -0,0 +1,48 @@
+# Welcome to your VS Code Extension
+
+## What's in the folder
+
+* This folder contains all of the files necessary for your extension.
+* `package.json` - this is the manifest file in which you declare your extension and command.
+  * The sample plugin registers a command and defines its title and command name. With this information VS Code can show the command in the command palette. It doesn’t yet need to load the plugin.
+* `src/extension.ts` - this is the main file where you will provide the implementation of your command.
+  * The file exports one function, `activate`, which is called the very first time your extension is activated (in this case by executing the command). Inside the `activate` function we call `registerCommand`.
+  * We pass the function containing the implementation of the command as the second parameter to `registerCommand`.
+
+## Setup
+
+* install the recommended extensions (amodio.tsl-problem-matcher, ms-vscode.extension-test-runner, and dbaeumer.vscode-eslint)
+
+
+## Get up and running straight away
+
+* Press `F5` to open a new window with your extension loaded.
+* Run your command from the command palette by pressing (`Ctrl+Shift+P` or `Cmd+Shift+P` on Mac) and typing `Hello World`.
+* Set breakpoints in your code inside `src/extension.ts` to debug your extension.
+* Find output from your extension in the debug console.
+
+## Make changes
+
+* You can relaunch the extension from the debug toolbar after changing code in `src/extension.ts`.
+* You can also reload (`Ctrl+R` or `Cmd+R` on Mac) the VS Code window with your extension to load your changes.
+
+
+## Explore the API
+
+* You can open the full set of our API when you open the file `node_modules/@types/vscode/index.d.ts`.
+
+## Run tests
+
+* Install the [Extension Test Runner](https://marketplace.visualstudio.com/items?itemName=ms-vscode.extension-test-runner)
+* Run the "watch" task via the **Tasks: Run Task** command. Make sure this is running, or tests might not be discovered.
+* Open the Testing view from the activity bar and click the Run Test" button, or use the hotkey `Ctrl/Cmd + ; A`
+* See the output of the test result in the Test Results view.
+* Make changes to `src/test/extension.test.ts` or create new test files inside the `test` folder.
+  * The provided test runner will only consider files matching the name pattern `**.test.ts`.
+  * You can create folders inside the `test` folder to structure your tests any way you want.
+
+## Go further
+
+* Reduce the extension size and improve the startup time by [bundling your extension](https://code.visualstudio.com/api/working-with-extensions/bundling-extension).
+* [Publish your extension](https://code.visualstudio.com/api/working-with-extensions/publishing-extension) on the VS Code extension marketplace.
+* Automate builds by setting up [Continuous Integration](https://code.visualstudio.com/api/working-with-extensions/continuous-integration).

package/webpack.config.js

@@ -0,0 +1,48 @@
+//@ts-check
+
+'use strict';
+
+const path = require('path');
+
+//@ts-check
+/** @typedef {import('webpack').Configuration} WebpackConfig **/
+
+/** @type WebpackConfig */
+const extensionConfig = {
+  target: 'node', // VS Code extensions run in a Node.js-context 📖 -> https://webpack.js.org/configuration/node/
+	mode: 'none', // this leaves the source code as close as possible to the original (when packaging we set this to 'production')
+
+  entry: './src/extension.ts', // the entry point of this extension, 📖 -> https://webpack.js.org/configuration/entry-context/
+  output: {
+    // the bundle is stored in the 'dist' folder (check package.json), 📖 -> https://webpack.js.org/configuration/output/
+    path: path.resolve(__dirname, 'dist'),
+    filename: 'extension.js',
+    libraryTarget: 'commonjs2'
+  },
+  externals: {
+    vscode: 'commonjs vscode' // the vscode-module is created on-the-fly and must be excluded. Add other modules that cannot be webpack'ed, 📖 -> https://webpack.js.org/configuration/externals/
+    // modules added here also need to be added in the .vscodeignore file
+  },
+  resolve: {
+    // support reading TypeScript and JavaScript files, 📖 -> https://github.com/TypeStrong/ts-loader
+    extensions: ['.ts', '.js']
+  },
+  module: {
+    rules: [
+      {
+        test: /\.ts$/,
+        exclude: /node_modules/,
+        use: [
+          {
+            loader: 'ts-loader'
+          }
+        ]
+      }
+    ]
+  },
+  devtool: 'nosources-source-map',
+  infrastructureLogging: {
+    level: "log", // enables logging required for problem matchers
+  },
+};
+module.exports = [ extensionConfig ];