Let's build a transpiler! Part 48

This is the forty-eighth post in a series of building a transpiler.
You can find the previous ones here.

An eventful thing

Events in VB are composed of four elements: Two on the producer side and two on the consumer side.
Suppose we wanted to add an Added event to KeyedList so, anytime a new item is added, KeyedList's user is warned.

First, we would need to declare that KeyedList now has an Added event:

Public Class KeyedList
Public Event Added()
(...)
End Class

Then, we would need to fire it when a new item is added:

Public Sub Add(ByVal Item As Variant, Optional ByVal Key As Variant, Optional Before As Variant)
(...)
RaiseEvent Added
End Sub

From the producer side, that's it.
Now on the consumer side.

We would need to declare a WithEvents KeyedList variable. It has to be in a class and its declaration area:

Class MyClass
Private WithEvents MyList As KeyedList
(...)
End Class

Unfortunately, we cannot declare it "As New KeyedList". So, we need to instantiate it somewhere else:

Private Sub Class_Initialize()
Set MyList = New KeyedList
End Class

Then we need to set up a handler, that is, the code that will be called when the event happens.
Its name must be composed of the variable's and the event's names:

Private Sub MyList_Added()
Rem Do whatever you want here...
End Sub

Now, every time an item is added to MyList, MyList_Added will be called.

VB hides a very complex COM protocol behind these four elements.
So far our classes are:

Public Class KeyedList
Public Event Added()

(...)

Public Sub Add(...)
(...)
RaiseEvent Added()
End Sub
End Class

Public Class MyClass
Private WithEvents MyList As KeyedList

Private Sub Class_Initialize()
Set MyList = New KeyedList
End Sub

Private Sub MyList_Added()
Rem Do whatever you want here...
End Sub
End Class
Without VB's magic, this is what would happen - kinda:
That event in KeyedList would be moved to an interface.

Public Class IKeyedListEvent
Sub Added()
End Sub
End Class

This is an outgoing interface, meaning it originates from KeyedList, but is implemented externally by KeyedList's clients.
It may also be called 'sink.'

This interface will need an IID:

Const Guid_IKeyedListEvent As Guid = (...)

Then, KeyedList would need to implement IConnectionPoint and IConnectionPointContainer interfaces, so clients would be able to connect to it:

'This is the connectable / source object. It supports - but does not implement - IKeyedListEvent
Public Class KeyedList
Implements IConnectionPoint
Implements IConnectionPointContainer

Private Sinks() As IKeyedListEvent

