« first day (2189 days earlier)      last day (991 days later) » 

Duga
Duga
12:01 AM
RELOAD!
[rubberduck-vba/Rubberduck] 1 opened issue.
[rubberduck-vba/RubberduckWeb] 1 opened issue. 1 issue comment.
[Zomis/Games] 6 commits. 2 opened issues. 4 issue comments. 913 additions. 169 deletions.
[Minesweeper] Games Played: 131, Bombs Used: 68, Moves Performed: 17183, New Users: 9
 
 
3 hours later…
Mathieu Guindon
Mathieu Guindon
3:28 AM
@IvenBach not yet... that would be the next major upgrade to RD testing
exactly how to have the user supply the parameters is still vaguely defined IIRC
 
IvenBach
IvenBach
I really look forward to that. That will simplify one section of my integrations tests checking if a named range exists.
 
Mathieu Guindon
Mathieu Guindon
we were looking into adding an annotation to supply the parameters, @TestCase if I had to guess
needs tweaks to the test discovery and execution loop logic
hm maybe not discovery, just the execution loop
 
IvenBach
IvenBach
Like how the TestAttribute is in .NET?
 
 
3 hours later…
M.Doerner
M.Doerner
7:05 AM
More precisely, like the TestCase attribute of NUnit.
 
 
2 hours later…
Duga
Duga
9:23 AM
> **Justification**
While working I quite often drag and drop by accident and it just wastes time.

**Description**
So I am not entirely sure why I do this, if it is because the UI is just laggy enough or it doesn't always register mouse up before I have moved, or if I am just a sloppy mouse user. Regardless the result is that I have to undo that operation when I do it by mistake.

There are a few number of ways to fix this that I can think of:
* Add an option to simply disable drag and d
 
Duga
Duga
10:20 AM
 
Duga
Duga
10:50 AM
> What is it that you're dragging and dropping - is it something in the RD environment or something native to the VBIDE?
> Oh sorry, should have clarified. Dragging and dropping folders and modules in the Code Explorer with the new drag and drop feature introduced somewhat recently.
 
 
5 hours later…
Duga
Duga
3:34 PM
> **Rubberduck version information**
Version 2.5.0.5457
OS: Microsoft Windows NT 10.0.18362.0, x64
Host Product: Microsoft Office x86
Host Version: 16.0.12730.20270
Host Executable: EXCEL.EXE

**Description**
After adding a User Form to Personal.xlsb RD has a Parse Error.

**To Reproduce**
Steps to reproduce the behavior (assuming it can be reproduced):
1. Add a new UserForm via RD CE>Add>UserForm to Personal.xlsb
2. See Parse Fail with Personal.UserForm1 in banner

**Expected be
> Removed the UserForm and any use of it in code. Parse still fails. Closing this for now because it is likely related to something else.
> My bad. Part of another loaded project failed to compile; hence the Parse Error.
 
 
1 hour later…
Mathieu Guindon
Mathieu Guindon
5:16 PM
so, y'all learned Stack Exchange markdown now and are familiar with it?
225
Q: We're switching to CommonMark

Ham VockeI’m Ham and I’m a developer on the Teams team here at Stack Overflow. Over the past few months, I’ve been heads down working on the way we turn Markdown into HTML when writing and editing posts across the network. I’d love to share what I’ve come up with. In a nutshell: We’re planning to use Com...

discussion featured markdown announcements
 
Vogel612
Vogel612
I'm kinda miffed that this will break headers working the way I'm used to
but eh, can't do much against that and it's really necessary they make that dependency external
basically a tech-debt payment that's been overdue for a few years now
 
mansellan
mansellan
So I'm finding some interesting things in my research into VBA internals
The notion that editor code is converted into p-code every time you press enter on a line is not quite accurate
It seems there's a couple of different encodings going on
First up is an "editor format" encoding, which is what pcodedmp decodes. It's quite close to source, with most of the opcodes mapping 1:1 with VB keywords. Literals are extracted and stored in a mapping table to save space.
It has about 260 opcodes
 
Vogel612
Vogel612
wow that's a LOT
 
