OSSP CVS Repository

ossp - Check-in [4179]
Not logged in 		[Honeypot]  [Browse]  [Home]  [Login]  [Reports] 
[Search]  [Ticket]  [Timeline] 
  [Patchset]  [Tagging/Branching] 

Check-in Number: 4179
Date: 2001-Jul-09 19:19:58 (local)
2001-Jul-09 17:19:58 (UTC)
User:simons
Branch:
Comment: Implemented xds_encode() and xds_vencode().
Tickets:
Inspections:
Files:
ossp-pkg/xds/encode.c      1.1->removed
ossp-pkg/xds/vencode.c      1.1 -> 1.2     132 inserted, 2 deleted
ossp-pkg/xds/encode.c 1.1 -> 1.2 

--- encode.c     2001/07/04 15:58:51     1.1
+++ encode.c     2001/07/09 17:19:58     1.2
@@ -29,5 +29,10 @@
 
 int xds_encode(xds_t* xds, const char* fmt, ...)
     {
-    return XDS_ERR_INVALID_ARG;
+    int rc;
+    va_list args;
+    va_start(args, fmt);
+    rc = xds_vencode(xds, fmt, args);
+    va_end(args);
+    return rc;
     }

ossp-pkg/xds/vencode.c 1.1 -> 1.2 

--- vencode.c    2001/07/04 15:58:51     1.1
+++ vencode.c    2001/07/09 17:19:58     1.2
@@ -25,9 +25,139 @@
    SUCH DAMAGE.
 */
 
+#include <stdio.h>              /* delete me */
+
+#include <string.h>
+#include <ctype.h>
+#include <assert.h>
 #include "internal.h"
 
-int xds_vencode(xds_t* xds, const char* fmt, va_list args)
+int xds_vencode(xds_t* xds, const char* fmt_arg, va_list args)
     {
-    return XDS_ERR_INVALID_ARG;
+    char* name;
+    char* p;
+    char* fmt;
+    int rc;
+
+    /* Sanity checks. */
+
+    assert(xds != NULL);
+    assert(fmt_arg != NULL);
+    assert(xds->mode == XDS_ENCODE);
+    if (xds == NULL || fmt_arg == NULL)
+        return XDS_ERR_INVALID_ARG;
+    if (xds->mode != XDS_ENCODE)
+        return XDS_ERR_INVALID_MODE;
+
+    /* Ensure we have a buffer allocated ready for use. */
+
+    if (xds->buffer == NULL)
+        {                       /* allocate a new buffer */
+        int rc = xds_set_capacity((void**)&xds->buffer,
+                                  &xds->buffer_capacity,
+                                  XDS_INITIAL_BUFFER_CAPACITY,
+                                  sizeof(char),
+                                  XDS_INITIAL_BUFFER_CAPACITY);
+        assert(rc == XDS_OK || rc == XDS_ERR_NO_MEM);
+        if (rc != XDS_OK)
+            return rc;
+        printf("Enlarged buffer to %d byte.\n", xds->buffer_capacity);
+        xds->buffer_len    = 0;
+        xds->we_own_buffer = (1==1);
+        }
+
+    /* Ensure the buffer has free space. */
+
+    assert(xds->buffer_len <= xds->buffer_capacity);
+    if (xds->buffer_len == xds->buffer_capacity)
+        {
+        if (xds->we_own_buffer)
+            {
+            int rc = xds_set_capacity((void**)&xds->buffer,
+                                      &xds->buffer_capacity,
+                                      xds->buffer_len + 1,
+                                      sizeof(char),
+                                      XDS_INITIAL_BUFFER_CAPACITY);
+            assert(rc == XDS_OK || rc == XDS_ERR_NO_MEM);
+            if (rc != XDS_OK)
+                return rc;
+            printf("Enlarged buffer to %d byte.\n", xds->buffer_capacity);
+            }
+        else
+            return XDS_ERR_OVERFLOW;
+        }
+
+    /* Iterate through the items in the format string and execute the
+       apropriate engines. */
+
+    fmt = p = strdup(fmt_arg);
+    if (fmt == NULL)
+        return XDS_ERR_NO_MEM;
+    for(name = p; *p != '\0'; name = p)
+        {
+        while(isalnum(*p) || *p == '-' || *p == '_')
+            ++p;
+        *p++ = '\0';
+
+        if (strlen(name) > 0)
+            {
+            size_t pos;
+            if (xds_find_engine(xds->engines, xds->engines_len, name, &pos))
+                {
+                int restart_engine;
+                do
+                    {
+                    printf("Executing engine '%s' ...\n", name);
+                    rc = (*xds->engines[pos].engine)(xds,
+                                                     xds->engines[pos].context,
+                                                     xds->buffer + xds->buffer_len,
+                                                     xds->buffer_capacity - xds->buffer_len,
+                                                     args);
+                    if (rc < 0)
+                        goto leave;
+                    else if (rc >= xds->buffer_capacity - xds->buffer_len)
+                        {               /* enlarge buffer */
+                        int rc2;
+
+                        if (!xds->we_own_buffer)
+                            {
+                            rc = XDS_ERR_OVERFLOW;
+                            goto leave;
+                            }
+
+                        rc2 = xds_set_capacity((void**)&xds->buffer,
+                                               &xds->buffer_capacity,
+                                               xds->buffer_capacity + rc,
+                                               sizeof(char),
+                                               XDS_INITIAL_BUFFER_CAPACITY);
+                        assert(rc2 == XDS_OK || rc2 == XDS_ERR_NO_MEM);
+                        if (rc2 != XDS_OK)
+                            {
+                            rc = rc2;
+                            goto leave;
+                            }
+                        restart_engine = (1==1);
+                        printf("Enlarged buffer to %d byte.\n", xds->buffer_capacity);
+                        }
+                    else
+                        {
+                        restart_engine = (1!=1);
+                        xds->buffer_len += rc;
+                        }
+                    }
+                while (restart_engine);
+                }
+            else
+                {
+                rc = XDS_ERR_UNKNOWN_ENGINE;
+                goto leave;
+                }
+            }
+        }
+    rc = XDS_OK;
+
+    /* Clean up and leave. */
+  leave:
+    free(fmt);
+    return rc;
     }

CVSTrac 2.0.1