Drop `assert()´ check in subpath parsing

[CGirls] / request.c

diff --git a/request.c b/request.c
index 25f962599b354cf4c588766d39d6f9cb5cceb2e7..f9fa453a85931e48326a6eb96c9ea57b718d6ae0 100644 (file)
--- a/request.c
+++ b/request.c
@@ -4,23 +4,46 @@
 #include "aa.h"
 #include "request.h"
 
 #include "aa.h"
 #include "request.h"
 

-void cgirls_freereq (cgirls_req req) {
-       free(req.cgirls_project);
-       free(req.cgirls_id);
-       if (req.cgirls_subpath) {
+static char const*const cgirls_mtypes[] = {
+       [cgirls_mtype_txt] = ".txt",
+       [cgirls_mtype_htm] = ".htm",
+       [cgirls_mtype_xml] = ".xml",
+       [cgirls_mtype_rdf] = ".rdf",
+};
+constexpr size_t cgirls_n·mtypes =
+       sizeof(cgirls_mtypes) / sizeof(char*);
+
+static char const*const cgirls_vbs[] = {
+       [cgirls_vb_unknown] = "unknown",
+       [cgirls_vb_index] = "index",
+       [cgirls_vb_show] = "show",
+};
+constexpr size_t cgirls_n·vbs =
+       sizeof(cgirls_vbs) / sizeof(char*);
+static cgirls_vb const cgirls_parsable·vbs[] = {
+       cgirls_vb_index,
+       cgirls_vb_show,
+};
+constexpr size_t cgirls_n·parsable·vbs =
+       sizeof(cgirls_parsable·vbs) / sizeof(cgirls_vb);
+
+void cgirls_req·free (cgirls_req req) {
+       free(req.project);
+       free(req.id_THIS_WILL_CHANGE);
+       if (req.subpath) {

                size_t i = 0;
                size_t i = 0;

-               char* c = req.cgirls_subpath[i];
+               char* c = req.subpath[i];

                while (c) {
                        free(c);
                while (c) {
                        free(c);

-                       c = req.cgirls_subpath[++i];
+                       c = req.subpath[++i];

                }
                }

-               free(req.cgirls_subpath);
+               free(req.subpath);

        }
        }

-       free(req.cgirls_baseid);
-       free(req.cgirls_status.cgirls_message);
+       free(req.baseid_THIS_WILL_CHANGE);
+       free(req.status.message);

 }
 
 }
 

-char* cgirls_gobblepath(char const* ndx[1], char const*const end[1]) {
+static char* cgirls_gobble·path(char const* ndx[1], char const*const end[1]) {

        char const* eor = strchr(ndx[0], '/');
        char* result = nullptr;
        if (!eor) {
        char const* eor = strchr(ndx[0], '/');
        char* result = nullptr;
        if (!eor) {


@@ -37,20 +60,20 @@ char* cgirls_gobblepath(char const* ndx[1], char const*const end[1]) {
        return result;
 }
 
        return result;
 }
 

-cgirls_req cgirls_path2req(char const*const pathinfo) {
+cgirls_req cgirls_path·to·req(char const*const pathinfo) {

        assert(pathinfo != nullptr);
 
        // Initialize the result.
        cgirls_req req = {
        assert(pathinfo != nullptr);
 
        // Initialize the result.
        cgirls_req req = {

-               .cgirls_action = cgirls_vb_unknown,
-               .cgirls_type = cgirls_mtype_any,
-               .cgirls_project = nullptr,
-               .cgirls_id = nullptr,
-               .cgirls_subpath = nullptr,
-               .cgirls_baseid = nullptr,
-               .cgirls_status = {
-                       .cgirls_code = 200,
-                       .cgirls_message = nullptr,
+               .verb = cgirls_vb_unknown,
+               .mtype = cgirls_mtype_any,
+               .project = nullptr,
+               .id_THIS_WILL_CHANGE = nullptr,
+               .subpath = nullptr,
+               .baseid_THIS_WILL_CHANGE = nullptr,
+               .status = {
+                       .code = 200,
+                       .message = nullptr,

                },
        };
 
                },
        };
 


@@ -64,7 +87,7 @@ cgirls_req cgirls_path2req(char const*const pathinfo) {
        // the project of the request. If there is no first slash, the
        // project extends to the end of the string. An empty string is
        // equivalent to having no project.
        // the project of the request. If there is no first slash, the
        // project extends to the end of the string. An empty string is
        // equivalent to having no project.

-       req.cgirls_project = cgirls_gobblepath(ndx, end);
+       req.project = cgirls_gobble·path(ndx, end);

 
        // The portion of the pathinfo which follows the first slash but
        // precedes the second gives the action of the request. If there is
 
        // The portion of the pathinfo which follows the first slash but
        // precedes the second gives the action of the request. If there is


@@ -80,7 +103,7 @@ cgirls_req cgirls_path2req(char const*const pathinfo) {
        // constants). If a verb is present, but unrecognized, it is assigned
        // the special value `cgirls_vb_unknown´, which should generally be
        // interpreted as an error.
        // constants). If a verb is present, but unrecognized, it is assigned
        // the special value `cgirls_vb_unknown´, which should generally be
        // interpreted as an error.