mansellan
mansellan
Then there's the actual p-code, which gets created when you compile. It represents the actual instructions for the VB VM, and I think is what bontchev has called "execode". IIUC, that's the only thing that that "VB Obfuscator" thing leaves in place.
The VBE cannot roundtrip actual pcode back to source (I haven't found anything that can yet, other than Wayne's recovery service)
It has 1159 opcodes in VB6, although many are duplicates
Still chasing pointers though to try and find where it all is in mem.
@Vogel612 Tbf it's not just encoding VB keywords, but also operators, some "built-in" functions, and some ops for variable handling.
example form pcodedmp's readme: 
Private Sub Document_Open()
    MsgBox "This could have been a virus!", vbOKOnly + vbInformation, "Virus!"
    Shell("calc.exe")
End Sub
tranlsates in editor format to: 
Line #0:
        FuncDefn (Private Sub Document_Open())
Line #1:
        LitStr 0x001D "This could have been a virus!"
        Ld vbOKOnly
        Ld vbInformation
        Add
        LitStr 0x0006 "Virus!"
        ArgsCall MsgBox 0x0003
Line #2:
        LitStr 0x0008 "calc.exe"
        Paren
        ArgsCall Shell 0x0001
Line #3:
        EndSub
 
M.Doerner
M.Doerner
5:45 PM
Didn't somebody post a link here ages ago where somebody explained that the VBA compilation is seven levels deep?
 
mansellan
mansellan
lol I can well believe it!
 
M.Doerner
M.Doerner
I recall that it was one of those ancient websites with the horrible 90s style.
 
mansellan
mansellan
I know that VB6 has a "second stage compiler" called C2.EXE that takes intermediate files from the built-in stage 1 compiler and does futher stuff. Yet to investigate that.
It's possible it's responsible for pcode -> native, but at this point that's just a guess.
 
Mathieu Guindon
Mathieu Guindon
@mansellan wow, nice findings!
 
mansellan
mansellan
peeking behind the curtain ;-)
 
Mathieu Guindon
Mathieu Guindon
5:54 PM
@mansellan and that's why "" is only taking up 2 bytes, as opposed to 2 bytes everywhere it shows up - IIRC .NET 1.1 wasn't going that
 
mansellan
mansellan
the editor format is kinda VB's "grammar" (at least, that's how I'm mentally modelling it atm...)
@MathieuGuindon Yep, literals get de-duped.
 
this
this
though, passing "" into an API could result in some interesting firework or at least an unexpected result.
So arguing that "" shouldn't be used because it wastes space will ring hollow but consistently representing a empty string with a null pointer is a more compelling case.
 
Mathieu Guindon
Mathieu Guindon
tbh both "" and vbNullString have their drawbacks and gotchas
 
this
this
yeah you're right. I remembered just now there's some weird API where it will blow up with a vbNullString but is A-OK with "", go figure.
"Let's play empty-string-jack. Hit or stand?"
 
Mathieu Guindon
Mathieu Guindon
lol
DOUBLE DOWN
 
mansellan
mansellan
6:01 PM
I also found out why some objects like Screen are special little soldiers. There's a flag in the VBHeader that tells the runtime to initialise them automagically.
"MDL Internal Object flags"
 
Vogel612
Vogel612
how about char* = [ NUL ];?
 
mansellan
mansellan
Hmm... I see that the other project has recently incorporated pcodedmp
 
Mathieu Guindon
Mathieu Guindon
ha!
notices they're a full 100 stars ahead now
 
mansellan
mansellan
for now <--- FTFY
:-)
 
Mathieu Guindon
Mathieu Guindon
=)
 
mansellan
mansellan
6:09 PM
anyway, chores. bbl
 
Mathieu Guindon
Mathieu Guindon
7:04 PM
wow the donations keep coming, $5 here, $10 there, EUR, AUD, CAD, USD, ...it's beautiful. I need to get the receipts and add things up, but if 2020 hosting isn't covered, it's sure getting close!
5
 
BigBen
BigBen
7:36 PM
Random question on formatting: 
Public Sub SomeReallyLongProcedureName(ByVal argumentOne As Long, ByVal argumentTwo As Worksheet)

End Sub
when a procedure declaration gets too long, how do you prefer breaking it into multiple lines?
 
M.Doerner
M.Doerner
Public Sub SomeReallyLongProcedureName( _
    ByVal argumentOne As Long, _
    ByVal argumentTwo As Worksheet _
)

End Sub
That is my approach.
 
