RELOAD!

[FreezePhoenix/Angels-And-Demons] 1 commit. 247 additions. 40688 deletions.

[FreezePhoenix/XtraUtils] 2 commits. 2732 additions. 374 deletions.

[rubberduck-vba/Rubberduck] 2 opened issues. 12 issue comments.

#TIL Insert>Procedure>Type: Property

Wish I knew about that years ago :sadface:

@this thanks, I'll have a play with that. What happens if code is Ended without the value releasing?

Home Time.

@ThunderFrame You'd have springed a leak.

Thought so. A leaky vault.

that's what you get for playing outside the VB sandbox.

pretty sure it won't go away until you shut down the host and you can't deallocate if you lose the address.

Which OleWoo fork do you use? leibnitz27/olewoo or ydanila/OleWoo?

leibnitz27

that's the original author

note that the version we are using for our build is further downstream, though. There's an open PR currently.

@this is it effectively doing the same thing as .NET's SecureString?

@this oh, it seemed like ydanila was the original, and leibnitz27 was the forker

@ThunderFrame Not sure about the internal implementation of SecureString, but functionally, it should be the same -- no unwanted access from outside the environment. Meaning that if you tried to do a memory dump, you wouldn't be able to read it. Only in-process code can do that (and only after having made the necessary changes to locks). Note that's a different thing from encryption.

@ThunderFrame yeah I had to do my research first to make sure I forked off the author.

I still don't understand how @CallumDA was able to access an instance using the class name as if it were predeclared. Maybe someone wrote a really weird VBE rootkit that makes all of your class modules predeclared.

it might be that he declared a variable Dim class1 As class1

Was #4091 the first issue opened for COM collector issues?

@Comintern there have been a few dupes, but that's the main one. I think there's. A linked issue there too.

OK, that'll be a good start.

Assuming that I didn't just screw up my VS2017 install... Grrrrrr

@Comintern I think you need a certain release/update level, but if you downloaded latest, you should be OK.

Yeah, I had apparently installed it at some point, but the updater just failed.

If it were up to @Hosch250 we'd all be running VS 2019 Alpha.

this may be relevant: 4045 and 3995

I think #4174 might also be a dup based on the log file.

@Comintern needs food, badly.

