Geht das überhaupt das man ein Array als Variablen Array Namen deklarieren kann ?
Nein.
Da gibt es ja sicher eine Möglichkeit ?
Ja, vewende doch das Array direkt. Weshalb willst du es als String haben?
Wenn dir der verschachtelte Zugriff zu kompliziert ist (was ich verstehen kann 
), bastele dir einfach ein Funktion zum Zugriff auf das interne Array.
Genauer gesagt, sollen im laufenden PSPad verschiedene VBScript-Funktionen von außen per AutoIt aufgerufen werden können, die dann auf interne Informationen von PSPad zugreifen.
Diese Kommunikationsrichtung ist tatsächlich unter den gegebenen Voraussetzungen wohl nicht realisierbar.
Wenn PSPad auf externe Nachrichten reagieren soll, ist das ja nur möglich, wenn intern kontinuierlich irgendein HTTP-Port oder eine Umgebungsvariable oder Event etc. abgefragt wird. Da du sagst, dass das nicht gegeben ist, sehe ich jetzt keinen erfolgversprechenden Ansatzpunkt. Das ist so, als ob du in ein Haus gehen möchtest, aber niemand macht die Tür auf, weil man dein Klingeln nicht hört.
Du kannst doch eigene VBScripte in PSPad ausführen? - Dann solltest du versuchen, ob ein eigener Loop und Event installierbar ist (vielleicht nach diesem Bsp.), wenn der Autor nicht mag.
Bugfix hat vor einigen Jahren ein interessantes Script geschrieben, mit dem man den Inhalt einiger Controls in einer ini-Datei speichern und wiederherstellen kann.
Bist du dir sicher, dass ich das war? Kann ich mich nicht dran erinnern - und ich möchte nicht mit fremden Federn schmücken.
Leider nicht. Wie gesagt, es gibt keine Browser-"Grundlage", somit keine Fenster, somit keine Events.
Somit benötigst du ein eigenes Kommunikations-Interface in PSPad. Ich bin nicht firm in VBScript, somit weiß ich nicht, ob das realisierbar ist.
Grundsätzlich brauchst du nur ein Fenster, das unsichtbar im Hintergrund dümpelt und mit dem du von externen Programmen (AutoIt) Nachrichten empfängst. In SciTE gibt es, wie schon bereits angesprochen, das SciTE Director Interface dafür. Vielleicht kann der Autor von PSPad das ja noch implementieren. Ist kein großes Hexenwerk und m.M. nach ohne große Probleme integrierbar.
Das Fenster für die Kommunikation könnte man mit jeder beliebigen Anwendung erstellen. Aber die Möglichkeit die Nachricht WM_COPYDATA auszuwerten, muss in PSPad implementiert werden.
Zitat von alpinesDa ich persönlich keine Lua-Skripte nutze (und auch keinen Sinn darin sehe)
Dann benutzt du nicht SciTE4AutoIt?
Die gesamte Funktionalität dort wird mit Lua-Skripten realisiert. Bitnugger oder ich nutzen darüber hinaus nur weitere Möglichkeiten. Aber ohne Lua würde SciTE nicht funktionieren.
Hier sind die versteckt:
import winim/[inc\commctrl]
Ja, ich hatte sie schon gefunden. Aber eigentlich gehört das zu wNim. Wegen der paar Konstanten (ganz klar List-Konstanten) mag ich ungern eine extra Bibliothek einbinden. 
So:
Eigentlich seltsam, dass dieser Style nicht im Modul enthalten ist. Ebenso fehlt LVS_EX_TRACKSELECT.
Ich habe mir mal noch 2 Funktionen erstellt um jeweils Spalten und Inhalt in einem Rutsch zu setzen.
import wNim/[wApp, wFrame, wPanel, wListCtrl]
# ------------------------------------------------------------------------------
type
ListHead = tuple[text: string, format: int, width: int]
ListText = seq[string]
proc setListColumns(list: wListCtrl, head: openArray[ListHead]) =
for i in 0..<head.len:
list.appendColumn(text=head[i][0], width=head[i][2])
list.setColumnFormat(i, head[i][1])
proc setListText(list: wListCtrl, stuff: openArray[ListText]) =
var item: int
for i in 0..<stuff.len:
item = list.appendItem(stuff[i][0])
for j in 1..<stuff[i].len:
list.setItem(item, j, stuff[i][j])
# ------------------------------------------------------------------------------
let
app = App()
frame = Frame(title="List Control",size=(600,300))
panel = frame.Panel()
list = panel.ListCtrl(size=(560,240), pos=(10,10), style=wLcReport or wBorderDouble or wLcSingleSel)
list.setExtendedStyle(0x1 or 0x8) # 0x1 LVS_EX_GRIDLINES, 0x8 LVS_EX_TRACKSELECT
list.setListColumns([
("Spalte 1",wListFormatLeft,150),
("Spalte 2",wListFormatCenter,150),
("Spalte 3",wListFormatRight,wListAutosizeUseHeader)])
list.setListText([
@["A","B","C"], @["D","E","F"], @["G","H","I"], @["J","K","L"]])
frame.wIdExit do ():
frame.delete()
frame.center()
frame.show()
app.mainLoop()Um eine variable Anzahl von Elementen an eine Funktion zu übergeben ist (nur als Funktionsparameter) der Datentyp openArray vorhanden.
Im Array bin ich aber grundsätzlich an Daten desselben Typs gebunden.
Um hier flexibel zu sein kann man aber das Array mit Datentypen besetzen, die selbst gemischt sind. Tuple - für eine fixe Anzahl oder Sequencen für veränderliche Anzahl.
Bsp.:
# ------------------------------------------------------------------------------
proc test(oa: openArray[seq[string]]) =
echo "openArray seq[string]: ", $oa
test([@["A","B"],@["C","D"],@["E","F"]])
# ------------------------------------------------------------------------------
# ------------------------------------------------------------------------------
proc test1(oa: openArray[tuple]) =
echo "openArray tuple: ", $oa
test1([("A",100),("C",200),("E",300)])
# ------------------------------------------------------------------------------
# ------------------------------------------------------------------------------
type MyObj = object
name: string
vname: string
alter: int
proc test2(oa: openArray[seq[MyObj]]) =
echo "openArray seq[object]: ", $oa
test2([@[MyObj(name: "Müller",vname: "Bernd",alter: 41)],
@[MyObj(name: "Meier",vname: "Lydia",alter: 28)]])
# ------------------------------------------------------------------------------Gridlines sind in den Styles für das ListCtrl nicht enthalten. Ich habe nun versucht den ExStyle zu setzen:
import winim
SetWindowLongPtr(list.mHwnd, GWL_EXSTYLE, cast[LONG_PTR](LVS_EX_GRIDLINES))Leider ohne Erfolg.
Ideen?
Wenn Du den Mehrspaltenmodus brauchst, dann nur die Imagelist zuweisen und den ImageIndex übergeben.
Danke, manchmal denkt man echt zu kompliziert.
Da man Item im ListCtrl nicht einzeln einfärben kann, wollte ich zumindest über farbige Images in der Spalte 0 Markierungen signalisieren.
Jedoch wird bei Verwendung des Styles: wLcIcon/wLcSmallIcon dann nur die erste Spalte der Liste angezeigt.
Das Bsp. zeigt alle Spalten ohne den Icon-Style. Werden die auskommentierten Zeilen aktiviert und statt dessen die Zeilen mit der # ***** Markierung auskommentiert, ist der IconStyle aktiv und nur die erste Spalte (mit den Images) ist sichtbar. 
Den angehängten Ordner mit den Images runterladen und imgPath entsprechend anpassen.
import wNim/[wApp, wFrame, wPanel, wListCtrl, wImageList, wBitmap]
import os
let
imgPath = r"C:\CODE\nim\_myExamples_\bmp_pur_16x16" # PFAD ANPASSEN !!!
app = App()
frame = Frame(title="Test ImageList",size=(600,300))
panel = frame.Panel()
# list = panel.ListCtrl(size=(560,240), pos=(10,10), style=wLcReport or wBorderDouble or wLcSingleSel or wLcSmallIcon)
list = panel.ListCtrl(size=(560,240), pos=(10,10), style=wLcReport or wBorderDouble or wLcSingleSel) # *****
var il = ImageList(size=(16,16), mask=false, initialCount=0)
il.add(Bitmap(joinPath(imgPath, "green.bmp")))
il.add(Bitmap(joinPath(imgPath, "red.bmp")))
# list.setImageList(il)
list.appendColumn(text="Column 0", width=150)
list.setColumnFormat(0, wListFormatLeft)
list.appendColumn(text="Column 1", width=110, format=wListFormatRight)
list.appendColumn(text="Column 2", width=110, format=wListFormatRight)
list.appendColumn(text="Column 3", width=wListAutosizeUseHeader)
var imgIndex: int
for i in 0..10:
if (i mod 2) == 0: imgIndex = 0 else: imgIndex = 1
# list.appendItem([$i&"-0", $i&"-1", $i&"-2", $i&"-3"], imgIndex)
list.appendItem([$i&"-0", $i&"-1", $i&"-2", $i&"-3"]) # *****
frame.wIdExit do ():
frame.delete()
frame.center()
frame.show()
app.mainLoop()Fehler bei mir oder muss das so?
Und eines ist mir noch aufgefallen:
Die Header werden sinnloser Weise genauso ausgerichtet, wie die Item. Habt ihr da schon eine Lösung für?
Bsp. für Einlesen einer JSON Datei.
Verwendet wird die "\.nimble\packages_official.json", die auf jeden Fall bei allen vorhanden ist.
import os, json, tables
type
PkgJson = object # Objekttyp zum Aufnehmen der JSON Daten
name: string
url: string
methode: string # in JSON Datei wird "method" verwendet, !Keyword!
tags: seq[string] # JArray muss vor Eintrag in Objekt portiert werden
description: string
license: string
web: string
doc: string
# Der Objekttyp muss die Daten der JSON Datei exakt abbilden! Optionale Item
# sind mittels try-except abzufangen
# Pfad der JSON Datei
let fjson = getEnv("HOMEDRIVE") & getEnv("HOMEPATH") &
r"\.nimble\packages_official.json"
# ------------------------------------------------------------------------------
proc jsonToObject(jFile: string): Table[string, PkgJson] =
# alle JSON Item in Objekte überführen
# ----------------------------------------------------------------------------
# Funktionen zum Auslesen der einzelnen Item-Daten
# ----------------------------------------------------------------------------
proc getItemJson(jni: JsonNode, name: string, ): string =
try:
result = jni[name].str
except KeyError:
result = "NONE " & name
# ----------------------------------------------------------------------------
proc getItemJsonSeq(jni: JsonNode, name: string, ): seq[string] =
var jnin: JsonNode
try:
jnin = jni[name]
for jnmi in jnin.mitems(): result.add(jnmi.str)
except KeyError:
result.add("NONE " & name)
except AssertionError:
result.add(name & ": OBJECT")
# ----------------------------------------------------------------------------
var pkgs = initTable[string, PkgJson]()
let jn = jFile.parseFile() # Einlesen der JSON Datei
var jo: PkgJson # Variable für Erstellung des Item-Objektes
for ji in jn.items(): # iterieren über alle Item
jo = PkgJson( # alle Itemfelder dem JSON-Objekt zuweisen
name: ji.getItemJson("name"),
url: ji.getItemJson("url"),
methode: ji.getItemJson("method"),
tags: ji.getItemJsonSeq("tags"),
description: ji.getItemJson("description"),
license: ji.getItemJson("license"),
web: ji.getItemJson("web"),
doc: ji.getItemJson("doc"))
pkgs[jo.name] = jo # Item-Objekt dem Table zuweisen
result = pkgs
# ------------------------------------------------------------------------------
# Table der JSON Objekte. Alle Item sind einmalig, Zugriff somit möglich mit:
# packages["Package-Name"].Feld
var packages = fjson.jsonToObject()
echo "Tags numnim: ", packages["numnim"].tags
echo "Description wNim: ", packages["wNim"].descriptionIch habe im Startpost eine weitere Version gepostet, die alle installierten Versionen eines Paketes mit auflistet.
Da stimmt etwas nicht bei nimgen... die 0.5.2 sollte dann ja eigentlich von nimble gefunden werden? Ein refresh hatte ich zuvor gemacht.
"Sollte" ist hier das richtige Wort.
Refresh hat damit aber m.M.n. nichts zu tun, das ist wohl eher in der Search-Funktion begründet. Diese sollte eigentlich genauso vorgehen, wie ich in meinem Update-Check:
- Repo url des benannten Pakets abfragen
- dort aus "Paketname.nimble" die aktuelle Versionsnummer lesen
Dabei hakt es wohl. - Gut, dass ich meinen Update Checker erstellt habe, der machts richtig. 
Da ich meine Module ausschließlich händisch verwalte, habe ich mir jetzt zumindest eine Routine zum Prüfen aller Packages auf vorhandene Updates erstellt.
EDIT 31.01.22
Die Ursache der Nicht-Erreichbarkeit der Seite:
Von 12 Packages verlinken 11 mit "../raw/master/.." auf die *.nimble (dort ist die Versionsnummer auslesbar). Aber 1 Package verwendet stattdessen: "../raw/main/..". Da hatte ich dann mit einer nicht existenten Adresse versucht zuzugreifen - deshalb HTTP-Error. 
Jetzt verwende ich "master", gibt das Fehler probiere ich "main" und sollte auch das fehlschlagen wird Online-Version=0 gesetzt, was dann bedeutet: Seite falsch/nicht erreichbar.
Ich habe das Programm überarbeitet und leite die nimble-Aufrufe in eine Tmp-Datei, die ich dann auswerte.
Vorerst habe ich nur die Kommandozeilen-Version geändert. Hinzugekommen sind dort Aufrufparameter:
"list" Listet alle lokalen Packages formatiert auf.
"check" Wie "list", zusätzlich mit online verfügbarer Version.
Wobei bemerkt werden muss: Update gibt es nicht wirklich in nimble, genau sowenig, wie eine Online-Versionsabfrage. Es gibt zwar die Möglichkeit mit Flag --ver danach zu fragen - in den Repos nutzt aber niemand diesen Parameter, sodass kein Ergebnis verfügbar ist.
Zum Updaten muss also der Install-Befehl genutzt werden. Führt man Install aus, obwohl keine neuere als die installierte Version vorhanden ist, wird nachgefragt ob die lokale Version überschrieben werden soll.
Programmname jetzt: nimble_up_check_cmd.nim
Ich werde es dann später noch in die GUI-Version integrieren.
EDIT 26.01.2022
Ich habe hierfür jetzt auch eine Lösung mit GUI erstellt:
PS: Habe gerade aktualisiert und festgestellt, dass bei den mit installierten Dependencies wohl ungültige/anders dargestellte url hinterlegt sind. Dadurch crasht das Programm bei erneutem Aufruf.
Da muss ich noch mal ran. EDIT: Die Seite ist einfach nicht erreichbar, Fehlerabfrage jetzt integriert.
# compile: nim c --define:ssl --app:gui nimble_up_check_gui.nim
import os, strutils, re, httpClient, json
import wNim/[wApp, wFrame, wPanel, wButton, wTextCtrl, wListCtrl, wImageList,
wCheckBox, wBrush, wBitmap, wIcon, wMemoryDC]
let pkgsPath = getEnv("HOMEDRIVE") & getEnv("HOMEPATH") & r"\.nimble\pkgs"
type
Packages = tuple
path: string
name: string
version: string
PkgsHighest = object
name: string # package name
versions: seq[string] # all installed version numbers
version: string # highest version number
path: string # installation directory
repo: string # url of the repository
url: string # url of ".../raw/master/PACKAGE.nimble"
versionOnline: string # version number from current repository
newup: bool # indicates that a higher version is available
ListHead = tuple[text: string, format: int, width: int]
var
pkgsAll: seq[Packages] # all packages in all versions
pkgsTmp: seq[string] # temporary only unique package names
pkgsHigh: seq[PkgsHighest] # packages with highest version number
client = newHttpClient() # client for online version request
# ------------------------------------------------------------------------------
proc pkg(path, get: string): string =
# gets from package folder the name and version
let tsplit = path.splitPath().tail.split('-')
case get
of "name": result = tsplit[0]
of "version": result = tsplit[1]
proc getUrl(path: string): string =
# reads from package folder the meta file and extracts the repository-url
let
jsonFile = joinPath(path, "nimblemeta.json")
jn = jsonFile.parseFile()
result = jn["url"].str
proc getOnlineVersion(url: string): string =
# reads from repository the "package-name.nimble" and extracts the version
try:
let patt = re(r"version\s+=\s\x22([^\x22]+)", {reIgnoreCase,reMultiLine})
var
match: seq[string]
readNimble: string
try:
readNimble = client.getContent(url)
match = re.findAll(readNimble, patt)
except:
return "HTTP REQUEST ERROR"
if match.len > 0:
var
line = match[0]
pos = line.find('"')
ver = line[pos+1..line.len-1]
return ver
else: return "0" # can't read version number
except OSError:
return "CONNECTION ERROR"
# ------------------------------------------------------------------------------
# ------------------------------------------------------------------------------
proc getAllPkgInfo() =
# comparable to "nimble list -i", all versions
for kind, path in walkDir(pkgsPath):
if kind == pcDir:
pkgsAll.add((path: path, name: path.pkg("name"),
version: path.pkg("version")))
else: discard
# filter highest versions
# 1. write unique package names in temporary sequence
for e in pkgsAll:
if not (e.name in pkgsTmp): pkgsTmp.add(e.name)
else: discard
# 2. for each package name search highest version
# store all version numbers
var
v, p: string
h: seq[string]
for n in pkgsTmp:
v = ""
p = ""
h = newSeq[string]()
for i in 0..pkgsAll.len - 1:
if pkgsAll[i].name == n:
if pkgsAll[i].version > v:
v = pkgsAll[i].version
p = pkgsAll[i].path
h.add(pkgsAll[i].version)
else: discard
pkgsHigh.add(PkgsHighest(name: n, versions: h, version: v, path: p))
# ------------------------------------------------------------------------------
# ------------------------------------------------------------------------------
# GUI #
# ------------------------------------------------------------------------------
# ------------------------------------------------------------------------------
proc setListColumns(list: wListCtrl, head: openArray[ListHead]) =
for i in 0..<head.len:
list.appendColumn(text=head[i][0], width=head[i][2])
list.setColumnFormat(i, head[i][1])
# ------------------------------------------------------------------------------
let
app = App()
frame = Frame(title="Nimble - Package Viewer",size=(620,400))
panel = frame.Panel()
button = panel.Button(label="Check Online Version")
list = panel.ListCtrl(style=wLcReport or wBorderDouble or wLcSingleSel)
var
il = ImageList(size=(16,16), mask=false, initialCount=0)
dc = MemoryDC()
bmp = Bitmap(16, 16)
dc.selectObject(bmp)
dc.clear(Brush(wGreenBrush))
let icoGreen = Icon(bmp)
dc.clear(Brush(wRedBrush))
let icoRed = Icon(bmp)
dc.clear(Brush(color=wYellow))
let icoYellow = Icon(bmp)
il.add(icoYellow) # 0
il.add(icoGreen) # 1
il.add(icoRed) # 2
list.setExtendedStyle(0x1)
list.setImageList(il)
list.setListColumns([
("Package", wListFormatLeft, 130),
("Current", wListFormatCenter, 80),
("Online", wListFormatCenter, 160),
("Installed", wListFormatLeft, wListAutosizeUseHeader)])
proc insertInstalled() =
getAllPkgInfo()
let imgIndex = 0
var item: int
for i in 0..pkgsHigh.len - 1:
item = list.appendItem([pkgsHigh[i].name, pkgsHigh[i].version,
"", $pkgsHigh[i].versions], imgIndex)
proc insertOnline() =
# read out repository url, change to "../raw/...nimble"
# ask for online version number
var
u: string
imgIndex, item: int
for i in 0..pkgsHigh.len - 1:
u = pkgsHigh[i].path.getUrl()
pkgsHigh[i].repo = u
if u[u.len-4..u.len-1] in [".git", ".nim"]: u = u[0..u.len-5] # remove file suffix if any
pkgsHigh[i].url = u & "/raw/master/" & pkgsHigh[i].name & ".nimble"
pkgsHigh[i].versionOnline = pkgsHigh[i].url.getOnlineVersion()
if (pkgsHigh[i].versionOnline > pkgsHigh[i].version):
pkgsHigh[i].newup = true
imgIndex = 2 # red
else:
pkgsHigh[i].newup = false
imgIndex = 1 # green
# to avoid failure by possible different sorting search item
item = list.findItem(pkgsHigh[i].name)
# insert online version number and change image color
list.setItemText(item, 2, pkgsHigh[i].versionOnline)
list.setItemImage(item, 0, imgIndex)
proc layout() =
panel.layout:
button:
top = panel.top + 10
right = panel.right - 15
height = bestHeight
width = bestWidth
list:
top = button.bottom + 10
left = panel.left + 15
bottom = panel.bottom - 15
width = panel.width - 30
panel.wEvent_Size do ():
layout()
button.wEvent_Button do ():
insertOnline()
frame.wIdExit do ():
frame.delete()
insertInstalled()
layout()
frame.setMinSize((620,400))
frame.center()
frame.show()
app.mainLoop()nimble_up_check_gui_0.pngnimble_up_check_gui.pngnimble_up_check_gui_1.png
# compile: nim c -d:ssl nimble_up_check_cmd.nim
import os, strutils, re, httpClient, strformat
let params = commandLineParams()
type
Packages = tuple
name: string # name of the package
versions: string # installed versions
verhigh: string # highest version (current)
repo: string # repository url
veronline: string # package-name.nimble url
bupdate: bool # true: newer version online, needs update
# Extract infos about all installed packages
# ------------------------------------------------------------------------------
proc pkgsInstalled(): seq[Packages] =
let tmpfile = os.getHomeDir() & "nimbledump.txt"
# tmpfile maybe exist - delete it
discard execShellCmd("DEL " & tmpfile)
# write installed pkgs into tmpfile
discard execShellCmd("nimble list -i >>" & tmpfile)
let f = tmpfile.open(fmRead)
var
line, name, ver, vhigh: string
smatch: seq[string]
pkgs: seq[Packages]
while f.readLine(line):
smatch = line.findAll(re(r"\w+")) # name
if smatch.len > 0: name = smatch[0]
smatch = line.findAll(re(r"\[.+\]")) # versions
if smatch.len > 0: ver = smatch[0]
smatch = line.findAll(re(r"\d+[\.\d]+\]$"))
if smatch.len > 0:
vhigh = smatch[0] # highest version
vhigh.delete(vhigh.len - 1, vhigh.len)
pkgs.add((name, ver, vhigh, "", "", false))
f.close()
result = pkgs
# ------------------------------------------------------------------------------
# Search for each installed package the repo url,
# read from this repo the *.nimble file and extract the version info
# ------------------------------------------------------------------------------
proc getOnlineVersion(): seq[Packages] =
let
client = newHttpClient()
tmpfile = os.getHomeDir() & "nimbledump.txt"
patt = re(r"version\s+=\s""([^""]+)""", {reIgnoreCase, reMultiLine})
var
pkgs = pkgsInstalled()
smatch: seq[string]
readNimble, rawurl: string
for i in 0..pkgs.len - 1:
discard execShellCmd("DEL " & tmpfile)
discard execShellCmd("nimble search " & pkgs[i].name & " >>" & tmpfile)
smatch = tmpfile.readFile().findAll(re(r"url:\s+\S+" & pkgs[i].name & r"\S*", {reIgnoreCase,reMultiLine}))
if smatch.len > 0:
smatch = smatch[0].findAll(re(r"https://\S+"))
pkgs[i].repo = smatch[0]
# reads "/raw/master/package-name.nimble" and extracts the version number
# maybe "/raw/main/...."
rawurl = pkgs[i].repo & "/raw/master/" & pkgs[i].name & ".nimble"
try:
readNimble = client.getContent(rawurl)
except:
rawurl = pkgs[i].repo & "/raw/main/" & pkgs[i].name & ".nimble"
try:
readNimble = client.getContent(rawurl)
except:
pkgs[i].veronline = "0"
smatch = re.findAll(readNimble, patt)
if smatch.len > 0:
pkgs[i].veronline = (smatch[0])[smatch[0].find('"')+1..smatch[0].len-2]
else: pkgs[i].veronline = "0"
pkgs[i].bupdate = (pkgs[i].veronline > pkgs[i].verhigh)
result = pkgs
# ------------------------------------------------------------------------------
# Get informations about all installed packages and [optional]
# installs newer version, if exists.
# i.e.:
# memlib [OK] current: 1.2.0 online: 1.2.0 installed: [1.2.0]
# minhook [OK] current: 1.0.0 online: 1.0.0 installed: [1.0.0]
#
# All packages are up to date.
# ------------------------------------------------------------------------------
proc outputPkgInfo(bup: bool=false) =
# collect all information
let pkgs = getOnlineVersion()
var needUp, output: string
var cmdUpdate, outputUp: string
for i in 0..pkgs.len - 1:
if pkgs[i].bupdate:
needUp = "[NEW!]"
cmdUpdate &= pkgs[i].name & ","
else:
needUp = "[OK]"
output &= fmt"{pkgs[i].name:<20}{needUp:<8}current:{pkgs[i].verhigh:>8} online:{pkgs[i].veronline:>8} installed: {$pkgs[i].versions}{'\n'}"
if cmdUpdate.len > 0:
outputUp = "Package Update:\n" & cmdUpdate[0..cmdUpdate.len-2] & "\n"
cmdUpdate = "nimble install " & cmdUpdate[0..cmdUpdate.len-2]
else: outputUp = "All packages are up to date."
echo output
if bup:
echo outputUp
if cmdUpdate != "": discard execShellCmd(cmdUpdate) else: discard
else: discard
# ------------------------------------------------------------------------------
# Outputs informations about installed packages, from "nimble list -i", but formatted.
# ------------------------------------------------------------------------------
proc outputLocal() {.discardable.} =
let pkgs = pkgsInstalled()
var output: string
for i in 0..pkgs.len - 1:
output &= fmt"{pkgs[i].name:<20} current:{pkgs[i].verhigh:>8} installed: {$pkgs[i].versions}{'\n'}"
echo output
# ------------------------------------------------------------------------------
if params.len > 0:
for i in 0..params.len - 1:
if params[i] == "help": echo "Available:\n" & "\"list\" Gets a list with local packages.\n\"check\" Gets a list with package informations local and online.\n\"update\" Retrieves the same list and, if newer versions are online: Installs them."
elif params[i] == "list": outputLocal()
elif params[i] == "check": outputPkgInfo()
elif params[i] == "update": outputPkgInfo(true)
else: echo "Wrong parameter! Use \"help\" to see available params."
else:
echo "No Params passed. List all installed packages."
outputPkgInfo()So schauts dann aus:
Der Grund für die fehlenden Erweiterungen:
OK, Danke für deine Bemühungen. Ich hatte bisher noch keine Probleme, aber nun ist man gewappnet.
Nur bei der Erstinstallation (1.44.2), alle weiteren Versionen (1.48.2, 1.49.0) mit scoop update vscodium.
Das ist auch OK, genauso mache ich es auch.
Die aktuelle Version:
Version: 1.49.0
Commit: e790b931385d72cf5669fcefc51cdf65990efa5d
Datum: 2020-09-11T10:41:02.560Z
Electron: 9.2.1
Chrome: 83.0.4103.122
Node.js: 12.14.1
V8: 8.3.110.13-electron.0
Betriebssystem: Windows_NT x64 6.1.7601So lief das Update bei mir (gerade ausgeführt):
Notfalls kannst du ja erst mal auf die vorige Version zurückgreifen.
Die neueste Version ist immer unter demselben Pfad: C:\Users\USER\scoop\apps\vscodium\current\VSCodium.exe zu finden und ist ein Link auf die jeweils höchste Installationsnummer.
Der reale Pfad dahinter ist also (bei v1.49.0): C:\Users\USER\scoop\apps\vscodium\1.49.0\VSCodium.exe
Wenn du dir einen Link auf C:\Users\USER\scoop\apps\vscodium\1.44.2\VSCodium.exe setzt, solltest du zumindest mit der vorigen Version problemlos arbeiten können. Da scoop alle Dateien ausschliesslich in seinem Unterordner apps ablegt, hast du hier auch keine Probleme mit irgendwelchen Abhängigkeiten.
Aber den Monat solltest Du schon testen,
Die Variante gefällt mir.
Naja, Du testest ja auch nur den Tag, aber mit getDaysInMonth geht's wirklich kürzer
Obs ein Schaltjahr ist, prüft getDaysInMonth bereits. Und alle anderen Prüfungen der Jahreszahlen sind m. M. nach Humbug. In der Historie ist nicht wirklich bekannt wer wann und wo welchen Kalender genutzt hat und wann "die Zeit des Jahreszählens" begann. Wer weiß, vielleicht hatte ja einer meiner Ur-Ur-Ahnen eines Tages den Gedanken und sagte: "He Leute, ich hab eine brilliante Idee - wir zählen ab heute die Zeit und jetzt ist das Jahr Nummer 1."
Und für die ferne Zukunft ist es auch völlig schnuppe, ob es vielleicht in 3000 Jahren zu einer Schaltjahresverschiebung kommt oder nicht.
Insofern kann jede Jahreszahl als valide angenommen werden. Tut keinem weh. 
Hm, color.argb = 0x7FFFFFFF geht noch, 0x80000000 nicht mehr
Schau mal hier Bug in Nim: Wertebereich bei 32Bit Integer