''''''''''''''' IConnectionPoint implementation ''''''''''''''

Private Sub IConnectionPoint_Advise(ByRef Sink As Object, ByRef Cookie As Long)
Cookie = SafeUBound(Sinks) + 1
ReDim Preserve Sinks(Cookie)
Set Sinks(Cookie) = Sink
End Sub

(...)

Private Sub IConnectionPoint_Unadvise(ByVal Cookie As Long)
Set Sinks(Cookie) = Nothing
End Sub

'''''''''' IConnectionPointContainer implementation ''''''''''

Private Sub IConnectionPointContainer_FindConnectionPoint(ByRef ItfId As Guid, ByRef Point As IConnectionPoint)
If ItfId = Guid_IKeyedListEvent Then Set Point = Me
End Sub

(...)

''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''

Public Sub Add(...)
Dim Sink As IKeyedListEvent
(...)

For Each Sink In Sinks
If Not Sink Is Nothing Then Call Sink.Added()
Next
End Sub
End Class

Finally, MyClass would have to implement the outgoing interface and manage the connection and disconnection to the source object:

'This is the client. It may be called 'sink', too.
Public Class MyClass
Implements IKeyedListEvent

Private Cookie As Long
Private Point As IConnectionPoint
Private MyList As KeyedList

Private Sub Class_Initialize()
Dim Container As IConnectionPointContainer

Set MyList = New KeyedList
'Error checks removed to keep it simple
Set Container = MyList
Container.FindConnectioPoint Guid_IKeyedListEvent, Point
If Point Is Nothing Then Err.Raise -1
Point.Advise Me, Cookie
End Sub

Private Sub IKeyedListEvent_Added()
Rem Do whatever you want here...
End Sub

Private Sub Class_Terminate()
Point.Unadvise Cookie
End Class
End Class

So, on the client-side, we have an IConnectionPointContainer variable (Container) that is set to MyList, which is a KeyedList that implements IConnectionPointContainer interface.
We call its FindConnectioPoint method passing both the GUID to IKeyedListEvent and an IConnectionPoint variable (Point). If the call is not successful - that is, KeyedList does not support the interface represented by the GUID -, Point will be Nothing, so we raise an error.
Otherwise, we pass (Me) and a Long variable (Cookie). We pass Me because KeyedList will call MyClass' IKeyedListEvent implementation through it, that is, it will call our IKeyedListEvent_Added method.
We pass Cookie because it is an identifier we should use when we are no longer interested in receiving events from KeyedList. We do that in Class_Terminate method.

On the server-side, if the GUID provided in calling IConnectionPointContainer_FindConnectionPoint is the one for IKeyedListEvent, we set Point to ourselves (Me), because KeyedList implements the IConnectionPointContainer interface.
In our Advise implementation, we just add another element to an array of IKeyedListEvent and return its index.
We also save Point at that place, so we can call its Added method / IKeyedListEvent implementation in KeyedList's Add method.
Finally, when Unadvise is called, we simply set the place in our array pointed to by Cookie to Nothing.
As it is just an example, we are not de-allocating that array's element because it would turn our code much more complicated.

Back to business

Last time I said I wanted to do so many things...
One of them was to prepare myself to do operations the way VB does.
See, when transpiling to C, while adding two Longs / int32_ts, for instance, if the result is too large to fit in an int32_t, we have undefined behavior in C, but VB has a very defined behavior for that: Overflow error.
The same goes for several other operators, like -, *, ^, etc.
But, as I said before, I would have to create hundreds of functions to deal with 14 data types times at least 26 operators times 14 data types.
So, I've made a compromise. I'm supposing that if I'm dealing with data type A, operator B, data type C, and I'm getting as result data type D, I may convert A and C to D and then apply the operator.
Like when multiplying a Single by a Currency and getting a Double. I can convert Single and Currency to Double and multiply them!
This "reduced" the number of procedures from over 4700 to 310.
Will I use all of them? Probably not, but I want to have it available if needed.

Here are the highlights while working on the code for the operations:

Comparing Singles and Doubles is difficult. I didn't know how to approach it, but I knew VB has its own way to do it.
Then, while testing in VB's IDE, I think I got it: It disregards from the 16th digit onwards, be it integral or fractional ones.
I've learned a few tricks reading Hacker's Delight 2nd Ed. available freely on the Internet.
There are two functions in the dump below that I did not create yet: One that calls a default method on an object - assuming it does have a default method -, and another that tells me what conversions I should apply to the "A" and "C" data types mentioned above.
I've said before that I had to figure out how to test some 64-bit / LongLong code now that I don't have an MS Office 64-bit installation available anymore.
What I did to test function Sum_Dec was to implement it in C, test it, then translate it back to VB.
Not much pleasant, but it is an option.
By the way, most functions below were not tested.
I could finally understand the Karatsuba algorithm, so now I'm using it when multiplying a pair of LongLongs, Currencys, or Decimals.
There's no implementation in the code below for the following operators: + [Identity], AddressOf, AndAlso, () [Apply], ! [Bang, WithBang], ByVal, . [Dot, WithDot], Like, := [Named], New, OrElse, To, and TypeOf.
Some are not "real" operators (like Apply), some will be dealt with differently (like AndAlso and OrElse), and some will be provided later, like, well... Like.

Next week we'll pause our transpiler series to talk about another fiasco of mine (!).

Andrej Biasic
2021-08-18

Update:
Fixed USub64 (changed MAX_LNG and MIN_LNG for MAX_LNGLNG and MIN_LNGLNG respectively. Oh, the shame!)

Andrej Biasic
2021-09-28