Initial commit: cframework. Longbow and Libparc

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

1 files changed, 181 insertions, 0 deletions

diff --git a/libparc/parc/algol/parc_JSONParser.c b/libparc/parc/algol/parc_JSONParser.c
new file mode 100755
index 00000000..a0022597
--- /dev/null
+++ b/libparc/parc/algol/parc_JSONParser.c
@@ -0,0 +1,181 @@
+/*
+ * 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 <ctype.h>
+#include <string.h>
+
+#include <parc/algol/parc_JSONParser.h>
+
+#include <parc/algol/parc_BufferComposer.h>
+#include <parc/algol/parc_Object.h>
+
+struct parc_buffer_parser {
+    char *ignore;
+    PARCBuffer *buffer;
+};
+
+static PARCBuffer *
+_getBuffer(const PARCJSONParser *parser)
+{
+    return parser->buffer;
+}
+
+static void
+_destroyPARCBufferParser(PARCJSONParser **instancePtr)
+{
+    PARCJSONParser *parser = *instancePtr;
+    parcBuffer_Release(&parser->buffer);
+}
+
+parcObject_ExtendPARCObject(PARCJSONParser, _destroyPARCBufferParser, NULL, NULL, NULL, NULL, NULL, NULL);
+
+PARCJSONParser *
+parcJSONParser_Create(PARCBuffer *buffer)
+{
+    PARCJSONParser *result = parcObject_CreateInstance(PARCJSONParser);
+    result->ignore = " \t\n";
+    result->buffer = parcBuffer_Acquire(buffer);
+    return result;
+}
+
+void
+parcJSONParser_AssertValid(const PARCJSONParser *parser)
+{
+    assertNotNull(parser, "PARCJSONParser cannot be NULL");
+    parcBuffer_OptionalAssertValid(parser->buffer);
+}
+
+parcObject_ImplementAcquire(parcJSONParser, PARCJSONParser);
+
+parcObject_ImplementRelease(parcJSONParser, PARCJSONParser);
+
+void
+parcJSONParser_SkipIgnored(PARCJSONParser *parser)
+{
+    parcJSONParser_OptionalAssertValid(parser);
+
+    parcBuffer_SkipOver(parser->buffer, strlen(parser->ignore), (uint8_t *) parser->ignore);
+}
+
+char
+parcJSONParser_NextChar(PARCJSONParser *parser)
+{
+    parcJSONParser_SkipIgnored(parser);
+    return (char) parcBuffer_GetUint8(parser->buffer);
+}
+
+bool
+parcJSONParser_Next(PARCJSONParser *parser, char *value)
+{
+    bool result = false;
+    parcJSONParser_SkipIgnored(parser);
+    if (parcJSONParser_Remaining(parser) > 0) {
+        *value = (char) parcBuffer_GetUint8(parser->buffer);
+        result = true;
+    }
+    return result;
+}
+
+char
+parcJSONParser_PeekNextChar(PARCJSONParser *parser)
+{
+    parcJSONParser_SkipIgnored(parser);
+    return (char) parcBuffer_PeekByte(parser->buffer);
+}
+
+void
+parcJSONParser_Advance(PARCJSONParser *parser, long bytes)
+{
+    parcJSONParser_OptionalAssertValid(parser);
+
+    parcBuffer_SetPosition(parser->buffer, parcBuffer_Position(parser->buffer) + bytes);
+}
+
+size_t
+parcJSONParser_Remaining(const PARCJSONParser *parser)
+{
+    parcJSONParser_OptionalAssertValid(parser);
+
+    return parcBuffer_Remaining(parser->buffer);
+}
+
+bool
+parcJSONParser_RequireString(PARCJSONParser *parser, const char *string)
+{
+    PARCBuffer *buffer = _getBuffer(parser);
+
+    for (const char *requiredCharacter = string; *requiredCharacter != 0; requiredCharacter++) {
+        uint8_t actualCharacter = parcBuffer_GetUint8(buffer);
+        if (actualCharacter != *requiredCharacter) {
+            return false;
+        }
+    }
+    return true;
+}
+
+PARCBuffer *
+parcJSONParser_ParseString(PARCJSONParser *parser)
+{
+    PARCBuffer *result = NULL;
+
+    PARCBuffer *buffer = _getBuffer(parser);
+    if (parcBuffer_GetUint8(buffer) == '"') { // skip the initial '"' character starting the string.
+        PARCBufferComposer *composer = parcBufferComposer_Create();
+
+        while (parcBuffer_Remaining(buffer)) {
+            uint8_t c = parcBuffer_GetUint8(buffer);
+            if (c == '"') {
+                // This is the only successful way to exit this while loop.
+                result = parcBufferComposer_ProduceBuffer(composer);
+                break;
+            } else if (c == '\\') {
+                c = parcBuffer_GetUint8(buffer);
+                if (c == '"') {
+                    // this special character passes directly into the composed string.
+                } else if (c == '\\') {
+                    // this special character passes directly into the composed string.
+                } else if (c == '/') {
+                    // this special character passes directly into the composed string.
+                } else if (c == 'b') {
+                    c = '\b';
+                } else if (c == 'f') {
+                    c = '\f';
+                } else if (c == 'n') {
+                    c = '\n';
+                } else if (c == 'r') {
+                    c = '\r';
+                } else if (c == 't') {
+                    c = '\t';
+                } else if (c == 'u') {
+                    // Not supporting unicode at this point.
+                    trapNotImplemented("Unicode is not supported.");
+                }
+            } else if (iscntrl(c)) {
+                // !! Syntax Error.
+                break;
+            }
+            parcBufferComposer_PutChar(composer, c);
+        }
+
+        parcBufferComposer_Release(&composer);
+    }
+    return result;
+}