@Comintern I deduced the other day, and Wayne confirmed, that certain Functions (like Array, Left$ and Left) and statements (like Mid and `Mid$) have internal, optimized implementations, so the like-named counterparts in the VBA library are only called if you qualify them with the library name.

In most cases, there's no difference, other than speed optimizations, with the exception of Array and VBA.Array, where the default lower bound differs according to the qualification, and your Option Base settings. I have a list somewhere, of the functions I suspect are internal (as they all show up in the identifiers table for an otherwise blank project)

I wonder whether we should let the resolver distinguish between internal and VBA usages

@ThunderFrame Interesting... I knew there were multiple entry points for them in the the vbe dll. So they're handled entirely outside of the library?

^ this suggests to me that those simply get inlined.

#ReadFail, right above that quote, Wayne does say they get inlined, so yeah.

@Comintern it's one of the reasons you get a compile/syntax error if you try using CLng on LHS as CLng 1, but not as VBA.CLng 1

LBound and UBound are trivial with SafeArrays - they're literally stored in the struct.

Means hooking them is probably out of the question...

Although why you would ever need to spoof a UBound call is beyond me ATM.

@this I'm resuming work on test-friendly block completion. I'm merging #4153

go for it. I'm a bit fuzzy how we will further refactor it anyway.

:+1:

Just Make It Better™ and I Won't Complain®.

[rubberduck-vba/Rubberduck] retailcoder merged pull request #4153: Introduce CodeStringParser from bclothier/Rubberduck/CodeStringParser into rubberduck-vba/Rubberduck/next

[rubberduck-vba/Rubberduck] bclothier pushed commit af66193a to next: Introduce CodeStringParser

I'll probably have to make a few changes to it anyway

[rubberduck-vba/Rubberduck] bclothier pushed commit e7197bd7 to next: Enable explicit mode selection and some refactoring

[rubberduck-vba/Rubberduck] bclothier pushed commit 294ab90f to next: Remove the superficial private constructor and create a separate method to parse. Update tests.

[rubberduck-vba/Rubberduck] web-flow pushed commit abe03b04 to next

:needs to find VB6 disc:

:probably under the VHS tapes:

[rubberduck-vba/Rubberduck] retailcoder published prerelease Rubberduck-v2.2.0.3484

[rubberduck-vba/Rubberduck] retailcoder created tag Rubberduck-v2.2.0.3484

[rubberduck-vba/Rubberduck] build for commit abe03b04 on next: AppVeyor build succeeded

[rubberduck-vba/Rubberduck] build for commit abe03b04 on next: 52.48% (target 0%)

Does RD add the HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\VBA\Vbe71DllPath key? I don't remember ever seeing that before.

hmm, not that I know of, but then I haven't looked there in a while, and @this did make rather significant changes to deployment and registration..

you'll want to make Rubberduck.Deployment your startup project BTW

Yep, @this tipped me to that this morning.

@this this PR was the small fix for KnownTypes csching: github.com/rubberduck-vba/Rubberduck/pull/4040

Need to look at it in the IDE, but wouldn't that prevent any caching? That shouldn't matter though - I just put that in for performance.

Finally hitting <kbd>F5</kbd>

@Comintern go on, give autocompletion a shot :)

(couple of bugs though, and an off-by-one will crash the IDE if you do msgbox(

Looking forward to it. :-)

Currently sitting at a breakpoint though. HTH I could boot RD straight into a debugging session before checking out all the bells and whistles is beyond even me.

stdole looks fine...

mso.dll is looking good.

excel.exe looks OK.

Well there's the problem...

It never even loads vbe7.dll.

Looking at you, suspicious new registry key...

@Comintern hmm, is it literally that? I'm pretty sure we shouldn't be adding a 71 anything.

I'm checking back through the call stack, but IIR we explicity load the vbe dll because it isn't really a "reference".

uh, isn't it the first reference?

Going to find out shortly. Just need to move my breakpoint back a bit.

and I just verified - we definitely don't have a symbol for Vbe71DllPath anywhere in the RD solution, so whatever that key is from, it's not from the Deployment, I think.

I wonder if that's specific to a 64bit Office install. I was running 32bit in my last VM.

.....

let me see...

...and not having VS Professional is already driving me up the wall. May have to fix that at work tomorrow.

just for my reference, are you building w/ MIDL or using tlexp?

Whatever the default is. :-D

it depends on your VS configuration....

if you have C++ build tools, then it'll try to compile using MIDL

otherwise it falls back to tlbexp

you can tell from the build output -- if it uses MIDL you will see all the MIDL messages

@this got a screen shot for reference regarding MIDL messages so I can recognise them in future.

@PeterMTaylor from line 645 to line 881

@this I didn't check the build output, but I don't have the MFC toolchain installed.

OK, WTF? That time it found it.

Why are we using the references object from the VBE on multiple threads?

for a debug build, we are using this script... that's the closest we get to the VBA branch....

@Comintern link to the code?

COMReferenceSynchronizer.LoadReferences, starting at line 26.

VS says that it was last touched by @M.Doerner 450+ days ago... One'd think that the problems would have manifested long ago if that was at that.

Unless a Windows change manifested itself in a different way between then and now.

Or a change to the runtime wrapper.

Those calls should ultimately be sorted out at the STA boundary and stacked, but that's dangerous in that it relies on the OLE subsystems to make sure that the accesses are thread safe.

re: that bogus registry key - maybe try and delete. If it re-appears after re-building, then that would confirm it is coming from the deployment project. I don't see any evidence that the scripts will build that funky key but who knows....

OK. I'm thinking it was something with an Office update?

We definitely try to load it (sometimes). The first time through, the debugger was telling me that there were 3 references. This time it's saying 4 (both with empty Workbooks).

hmmm.... this is a wild guess but one change was to have Excel auto-parse on startup for small enough workbook. That might be failing, since VBE isn't necessarily ready?

Mind, that change was made long while ago... I want to say almost a year now

OMG, autocomplete.

?!? it can do that?

(one'd hope that listening for keyboard events would be benign....)

Int -> Tab = Integer

@this LOL - nothing to do with reading the TLB. That was my first VBA autocomplete ever.

:savors moment:

Hmmm... What's the best way to test this in the VBE. The status bar isn't behaving like I remembered.

@MathieuGuindon methinks @Comintern is enjoying his first taste of autocomplete in VBA.

@Comintern whew! Glad you like it! I think Mat really did a great job there.

My VBA productivity seriously just tripled, at least.

given that he's using subclassing, I jumped to totally wrong conclusion. :D

There is something very satisfying about it. I’m looking forward to when our BDFL gets around to putting in foo ++ —> foo = foo + 1

I need an XML prettifier to verify, but the serialized declarations look just fine. Something is definately screwed up though, because this time I only got vbe and stdole loaded.

@IvenBach ὸ.ό HERESY!

I'm getting better results with this change:

foreach (var reference in referencesToLoad.ToList())

It's still occasionally missing though.

@M.Doerner I'm thinking that the main performance reason to multi-thread the COM collection is due to the TLB reads. Those are all native calls that can safely run concurrently. At that point in execution, we can assume that references are static (the UI isn't blocking, but I dare you to add a reference fast enough to trip it up...). Any downside to copying the members we need from the VBE reference objects to a managed IReference and then loading those concurrently?

...some load, some don't?

Yep. It's different with every run.

that does explain a lot of things

Looks like either thread contention or what @this mentioned, we're loading too fast.

The debugger itself gives a good clue - the count changes if you set a breakpoint before the loading loop and force it to enumerate the IEnumerable<IReference>. I'm getting all the references consistently that way.

[rubberduck-vba/Rubberduck] comintern created comment on issue #4045: COM resolver issues

[rubberduck-vba/Rubberduck] comintern created comment on issue #3201: Smart Indenter doesn't use changed/current Tab Width setting

@Duga This is the use case for symbolic links in the Windows registry.

TTGTB

[rubberduck-vba/Rubberduck] comintern created comment on issue #3210: Indenter indents line numbers/labels that include line continuations

[rubberduck-vba/Rubberduck] Vogel612 added label bug to issue #4174: False Positives for Builtin Functions and Constants

[rubberduck-vba/Rubberduck] Vogel612 added label resolver to issue #4174: False Positives for Builtin Functions and Constants

@Comintern It might be worthwhile to check out this particular feature of typelib API: GetReferenceInfo, ReferencesCollection,

and TypeInfoReference. This has the added advantage of providing you with the info even for a broken reference as well.

[rubberduck-vba/Rubberduck] ThunderFrame created comment on issue #3201: Smart Indenter doesn't use changed/current Tab Width setting

[rubberduck-vba/Rubberduck] ThunderFrame edited comment on issue #3201: Smart Indenter doesn't use changed/current Tab Width setting

[rubberduck-vba/Rubberduck] ThunderFrame created comment on issue #3210: Indenter indents line numbers/labels that include line continuations

[rubberduck-vba/Rubberduck] ThunderFrame added label parse-tree-processing to issue #3210: Indenter indents line numbers/labels that include line continuations

@M.Doerner ^ - adding parser to that issue, rather than opening a duplicate with a different tag..

[rubberduck-vba/Rubberduck] ThunderFrame edited comment on issue #3210: Indenter indents line numbers/labels that include line continuations

[rubberduck-vba/Rubberduck] ThunderFrame edited comment on issue #3210: Indenter indents line numbers/labels that include line continuations

[rubberduck-vba/Rubberduck] WaynePhillipsEA created pull request #4175: Add user defined compilation arguments to the preprocessor (WIP) to merge WaynePhillipsEA/Rubberduck/next into rubberduck-vba/Rubberduck/next

[rubberduck-vba/Rubberduck] build for commit f4ba846a on unknown branch: AppVeyor build failed

BUILD FAILURE!

@Duga huh? builds here. what have I done now

[rubberduck-vba/Rubberduck] WaynePhillipsEA synchronized pull request #4175: Add user defined compilation arguments to the preprocessor (WIP)

[rubberduck-vba/Rubberduck] build for commit fe6a5009 on unknown branch: AppVeyor build failed

BUILD FAILURE!

Thinking about it, could the change in managing the IVBE instance passed to us on startup have started the issues with the references?

[rubberduck-vba/Rubberduck] MDoerner created comment on issue #3210: Indenter indents line numbers/labels that include line continuations

> I have no idea how the compiler interprets the code example. Per spec, line labels must be at the start of the logical line.

[rubberduck-vba/Rubberduck] Stevefb opened issue #4176: Rubberduck ate my code, spit it out ....

[rubberduck-vba/Rubberduck] Stevefb edited issue #4176: Something ~Rubberduck~ ate my code, spit it out ....

[rubberduck-vba/Rubberduck] WaynePhillipsEA synchronized pull request #4175: Add user defined compilation arguments to the preprocessor (WIP)

@Duga if that doesn't fix the broken tests, I'll have to ask one of you to take a look, as I don't know how to run them locally and debug them so I'm shooting in the dark

@M.Doerner if you could spare a few minutes to look over my PR I'd be grateful. In particular, the use of the task with your pimped UiDispatcher

[rubberduck-vba/Rubberduck] Stevefb edited issue #4176: Something ~Rubberduck~ ate my code, spit it out ....

[rubberduck-vba/Rubberduck] ThunderFrame created comment on issue #3210: Indenter indents line numbers/labels that include line continuations

[rubberduck-vba/Rubberduck] [codecov[bot]](github.com/apps/codecov) created comment on pull request #4175: Add user defined compilation arguments to the preprocessor (WIP)

[rubberduck-vba/Rubberduck] build for commit ca7cd95f on unknown branch: 52.47% (target 0%)

[rubberduck-vba/Rubberduck] build for commit ca7cd95f on unknown branch: AppVeyor build succeeded

[rubberduck-vba/Rubberduck] MDoerner commented on Rubberduck.Parsing/VBA/AttributeParser.cs of pull request #4175: Add user defined compilation arguments to the preprocessor (WIP)

[rubberduck-vba/Rubberduck] MDoerner commented on Rubberduck.Parsing/Preprocessing/VBAPreprocessor.cs of pull request #4175: Add user defined compilation arguments to the preprocessor (WIP)

[rubberduck-vba/Rubberduck] MDoerner commented on Rubberduck.Parsing/VBA/ComponentParseTask.cs of pull request #4175: Add user defined compilation arguments to the preprocessor (WIP)

[rubberduck-vba/Rubberduck] MDoerner commented on Rubberduck.Parsing/Preprocessing/VBAPreprocessor.cs of pull request #4175: Add user defined compilation arguments to the preprocessor (WIP)

@Duga Is that an auto-complete bug?

It shouldn't be considering it is unloaded, but...

[rubberduck-vba/Rubberduck] WaynePhillipsEA created comment on pull request #4175: Add user defined compilation arguments to the preprocessor (WIP)

> Thanks @MDoerner. With regards to the step before parsing: I fully agree, and I said as much in the description of this WIP PR.

@WaynePhillipsEA @Duga I think we can postpone the refactoring of how the preprocessor is organized to when we refactor the parser. My current plan is to do that next month when I have a bit more time again.

[rubberduck-vba/Rubberduck] comintern created comment on issue #3210: Indenter indents line numbers/labels that include line continuations

[rubberduck-vba/Rubberduck] bclothier created comment on issue #3210: Indenter indents line numbers/labels that include line continuations

[rubberduck-vba/Rubberduck] bclothier edited comment on issue #3210: Indenter indents line numbers/labels that include line continuations

[rubberduck-vba/Rubberduck] MDoerner created comment on issue #3210: Indenter indents line numbers/labels that include line continuations

> I think I have an idea how to fix the parser to accept the line continuations in front of the line number. However, I will have to test whether that brakes something else.

@WaynePhillipsEA am I to understand that the value for a compilation argument is a short? Why would this compile? #Const Test = &HFFFFFFFF?

[rubberduck-vba/Rubberduck] ThunderFrame created comment on issue #3210: Indenter indents line numbers/labels that include line continuations

> I'm convinced it's a single logical line, but it seems like a little tool called vbWatchdog might be of use here, or even a p-code analysis. I'm AFK. Maybe @WaynePhillipsEA can help determine the lines are a single logical line?

@this I thought code-defined arguments could be any type?

#Const fooo = "abc"

#If fooo = "abc" Then
    Const x = "strings allowed"
#Else
    Const x = "not allowed"
#End If

@this - ^ that should compile and return strings allowed

@ThunderFrame Even Object apparently

that looks like it's asking for trouble

That's an "invalid use of object" on the #If line.

@ThunderFrame I demand trouble.

@this - huh, there are imposters:

and there's even a this.foo:

@ThunderFrame how do you impose a pronoun? Of course you gonna get different answer since it's all about context, baby!

@this I assumed one of those thises has a trailing space, so if I watch that user, I'll be watching this space?

@Comintern When you have a moment, you may want to review some recent, unresolved chats about how to treat <globals> and appobjects (see(4164) and how to get the IControl members for a control (see 2592)

@ThunderFrame That's what I thought but it might be that I did not understand the PR changing from string to short. That's why I asked.

@ThunderFrame IDK. It might be even legal to have duplicates.

@this or, it's a coding error at SO, where sombody accidentally treated a this variable as a string literal... A bit like Jennifer Null having trouble when booking travel.

I doubt it. If you try a common name... say Paul, you get a lot of dupes. And if you look carefully - when you select a choice it changes to user ID. Thus the names are not necessarily unique in SO.

Gah... I think I may have misdirected on the com collector... I had a dirty local, having reset to vanilla next, the collector seems OK. There still appears to be a problem with events from COM controls though, investigating.

@Comintern it might be that it's doing a crappy job of validating the validity. Change the line to #If foo Is Application Then then you get a different compile error: Constant expression required which is more expected.

@this project-level compilation arguments are always shorts. Even the built-in ones.

@WaynePhillipsEA ooh. that's new to me! Yeah I can confirm that.

bar = 1 : foo = bar and foo = 32678 both result in error.

But gee whiz, consistency isn't their strong suit; one'd expect the module-level constants to have similar behavior.

The handling of the builtin constants VBA7 etc is wrong in the preprocessor actually. I might just fix it in my PR.

Problem is, the preprocessor is a bit of a mess. e.g. It should have separate integer types, not just Bool / Byte / Decimal

IDK if you saw but there is a open issue to build a proper expression engine

right now we have 2 versions of expression engine. :(

ah right, well that explains it. no missed that

That's why Max would like to merge them and ensure that they follow the VBA spec

I see, sounds like a good idea

vbWatchdog has a built in preprocessor evaluation engine, so if I can assist, just let me know

github.com/rubberduck-vba/Rubberduck/issues/3969

This is the issue

I also wonder if we need to be importing the functions from the oleaut32 DLL so that we use exact same functions that VBA internally uses for comparison/conversions/parsing of various types.

pssst.... you're on the right track

Unfortunately, the p/invoke site only has one function from that DLL. The rest will have to be crafted by hand. x_x

Well, let's just say, that's how vbWatchdog does it. Everything goes through the appropriate OLE functions.

Makes complete sense. Good to know that I'm not wrong all the time!

[rubberduck-vba/Rubberduck] mansellan edited comment on issue #4045: COM resolver issues

[rubberduck-vba/Rubberduck] mansellan edited comment on issue #4045: COM resolver issues

[rubberduck-vba/Rubberduck] mansellan created comment on issue #4045: COM resolver issues

[rubberduck-vba/Rubberduck] mansellan added label vb6-specific to issue #4045: COM resolver issues

@Duga #TIL RE: OCA. I wonder if that's the same thing that we get via the typelib API (e.g. strings like *\G{000204EF-0000-0000-C000-000000000046}#4.1#9#C:\PROGRA~2\COMMON~1\MICROS~1\V‌​BA\VBA7\VBE7.DLL#Visual Basic For Applications"

[rubberduck-vba/Rubberduck] WaynePhillipsEA commented on Rubberduck.Parsing/VBA/ComponentParseTask.cs of pull request #4175: Add user defined compilation arguments to the preprocessor (WIP)

@Duga we really need that code analyzer for dangerous access to com wrapper. @Hosch250 do you think you might be able to whip it up quickly?

[rubberduck-vba/Rubberduck] WaynePhillipsEA commented on Rubberduck.Parsing/Preprocessing/VBAPreprocessor.cs of pull request #4175: Add user defined compilation arguments to the preprocessor (WIP)

@this Which one?

The chained access one?

Maybe.

yes

for any types deriving from ComSafeWrapper SafeComWrapper

I guess I could take a stab at it this weekend.

@this SafeComWrapper

the COM "safe" is another thing :)

Well, they do recommend wrapping your safe to keep it warm.

Especially during the winter.

[rubberduck-vba/Rubberduck] WaynePhillipsEA synchronized pull request #4175: Add user defined compilation arguments to the preprocessor (WIP)

[rubberduck-vba/Rubberduck] WaynePhillipsEA created comment on pull request #4175: Add user defined compilation arguments to the preprocessor (WIP)

> as per chat, I'll leave it to @MDoerner to refactor the code to grab the argument values only once before parse when he does his larger scope PR for the preprocessor.

@Duga I could understand it if the .VBP or .FRM files (for some reason) referenced the .OCA. But tracing through all the GUIDs leads to the OCX, not the OCA...

So the References collection is lying

@mansellan you could always use the TypeLib API instead, as I've exposed the ITypeLib for each reference, which is the exact ITypeLib that VBE is itself using internally.

@this IIRC, those # delimiters and reference strings are the same format used in the binary vbProject files, and are documented in the [OVBA] specification.

@WaynePhillipsEA sounds like the way forward

chores, bbl

@ThunderFrame hm. If it's in the .vbp then I guess I don't understand the use of OCA file.

@mansellan This may help, too:

@this I forget what the OCA files are?

@ThunderFrame it's linked in the issue: stackoverflow.com/questions/4050078/…

[rubberduck-vba/Rubberduck] bclothier created comment on issue #3969: Unify expression evaluation back-ends for Unreachable case and the preprocessor

> Just to record for posterity, the new unified expression engine should ideally make use of the functions imported from the oleaut32 DLL. The functions are described here. The engine should invoke those functions to get the same behavior as we observe with VBA for parsing, conversion and casting of the expressions and its types.

@this yeah, thought they sounded familiar. Are they the files that you sometimes need to delete to get userforms to work? I had thought they had a different extension and related to the form, or maybe they're in addition to the OCA files?

@Duga didn't @Comintern use some of those for the Fakes?

@ThunderFrame only to load the type lib: github.com/rubberduck-vba/Rubberduck/blob/…

we also have another import for clearing the variant: github.com/rubberduck-vba/Rubberduck/blob/…

[rubberduck-vba/Rubberduck] build for commit 5c6bfc64 on unknown branch: AppVeyor build succeeded

only 2 functions --- we're missing only few. ;-)

[rubberduck-vba/Rubberduck] [codecov[bot]](github.com/apps/codecov) edited comment on pull request #4175: Add user defined compilation arguments to the preprocessor (WIP)

[rubberduck-vba/Rubberduck] build for commit 5c6bfc64 on unknown branch: 52.47% (target 0%)

@ThunderFrame I'd have to check to make sure, but I don't think so. It probably needs to in order to be stable. I was starting to run into issues with memory management of Variants that were being used as return values IIR.

> twiddled type library: A modified Automation type library in which all controls are marked as extensible. A twiddled type library is generated automatically by the Visual Basic Editor when a user adds one or more controls to a document.

@Comintern that's the thing about imported functions - you've left the sandbox. It may be necessary to use IntPtrs and only cast to object when actually needed or something like that.

@Comintern... that's a name I've haerd a lot around here

@this Oh, you can't even see the sandbox from the Fakes.

Nice to virtually meet you @Comintern

Likewise, @WaynePhillipsEA

> from [MS-OVBA]:

^ see constructor for TypeInfoReference, as the parser for that string format already exists.

[rubberduck-vba/Rubberduck] WaynePhillipsEA edited pull request #4175: Add user defined compilation arguments to the preprocessor

[rubberduck-vba/Rubberduck] bclothier created comment on pull request #4175: Add user defined compilation arguments to the preprocessor

[rubberduck-vba/Rubberduck] bclothier edited comment on pull request #4175: Add user defined compilation arguments to the preprocessor

[rubberduck-vba/Rubberduck] bclothier edited comment on pull request #4175: Add user defined compilation arguments to the preprocessor

[rubberduck-vba/Rubberduck] WaynePhillipsEA created comment on pull request #4175: Add user defined compilation arguments to the preprocessor

> @bclothier they looks like they are cached? I can't see that they are getting new wrappers, so they should be OK.

[rubberduck-vba/Rubberduck] WaynePhillipsEA edited comment on pull request #4175: Add user defined compilation arguments to the preprocessor

[rubberduck-vba/Rubberduck] WaynePhillipsEA synchronized pull request #4175: Add user defined compilation arguments to the preprocessor

[rubberduck-vba/Rubberduck] [codecov[bot]](github.com/apps/codecov) edited comment on pull request #4175: Add user defined compilation arguments to the preprocessor

[rubberduck-vba/Rubberduck] [codecov[bot]](github.com/apps/codecov) edited comment on pull request #4175: Add user defined compilation arguments to the preprocessor

[rubberduck-vba/Rubberduck] WaynePhillipsEA created comment on issue #3210: Indenter indents line numbers/labels that include line continuations

[rubberduck-vba/Rubberduck] WaynePhillipsEA created comment on pull request #4175: Add user defined compilation arguments to the preprocessor

> ^ whilst I was in here, I thought I may as well correct some errors with the handling of builtin constants (VBE7, VBE6, Win64 etc).

[rubberduck-vba/Rubberduck] build for commit 18af41aa on unknown branch: AppVeyor build failed

BUILD FAILURE!

[rubberduck-vba/Rubberduck] bclothier edited comment on pull request #4175: Add user defined compilation arguments to the preprocessor

@Duga that's yet another reason why we really need the code analyzer. I can't trust my own eyeballing to catch the possible leaks.

you all help me with an excel formula?

> ISNUMBER(SEARCH("%",B12))

if I have 5% in B12, why does it give me a Falsey value?

SEARCH returns an index, and that index will always be a number..

@Malachi because SEARCH is expecting a string, not a number. 5% is really 0.05.

hmmm....

makes sense for Excel.....

SEARCH("%",TEXT(B12,"0%"))

I am trying to set up discount calculation where I can input either a dollar amount or a percentage

@Malachi makes sense period: B12 doesn't contain "5%", it contains 0.05 and then it has a NumberFormat that makes its text representation be 5%.

@MathieuGuindon very true

where is that one post by SO Guru about Excel and the Cell Names.... do you know what I am talking about?

maybe it was a youtube video

no idea

Jon Skeet I think....

Jon Skeet, Excel guru?

the fancy A1 style cell naming is not what the cell names really are.

not names, addresses

and yes, they're that. you can use either A1 or R1C1 addressing.

who are the other Top Names in SO

it wasn't skeet

Spolsky?

yeah maybe actually

(SE's CEO BTW)

he worked on the Excel team and designed the VBA spec

that is exactly the one I was looking for

[rubberduck-vba/Rubberduck] WaynePhillipsEA synchronized pull request #4175: Add user defined compilation arguments to the preprocessor

[rubberduck-vba/Rubberduck] [codecov[bot]](github.com/apps/codecov) edited comment on pull request #4175: Add user defined compilation arguments to the preprocessor

@MathieuGuindon that gives a value of 2? is that truthy for excel?

it's a very good video IIRC

index is 1-based

oh I get it

duh LOL

[rubberduck-vba/Rubberduck] build for commit e6da06f9 on unknown branch: AppVeyor build succeeded

[rubberduck-vba/Rubberduck] [codecov[bot]](github.com/apps/codecov) edited comment on pull request #4175: Add user defined compilation arguments to the preprocessor

@Duga just a note to whoever wrote the preprocessor unit tests... "#If Not VBA7 Then" does not do what you think it does, since the VBA7 constant is only either 1 or 0 (not True/-1 as you may expect)

[rubberduck-vba/Rubberduck] build for commit e6da06f9 on unknown branch: 52.47% (target 0%)

@MathieuGuindon, Thank you for your help.

@WaynePhillipsEA thanks for that. Looks like that might need to be an inspection too.

good idea

[rubberduck-vba/Rubberduck] ThunderFrame created comment on issue #3210: Indenter indents line numbers/labels that include line continuations

> @WaynePhillipsEA - Thanks for the confirmation.

Not only that but also for incorrect ordering (e.g. #If VBA6 Then .... #ElseIf VBA7 Then....) --- the VBA7 branch would be basically unreachable.

^ definitely

BTW guys, how do you run the tests locally?

@WaynePhillipsEA can you open up Test Explorer?

it's under the Test -> Windows menu

ahah.... got it, thanks

one more FYI -

if you go to any unit test procedure

you can right-click somewhere inside and choose Debug Tets / Run Test from the context menu

brilliant, thanks.

I am on Windows 10 and Can't find Excel in the folder structure to have it open an ODS file, any thoughts?

nevermind

[rubberduck-vba/Rubberduck] schifazl starred us

ugh. folks, member names aren't reserved keywords

I think a lot of VBA coders avoid them as if they were though because the VBE screws up the casing everywhere. It's an OCD thing that I'm guilty of.

Definitely not "reserved" though. Nothing a reference to Excel would compile...

I've gotten to the point where I truly don't care for casing of referenced libraries anymore. If I need a value parameter, I'm not calling it pValue just to keep Range.Value uppercase.

I'd probably grab a thesaurus and end up with something like quantity or something stupid like that.

I think it mainly has to do with working in so many case-sensitive languages - it requires concentration to not assume that Value and value are distinct.

OMG!!! @Comintern is ALIVE!!!!! / late to the party / story of my life

welcome back.

[rubberduck-vba/Rubberduck] DudePascalou starred us

@FreeMan Thanks!