BigBen
BigBen
that seems to be the best, yeah
and when calling SomeReallyLongProcedure, then follow the same approach and put the arguments on separate lines
 
M.Doerner
M.Doerner
I like to put the closing parenthesis on a new line because that separates the indentation from that of the body.
 
BigBen
BigBen
yep, good point
thanks!
(this beautifies a code block that was starting to get ugly)
 
Mathieu Guindon
Mathieu Guindon
would be nice if the indenter could do that!
 
this
this
7:50 PM
I do the same thing that Max does, FWIW.
 
BigBen
BigBen
it would definitely be nice if the indenter could do that yeah
 
this
this
^
 
Duga
Duga
> I would like to close this PR in order to split and resubmit the functionality with two PRs.

1. A `ConflictDetectionSession` PR. This would propose the `ConflictDetectionSession` capability and the associated removal of conflict detection code in the `DeclarationFinder`.
2. The current `MoveMember` PR would be then re-submitted after modified with the outcomes of the `ConflictDetectionSession` PR and PR #5452.

I am hoping that this is a better approach. And, will make the review proc
> **Rubberduck version information**
Version 2.5.0.20863
OS: Microsoft Windows NT 10.0.18362.0, x64
Host Product: Microsoft Office 2016 x64
Host Version: 16.0.4978.1000
Host Executable: EXCEL.EXE

**Description**
Root cause is unknown. Intermittent as to when it shows. Started getting this unhandled exception after adding a lot of properties to a worksheet and unit tests.

**To Reproduce**
---Steps to reproduce the behavior:--- Will document if problem perists and can determine cause.
 
mansellan
mansellan
8:14 PM
btw, I thought of a decent use-case for understanding the VBA internal memory layout. With full comprehension, it should be possible to provide an explorer for breakpoints and bookmarks, the absence of which is often lameted on the internets.
And less easily, save / restore across sessions (restore could be a problem, don't really want to be writing to the same memory as the VBE...)
"With full comprehension" <--- HHCIB, right ;-)
 
Duga
Duga
 
Mathieu Guindon
Mathieu Guindon
@mansellan that would be amazing
 
mansellan
mansellan
@MathieuGuindon Whether or not the pointer trail for that can be found is very debateable...
But I plan to try :-)
 
this
this
@mansellan search the chat for Thunderframe's comment about finding the pointer via project explorer
 
mansellan
mansellan
@this ah ok, will do!
 
this
this
8:24 PM
typelib api does something similar but via References rather than project explorer
 
mansellan
mansellan
yeah typelib is kinda what got me thinking about all this
Bah, forgotten where I saved the VBA SDK, and it seems to have vanished from my MSDN subscription :-(
oops scratch that, it's under downloads in MSDN not product keys
 
Feeds
Feeds
 
mansellan
mansellan
random aside. There's VBA3, 5, 6, 7... wonder what happened to 1, 2 and 4 :-)
 
this
this
I think they were simply too short-lived
you know, like Windows 95
 
mansellan
mansellan
lol
huh, MSDN has v6.4 of the VBA SDK. Not seen that before, only 6.3...
 
Duga
Duga
8:31 PM
> The root cause of this issue seems to be the virtualization applied to the TestGrid having a bug in the height-calculation.

As it is currently, our code is only adding a new item to a collection [here](https://github.com/rubberduck-vba/Rubberduck/blob/37bd1bb1276854b0757e6a300e5845fc8d941ff2/Rubberduck.Core/UI/UnitTesting/TestExplorerModel.cs#L230). This triggers the insertion of a new row into the GroupingGrid's underlying ListView, where the VirtualizingStackPanel seems to break upon reca
 
mansellan
mansellan
@mansellan Interesting... the installer offers to install the debug version...
 
Vogel612
Vogel612
Poke @IvenBach I think I have a way to narrow down the repro, see above comment on the issue
 
this
this
@mansellan wasn't the 6.4 the one that purported to release a MT version of VB?
 
mansellan
mansellan
@this no, i've seen that before in 6.3
6.4 seems to include a lot more sample apps
heh, none of which are happy to run on win10 :-)
 
mansellan
mansellan
9:13 PM
wonders why a 20 year old sample VBA SDK app would be loading .Net modules - ah yes, it has RD running inside of it :-)
 

« first day (2189 days earlier)      last day (991 days later) »