-       char* soa = cgirls_gobblepath(ndx, end);
+       char* soa = cgirls_gobble·path(ndx, end);

        if (soa) {
                char*const eoa = strchr(soa, 0);
                if (eoa - soa > 4) {
        if (soa) {
                char*const eoa = strchr(soa, 0);
                if (eoa - soa > 4) {


@@ -88,10 +111,10 @@ cgirls_req cgirls_path2req(char const*const pathinfo) {
                        // present (it will be the last 4). Then set the first character
                        // of the extension to null, effectively trimming the verb.
                        char* ext = eoa - 4;
                        // present (it will be the last 4). Then set the first character
                        // of the extension to null, effectively trimming the verb.
                        char* ext = eoa - 4;

-                       for (size_t i = 0; i < cgirls_n·mtypes; ++i) {
-                               cgirls_mtype ixt = cgirls_mtypes[i];
-                               if (strncmp(ext, ixt, 4) == 0) {
-                                       req.cgirls_type = ixt;
+                       for (cgirls_mtype i = 0; i < cgirls_n·mtypes; ++i) {
+                               char const*const ixt = cgirls_mtypes[i];
+                               if (ixt && strncmp(ext, ixt, 4) == 0) {
+                                       req.mtype = i;

                                        ext[0] = 0;
                                        break;
                                }
                                        ext[0] = 0;
                                        break;
                                }


@@ -99,14 +122,15 @@ cgirls_req cgirls_path2req(char const*const pathinfo) {
                }
                for (size_t i = 0; i < cgirls_n·parsable·vbs; ++i) {
                        cgirls_vb ivb = cgirls_parsable·vbs[i];
                }
                for (size_t i = 0; i < cgirls_n·parsable·vbs; ++i) {
                        cgirls_vb ivb = cgirls_parsable·vbs[i];

-                       if (strcmp(soa, ivb) == 0) {
-                               req.cgirls_action = ivb;
+                       char const*const svb = cgirls_vbs[ivb];
+                       if (svb && strcmp(soa, svb) == 0) {
+                               req.verb = ivb;

                                break;
                        }
                }
                free(soa);
        } else if (ndx[0] == end[0]) {
                                break;
                        }
                }
                free(soa);
        } else if (ndx[0] == end[0]) {

-               req.cgirls_action = cgirls_vb_index;
+               req.verb = cgirls_vb_index;

        }
 
        // The portion of the pathinfo which follows the second slash but
        }
 
        // The portion of the pathinfo which follows the second slash but


@@ -115,7 +139,7 @@ cgirls_req cgirls_path2req(char const*const pathinfo) {
        // string. A single identifier may be given, or two identifiers may
        // be given separated by two periods. An empty string is equivalent
        // to no identifier.
        // string. A single identifier may be given, or two identifiers may
        // be given separated by two periods. An empty string is equivalent
        // to no identifier.

-       char* idid = cgirls_gobblepath(ndx, end);
+       char* idid = cgirls_gobble·path(ndx, end);

        if (idid) {
                // If the identifier string contains two successive dots, the base
                // and target identifiers must be extracted and the original
        if (idid) {
                // If the identifier string contains two successive dots, the base
                // and target identifiers must be extracted and the original


@@ -126,24 +150,27 @@ cgirls_req cgirls_path2req(char const*const pathinfo) {
                        char const*const eods = dots + 2;
                        char const*const eoii = strchr(idid, 0);
                        if (dots > idid) {
                        char const*const eods = dots + 2;
                        char const*const eoii = strchr(idid, 0);
                        if (dots > idid) {

-                               req.cgirls_baseid = strndup(idid, dots - idid);
+                               req.baseid_THIS_WILL_CHANGE = strndup(idid, dots - idid);

                        }
                        if (eods < eoii) {
                        }
                        if (eods < eoii) {

-                               req.cgirls_id = strndup(eods, eoii - eods);
+                               req.id_THIS_WILL_CHANGE = strndup(eods, eoii - eods);

                        }
                        free(idid);
                } else {
                        }
                        free(idid);
                } else {

-                       req.cgirls_id = idid;
+                       req.id_THIS_WILL_CHANGE = idid;

                }
        }
 
        // The portion of the pathinfo which follows the third slash is the
        // subpath of the request. An empty sting is equivalent to having no
        // subpath. Trailing and successive slashes are dropped.
                }
        }
 
        // The portion of the pathinfo which follows the third slash is the
        // subpath of the request. An empty sting is equivalent to having no
        // subpath. Trailing and successive slashes are dropped.

-       char const* sos = ndx[0];

        char const* sep = nullptr;
        size_t n·s = 0;
        char const* sep = nullptr;
        size_t n·s = 0;

-       while (end[0] > sos) {
+       for (
+               char const* sos = ndx[0];
+               sos < end[0];
+               sos = (end[0] > sep ? sep + 1 : end[0])
+       ) {

                // Count the number of segments in the pathinfo so that the correct
                // amount of space can be allocated.
                sep = strchr(sos, '/');
                // Count the number of segments in the pathinfo so that the correct
                // amount of space can be allocated.
                sep = strchr(sos, '/');


@@ -153,70 +180,74 @@ cgirls_req cgirls_path2req(char const*const pathinfo) {
                if (sep > sos) {
                        ++n·s;
                }
                if (sep > sos) {
                        ++n·s;
                }

-               if (end[0] > sep) {
-                       sos = sep + 1;
-               } else {
-                       sos = end[0];
-               }
-       }
-       req.cgirls_subpath = calloc(n·s + 1, sizeof(char*));
-       if (!req.cgirls_subpath) {
-               return req;

        }
        }

-       size_t i·s = 0;
-       while (end[0] > ndx[0]) {
-               // Add the segments to the newly allocated array.
-               sep = strchr(ndx[0], '/');
-               if (!sep) {
-                       sep = end[0];
-               }
-               if (sep > ndx[0]) {
-                       req.cgirls_subpath[i·s++] = strndup(ndx[0], sep - ndx[0]);
+       if (n·s > 0) {
+               req.subpath = calloc(n·s + 1, sizeof(char*));
+               if (!req.subpath) {
+                       return req;

                }
                }

-               if (end[0] > sep) {
-                       ndx[0] = sep + 1;
-               } else {
-                       ndx[0] = end[0];
+               for (
+                       size_t i·s = 0;
+                       i·s < n·s;
+                       ndx[0] = (end[0] > sep ? sep + 1 : end[0])
+               ) {
+                       // Add the segments to the newly allocated array.
+                       sep = strchr(ndx[0], '/');
+                       if (!sep) {
+                               sep = end[0];
+                       }
+                       if (sep > ndx[0]) {
+                               req.subpath[i·s++] = strndup(ndx[0], sep - ndx[0]);
+                       }

                }
                }

+               req.subpath[n·s] = nullptr;

        }
        }

-       assert(i·s == n·s);
-       req.cgirls_subpath[i·s] = nullptr;

 
        // Return the result.
        return req;
 }
 
 
        // Return the result.
        return req;
 }
 

-char* cgirls_req2path(cgirls_req req) {
-       cgirls_vb vb = cgirls_vb_index;
-       bool has·ids = req.cgirls_baseid || req.cgirls_id;
-       bool has·type = req.cgirls_type;
-       bool has·subpath = req.cgirls_subpath && req.cgirls_subpath[0];
+char* cgirls_req·to·path(cgirls_req req) {
+       char const* vb = nullptr;
+       char const* mtype = nullptr;
+       bool has·ids = req.baseid_THIS_WILL_CHANGE || req.id_THIS_WILL_CHANGE;
+       bool has·subpath = req.subpath && req.subpath[0];

        size_t length = 0;
 
        size_t length = 0;
 

+       // Get the string corresponding to the verb. Do not assume that the
+       // verb is welbehaved (actually corresponding to an enumeration
+       // constant).
+       if (req.verb < cgirls_n·vbs) {
+               vb = cgirls_vbs[req.verb];
+       }
+       if (!vb) {
+               vb = cgirls_vbs[cgirls_vb_unknown];
+       }
+
+       // Get the string corresponding to the mediatype, or `nullptr´. Do
+       // not assume that the verb is welbehaved (actually corresponding to
+       // an enumeration constant).
+       if (req.mtype < cgirls_n·mtypes) {
+               mtype = cgirls_mtypes[req.mtype];
+       }
+

        // Get the length of the various parts. This length includes a
        // trailing slash, but in practice this will be replaced by the final
        // null byte.
        // Get the length of the various parts. This length includes a
        // trailing slash, but in practice this will be replaced by the final
        // null byte.

-       if (req.cgirls_project) {
-               length += strlen(req.cgirls_project) + 1;
-               for (size_t i = 0; i < cgirls_n·vbs; ++i) {
-                       cgirls_vb ivb = cgirls_vbs[i];
-                       if (req.cgirls_action == ivb) {
-                               vb = ivb;
-                               break;
-                       }
-               }
-               if (vb != cgirls_vb_index || has·type || has·ids || has·subpath) {
+       if (req.project) {
+               length += strlen(req.project) + 1;
+               if (req.verb != cgirls_vb_index || mtype || has·ids || has·subpath) {

                        length += strlen(vb) + 1;
                }
                        length += strlen(vb) + 1;
                }

-               if (has·type) {
-                       length += strlen(req.cgirls_type);
+               if (mtype) {
+                       length += strlen(mtype);

                }
                if (has·ids) {
                }
                if (has·ids) {

-                       if (req.cgirls_baseid) {
-                               length += strlen(req.cgirls_baseid) + 2;
+                       if (req.baseid_THIS_WILL_CHANGE) {
+                               length += strlen(req.baseid_THIS_WILL_CHANGE) + 2;

                        }
                        }

-                       if (req.cgirls_id) {
-                               length += strlen(req.cgirls_id);
+                       if (req.id_THIS_WILL_CHANGE) {
+                               length += strlen(req.id_THIS_WILL_CHANGE);

                        }
                        length += 1;
                } else if (has·subpath) {
                        }
                        length += 1;
                } else if (has·subpath) {


@@ -224,10 +255,10 @@ char* cgirls_req2path(cgirls_req req) {
                }
                if (has·subpath) {
                        size_t i = 0;
                }
                if (has·subpath) {
                        size_t i = 0;

-                       char* c = req.cgirls_subpath[i];
+                       char* c = req.subpath[i];

                        while (c) {
                                length += strlen(c) + 1;
                        while (c) {
                                length += strlen(c) + 1;

-                               c = req.cgirls_subpath[++i];
+                               c = req.subpath[++i];

                        }
                }
        } else {
                        }
                }
        } else {


@@ -241,23 +272,23 @@ char* cgirls_req2path(cgirls_req req) {
                return nullptr;
        }
        char* cursor = result;
                return nullptr;
        }
        char* cursor = result;

-       if (req.cgirls_project) {
-               cursor = stpcpy(cursor, req.cgirls_project);
+       if (req.project) {
+               cursor = stpcpy(cursor, req.project);

                (cursor++)[0] = '/';
                (cursor++)[0] = '/';

-               if (vb != cgirls_vb_index || has·type || has·ids || has·subpath) {
+               if (req.verb != cgirls_vb_index || mtype || has·ids || has·subpath) {

                        cursor = stpcpy(cursor, vb);
                        cursor = stpcpy(cursor, vb);

-                       if (has·type) {
-                               cursor = stpcpy(cursor, req.cgirls_type);
+                       if (mtype) {
+                               cursor = stpcpy(cursor, mtype);

                        }
                        (cursor++)[0] = '/';
                }
                if (has·ids) {
                        }
                        (cursor++)[0] = '/';
                }
                if (has·ids) {

-                       if (req.cgirls_baseid) {
-                               cursor = stpcpy(cursor, req.cgirls_baseid);
+                       if (req.baseid_THIS_WILL_CHANGE) {
+                               cursor = stpcpy(cursor, req.baseid_THIS_WILL_CHANGE);

                                cursor = stpcpy(cursor, "..");
                        }
                                cursor = stpcpy(cursor, "..");
                        }

-                       if (req.cgirls_id) {
-                               cursor = stpcpy(cursor, req.cgirls_id);
+                       if (req.id_THIS_WILL_CHANGE) {
+                               cursor = stpcpy(cursor, req.id_THIS_WILL_CHANGE);

                        }
                        (cursor++)[0] = '/';
                } else if (has·subpath) {
                        }
                        (cursor++)[0] = '/';
                } else if (has·subpath) {


@@ -265,10 +296,10 @@ char* cgirls_req2path(cgirls_req req) {
                }
                if (has·subpath) {
                        size_t i = 0;
                }
                if (has·subpath) {
                        size_t i = 0;

-                       char* c = req.cgirls_subpath[i];
+                       char* c = req.subpath[i];

                        while (c) {
                                cursor = stpcpy(cursor, c);
                        while (c) {
                                cursor = stpcpy(cursor, c);

-                               c = req.cgirls_subpath[++i];
+                               c = req.subpath[++i];

                                (cursor++)[0] = '/';
                        }
                }
                                (cursor++)[0] = '/';
                        }
                }