Initial commit: cframework. Longbow and Libparc

Change-Id: I90378dbd30da6033b20fb1f829b3b822cf366c59
Signed-off-by: Luca Muscariello <lumuscar+fdio@cisco.com>

1 files changed, 324 insertions, 0 deletions

diff --git a/libparc/parc/algol/internal_parc_Event.c b/libparc/parc/algol/internal_parc_Event.c
new file mode 100755
index 00000000..74e917bf
--- /dev/null
+++ b/libparc/parc/algol/internal_parc_Event.c
@@ -0,0 +1,324 @@
+/*
+ * Copyright (c) 2017 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ */
+#include <config.h>
+
+#include <LongBow/runtime.h>
+#include <parc/algol/parc_Memory.h>
+#include "internal_parc_Event.h"
+
+/**
+ * Current implementation based on top of libevent2
+ */
+#include <event2/event.h>
+#include <event2/bufferevent.h>
+
+void *
+internal_parc_alloc(size_t size)
+{
+    void *pointer;
+
+    pointer = parcMemory_AllocateAndClear(size);
+    return pointer;
+}
+
+void *
+internal_parc_realloc(void *pointer, size_t newSize)
+{
+    void *newPointer;
+    newPointer = parcMemory_Reallocate(pointer, newSize);
+    return newPointer;
+}
+
+// We interpose on the standard "free" interface to protect against freed memory accesses.
+void
+internal_parc_free(void *ptr)
+{
+    parcMemory_Deallocate((void **) &ptr);
+}
+
+static int _libeventInitialized = 0;
+
+void
+internal_parc_initializeLibevent(void)
+{
+    if (_libeventInitialized) {
+        return;
+    }
+    _libeventInitialized = 1;
+
+    // 0x AA BB CC XX
+    // AA = major
+    // BB = minor
+    // CC = patchlevel
+    //
+    uint32_t version = event_get_version_number();
+    trapIllegalValueIf(version < 0x02001000UL,
+                       "Libevent version must be at least 2.0.16, got %s",
+                       event_get_version());
+
+    // Make sure libevent uses our memory allocator.
+    // Libevent allocates an internal object the first time a base is allocated
+    // that it never releases.  In order to ensure our outstanding memory counters
+    // start at zero we trigger this allocation before interposing our memory allocator.
+    //
+    // Create a scheduler event base, an event, then free both of them.
+    //
+    struct event_base *evbase = event_base_new();
+    assertNotNull(evbase, "Libevent event_base_new returned NULL");
+    struct event *event = event_new(evbase, -1, 0, NULL, NULL);
+    assertNotNull(event, "Libevent event_new returned NULL");
+    event_del(event);
+    event_base_free(evbase);
+    event_free(event);
+
+    event_set_mem_functions(internal_parc_alloc,
+                            internal_parc_realloc,
+                            internal_parc_free);
+}
+
+PARCEventPriority
+internal_libevent_priority_to_PARCEventPriority(short evpriority)
+{
+    PARCEventPriority priority = 0;
+    switch (evpriority) {
+        case 0: priority = PARCEventPriority_Maximum;
+            break;
+        case 1: priority = PARCEventPriority_Normal;
+            break;
+        case 2: priority = PARCEventPriority_Minimum;
+            break;
+        default:
+            assertTrue(0, "Unknown Libevent priority 0x%x\n", evpriority);
+            break;
+    }
+    return priority;
+}
+
+short
+internal_PARCEventPriority_to_libevent_priority(PARCEventPriority priority)
+{
+    short evpriority = 0;
+    switch (priority) {
+        case PARCEventPriority_Maximum: evpriority = 0;
+            break;
+        case PARCEventPriority_Normal: evpriority = 1;
+            break;
+        case PARCEventPriority_Minimum: evpriority = 2;
+            break;
+        default:
+            assertTrue(0, "Unknown PARCEventPriority 0x%x\n", evpriority);
+            break;
+    }
+    return evpriority;
+}
+
+PARCEventSchedulerDispatchType
+internal_eventloop_options_to_PARCEventSchedulerDispatchType(short evoptions)
+{
+    PARCEventSchedulerDispatchType options = 0;
+    switch (evoptions) {
+        case 0: options = PARCEventSchedulerDispatchType_Blocking;
+            break;
+        case EVLOOP_ONCE: options = PARCEventSchedulerDispatchType_LoopOnce;
+            break;
+        case EVLOOP_NONBLOCK: options = PARCEventSchedulerDispatchType_NonBlocking;
+            break;
+        default:
+            assertTrue(0, "Unknown Libevent dispatcher flag 0x%x\n", evoptions);
+            break;
+    }
+    return options;
+}
+
+short
+internal_PARCEventSchedulerDispatchType_to_eventloop_options(PARCEventSchedulerDispatchType options)
+{
+    short evoptions = 0;
+    switch (options) {
+        case PARCEventSchedulerDispatchType_Blocking: evoptions = 0;
+            break;
+        case PARCEventSchedulerDispatchType_LoopOnce: evoptions = EVLOOP_ONCE;
+            break;
+        case PARCEventSchedulerDispatchType_NonBlocking: evoptions = EVLOOP_NONBLOCK;
+            break;
+        default:
+            assertTrue(0, "Unknown PARCEventSchedulerDispatchType option 0x%x\n", evoptions);
+            break;
+    }
+    return evoptions;
+}
+
+PARCEventQueueOption
+internal_bufferevent_options_to_PARCEventQueueOption(short evflags)
+{
+    PARCEventQueueOption flags = 0;
+    if (evflags & BEV_OPT_CLOSE_ON_FREE) {
+        flags |= PARCEventQueueOption_CloseOnFree;
+        evflags &= ~BEV_OPT_CLOSE_ON_FREE;
+    }
+    if (evflags & BEV_OPT_DEFER_CALLBACKS) {
+        flags |= PARCEventQueueOption_DeferCallbacks;
+        evflags &= ~BEV_OPT_DEFER_CALLBACKS;
+    }
+    assertTrue(evflags == 0, "Unknown Libevent option flag 0x%x\n", evflags);
+    return flags;
+}
+
+short
+internal_PARCEventQueueOption_to_bufferevent_options(PARCEventQueueOption flags)
+{
+    short evflags = 0;
+    if (flags & PARCEventQueueOption_CloseOnFree) {
+        evflags |= BEV_OPT_CLOSE_ON_FREE;
+        flags &= ~PARCEventQueueOption_CloseOnFree;
+    }
+    if (flags & PARCEventQueueOption_DeferCallbacks) {
+        evflags |= BEV_OPT_DEFER_CALLBACKS;
+        flags &= ~PARCEventQueueOption_DeferCallbacks;
+    }
+    assertTrue(flags == 0, "Unknown PARCEventQueueOption flag 0x%x\n", flags);
+    return evflags;
+}
+
+PARCEventQueueEventType
+internal_bufferevent_type_to_PARCEventQueueEventType(short evtypes)
+{
+    PARCEventQueueEventType types = 0;
+    if (evtypes & BEV_EVENT_READING) {
+        types |= PARCEventQueueEventType_Reading;
+        evtypes &= ~BEV_EVENT_READING;
+    }
+    if (evtypes & BEV_EVENT_WRITING) {
+        types |= PARCEventQueueEventType_Writing;
+        evtypes &= ~BEV_EVENT_WRITING;
+    }
+    if (evtypes & BEV_EVENT_EOF) {
+        types |= PARCEventQueueEventType_EOF;
+        evtypes &= ~BEV_EVENT_EOF;
+    }
+    if (evtypes & BEV_EVENT_ERROR) {
+        types |= PARCEventQueueEventType_Error;
+        evtypes &= ~BEV_EVENT_ERROR;
+    }
+    if (evtypes & BEV_EVENT_TIMEOUT) {
+        types |= PARCEventQueueEventType_Timeout;
+        evtypes &= ~BEV_EVENT_TIMEOUT;
+    }
+    if (evtypes & BEV_EVENT_CONNECTED) {
+        types |= PARCEventQueueEventType_Connected;
+        evtypes &= ~BEV_EVENT_CONNECTED;
+    }
+    assertTrue(evtypes == 0, "Unknown Libevent type flag 0x%x\n", evtypes);
+    return types;
+}
+
+short
+internal_PARCEventQueueEventType_to_bufferevent_type(PARCEventQueueEventType types)
+{
+    short evtypes = 0;
+    if (types & PARCEventQueueEventType_Reading) {
+        evtypes |= BEV_EVENT_READING;
+        types &= ~PARCEventQueueEventType_Reading;
+    }
+    if (types & PARCEventQueueEventType_Writing) {
+        evtypes |= BEV_EVENT_WRITING;
+        types &= ~PARCEventQueueEventType_Writing;
+    }
+    if (types & PARCEventQueueEventType_EOF) {
+        evtypes |= BEV_EVENT_EOF;
+        types &= ~PARCEventQueueEventType_EOF;
+    }
+    if (types & PARCEventQueueEventType_Error) {
+        evtypes |= BEV_EVENT_ERROR;
+        types &= ~PARCEventQueueEventType_Error;
+    }
+    if (types & PARCEventQueueEventType_Timeout) {
+        evtypes |= BEV_EVENT_TIMEOUT;
+        types &= ~PARCEventQueueEventType_Timeout;
+    }
+    if (types & PARCEventQueueEventType_Connected) {
+        evtypes |= BEV_EVENT_CONNECTED;
+        types &= ~PARCEventQueueEventType_Connected;
+    }
+    assertTrue(types == 0, "Unknown PARCEventQueueEventType 0x%x\n", types);
+    return evtypes;
+}
+
+PARCEventType
+internal_libevent_type_to_PARCEventType(short evtypes)
+{
+    PARCEventType types = 0;
+    if (evtypes & EV_TIMEOUT) {
+        types |= PARCEventType_Timeout;
+        evtypes &= ~EV_TIMEOUT;
+    }
+    if (evtypes & EV_READ) {
+        types |= PARCEventType_Read;
+        evtypes &= ~EV_READ;
+    }
+    if (evtypes & EV_WRITE) {
+        types |= PARCEventType_Write;
+        evtypes &= ~EV_WRITE;
+    }
+    if (evtypes & EV_SIGNAL) {
+        types |= PARCEventType_Signal;
+        evtypes &= ~EV_SIGNAL;
+    }
+    if (evtypes & EV_PERSIST) {
+        types |= PARCEventType_Persist;
+        evtypes &= ~EV_PERSIST;
+    }
+    if (evtypes & EV_ET) {
+        types |= PARCEventType_EdgeTriggered;
+        evtypes &= ~EV_ET;
+    }
+    assertTrue(evtypes == 0, "Unknown Libevent event type 0x%x\n", evtypes);
+    return types;
+}
+
+short
+internal_PARCEventType_to_libevent_type(PARCEventType types)
+{
+    short evtypes = 0;
+    if (types & PARCEventType_Timeout) {
+        evtypes |= EV_TIMEOUT;
+        types &= ~PARCEventType_Timeout;
+    }
+    if (types & PARCEventType_Read) {
+        evtypes |= EV_READ;
+        types &= ~PARCEventType_Read;
+    }
+    if (types & PARCEventType_Write) {
+        evtypes |= EV_WRITE;
+        types &= ~PARCEventType_Write;
+    }
+    if (types & PARCEventType_Signal) {
+        evtypes |= EV_SIGNAL;
+        types &= ~PARCEventType_Signal;
+    }
+    if (types & PARCEventType_Persist) {
+        evtypes |= EV_PERSIST;
+        types &= ~PARCEventType_Persist;
+    }
+    if (types & PARCEventType_EdgeTriggered) {
+        evtypes |= EV_ET;
+        types &= ~PARCEventType_EdgeTriggered;
+    }
+    assertTrue(types == 0, "Unknown Libevent event type 0x%x\n", types);
+    return evtypes;
+}