Back to index

lightning-sunbird  0.9+nobinonly
Classes | Defines | Typedefs | Functions | Variables
nameprep.c File Reference
#include <stdlib.h>
#include <string.h>
#include "nsIDNKitInterface.h"
#include "nameprepdata.c"
#include "nameprep_template.c"

Go to the source code of this file.

Classes

struct  idn_nameprep

Defines

#define UCS_MAX   0x7fffffff
#define UNICODE_MAX   0x10ffff
#define VERSION   id11
#define MAKE_NAMEPREP_HANDLE(version, id)

Typedefs

typedef const char *(* nameprep_mapproc )(PRUint32 v)
typedef int(* nameprep_checkproc )(PRUint32 v)
typedef idn_biditype_t(* nameprep_biditypeproc )(PRUint32 v)

Functions

static idn_result_t idn_nameprep_check (nameprep_checkproc proc, const PRUint32 *str, const PRUint32 **found)
idn_result_t idn_nameprep_create (const char *version, idn_nameprep_t *handlep)
void idn_nameprep_destroy (idn_nameprep_t handle)
idn_result_t idn_nameprep_map (idn_nameprep_t handle, const PRUint32 *from, PRUint32 *to, size_t tolen)
idn_result_t idn_nameprep_isprohibited (idn_nameprep_t handle, const PRUint32 *str, const PRUint32 **found)
idn_result_t idn_nameprep_isunassigned (idn_nameprep_t handle, const PRUint32 *str, const PRUint32 **found)
idn_result_t idn_nameprep_isvalidbidi (idn_nameprep_t handle, const PRUint32 *str, const PRUint32 **found)
idn_result_t idn_nameprep_createproc (const char *parameter, void **handlep)
void idn_nameprep_destroyproc (void *handle)
idn_result_t idn_nameprep_mapproc (void *handle, const PRUint32 *from, PRUint32 *to, size_t tolen)
idn_result_t idn_nameprep_prohibitproc (void *handle, const PRUint32 *str, const PRUint32 **found)
idn_result_t idn_nameprep_unassignedproc (void *handle, const PRUint32 *str, const PRUint32 **found)
idn_result_t idn_nameprep_bidiproc (void *handle, const PRUint32 *str, const PRUint32 **found)

Variables

static struct idn_nameprep nameprep_versions []

Class Documentation

struct idn_nameprep

Definition at line 71 of file nameprep.c.

Class Members
nameprep_biditypeproc biditype_proc
nameprep_mapproc map_proc
nameprep_checkproc prohibited_proc
nameprep_checkproc unassigned_proc
char * version

Define Documentation

Value:
{ version, \
         compose_sym2(nameprep_map_, id), \
         compose_sym2(nameprep_prohibited_, id), \
         compose_sym2(nameprep_unassigned_, id), \
         compose_sym2(nameprep_biditype_, id), }
#define UCS_MAX   0x7fffffff

Definition at line 50 of file nameprep.c.

#define UNICODE_MAX   0x10ffff

Definition at line 51 of file nameprep.c.

#define VERSION   id11

Definition at line 63 of file nameprep.c.


Typedef Documentation

Definition at line 69 of file nameprep.c.

Definition at line 68 of file nameprep.c.

typedef const char*(* nameprep_mapproc)(PRUint32 v)

Definition at line 67 of file nameprep.c.


Function Documentation

idn_result_t idn_nameprep_bidiproc ( void handle,
const PRUint32 str,
const PRUint32 **  found 
)

Definition at line 344 of file nameprep.c.

Here is the call graph for this function:

static idn_result_t idn_nameprep_check ( nameprep_checkproc  proc,
const PRUint32 str,
const PRUint32 **  found 
) [static]

Definition at line 214 of file nameprep.c.

                                         {
       PRUint32 v;

       while (*str != '\0') {
              v = *str;

              if (v > UCS_MAX) {
                     /* This cannot happen, but just in case.. */
                     return (idn_invalid_codepoint);
              } else if (v > UNICODE_MAX) {
                     /* It is invalid.. */
                     *found = str;
                     return (idn_success);
              } else if ((*proc)(v)) {
                     *found = str;
                     return (idn_success);
              }
              str++;
       }
       *found = NULL;
       return (idn_success);
}

Here is the caller graph for this function:

idn_result_t idn_nameprep_create ( const char *  version,
idn_nameprep_t handlep 
)

Definition at line 93 of file nameprep.c.

                                                                  {
       idn_nameprep_t handle;

       assert(handlep != NULL);

       TRACE(("idn_nameprep_create(version=%-.50s)\n",
              version == NULL ? "<NULL>" : version));

       if (version == NULL)
              version = IDN_NAMEPREP_CURRENT;

       /*
        * Lookup table for the specified version.  Since the number of
        * versions won't be large (I don't want see draft-23 or such :-),
        * simple linear search is OK.
        */
       for (handle = nameprep_versions; handle->version != NULL; handle++) {
              if (strcmp(handle->version, version) == 0) {
                     *handlep = handle;
                     return (idn_success);
              }
       }
       return (idn_notfound);
}

Here is the caller graph for this function:

idn_result_t idn_nameprep_createproc ( const char *  parameter,
void **  handlep 
)

Definition at line 316 of file nameprep.c.

                                                               {
       return idn_nameprep_create(parameter, (idn_nameprep_t *)handlep);
}

Here is the call graph for this function:

Definition at line 119 of file nameprep.c.

                                            {
       assert(handle != NULL);

       TRACE(("idn_nameprep_destroy()\n"));

       /* Nothing to do. */
}

Here is the caller graph for this function:

Definition at line 321 of file nameprep.c.

Here is the call graph for this function:

Definition at line 192 of file nameprep.c.

                                               {
       assert(handle != NULL && str != NULL && found != NULL);

       TRACE(("idn_nameprep_isprohibited(ctx=%s, str=\"%s\")\n",
              handle->version, idn__debug_ucs4xstring(str, 50)));

       return (idn_nameprep_check(handle->prohibited_proc, str, found));
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 203 of file nameprep.c.

                                               {
       assert(handle != NULL && str != NULL && found != NULL);

       TRACE(("idn_nameprep_isunassigned(handle->version, str=\"%s\")\n",
              handle->version, idn__debug_ucs4xstring(str, 50)));

       return (idn_nameprep_check(handle->unassigned_proc, str, found));
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 239 of file nameprep.c.

                                              {
       PRUint32 v;
       idn_biditype_t first_char;
       idn_biditype_t last_char;
       int found_r_al;

       assert(handle != NULL && str != NULL && found != NULL);

       TRACE(("idn_nameprep_isvalidbidi(ctx=%s, str=\"%s\")\n",
              handle->version, idn__debug_ucs4xstring(str, 50)));

       if (*str == '\0') {
              *found = NULL;
              return (idn_success);
       }

       /*
        * check first character's type and initialize variables.
        */
       found_r_al = 0;
       if (*str > UCS_MAX) {
              /* This cannot happen, but just in case.. */
              return (idn_invalid_codepoint);
       } else if (*str > UNICODE_MAX) {
              /* It is invalid.. */
              *found = str;
              return (idn_success);
       }
       first_char = last_char = (*(handle->biditype_proc))(*str);
       if (first_char == idn_biditype_r_al) {
              found_r_al = 1;
       }
       str++;

       /*
        * see whether string is valid or not.
        */
       while (*str != '\0') {
              v = *str;

              if (v > UCS_MAX) {
                     /* This cannot happen, but just in case.. */
                     return (idn_invalid_codepoint);
              } else if (v > UNICODE_MAX) {
                     /* It is invalid.. */
                     *found = str;
                     return (idn_success);
              } else { 
                     last_char = (*(handle->biditype_proc))(v);
                     if (found_r_al && last_char == idn_biditype_l) {
                            *found = str;
                            return (idn_success);
                     }
                     if (first_char != idn_biditype_r_al && last_char == idn_biditype_r_al) {
                            *found = str;
                            return (idn_success);
                     }
                     if (last_char == idn_biditype_r_al) {
                            found_r_al = 1;
                     }
              }
              str++;
       }

       if (found_r_al) {
              if (last_char != idn_biditype_r_al) {
                     *found = str - 1;
                     return (idn_success);
              }
       }

       *found = NULL;
       return (idn_success);
}

Here is the caller graph for this function:

idn_result_t idn_nameprep_map ( idn_nameprep_t  handle,
const PRUint32 from,
PRUint32 to,
size_t  tolen 
)

Definition at line 128 of file nameprep.c.

                                           {
       assert(handle != NULL && from != NULL && to != NULL);

       TRACE(("idn_nameprep_map(ctx=%s, from=\"%s\")\n",
              handle->version, idn__debug_ucs4xstring(from, 50)));

       while (*from != '\0') {
              PRUint32 v = *from;
              const char *mapped;

              if (v > UCS_MAX) {
                     /* This cannot happen, but just in case.. */
                     return (idn_invalid_codepoint);
              } else if (v > UNICODE_MAX) {
                     /* No mapping is possible. */
                     mapped = NULL;
              } else {
                     /* Try mapping. */
                     mapped = (*handle->map_proc)(v);
              }

              if (mapped == NULL) {
                     /* No mapping. Just copy verbatim. */
                     if (tolen < 1)
                            return (idn_buffer_overflow);
                     *to++ = v;
                     tolen--;
              } else {
                     const unsigned char *mappeddata;
                     size_t mappedlen;

                     mappeddata = (const unsigned char *)mapped + 1;
                     mappedlen = *mapped;

                     if (tolen < (mappedlen + 3) / 4)
                            return (idn_buffer_overflow);
                     tolen -= (mappedlen + 3) / 4;
                     while (mappedlen >= 4) {
                            *to  = *mappeddata++;
                            *to |= *mappeddata++ <<  8;
                            *to |= *mappeddata++ << 16;
                            *to |= *mappeddata++ << 24;
                            mappedlen -= 4;
                            to++;
                     }
                     if (mappedlen > 0) {
                            *to  = *mappeddata++;
                            *to |= (mappedlen >= 2) ?
                                   *mappeddata++ <<  8: 0;
                            *to |= (mappedlen >= 3) ?
                                   *mappeddata++ << 16: 0;
                            to++;
                     }
              }
              from++;
       }
       if (tolen == 0)
              return (idn_buffer_overflow);
       *to = '\0';
       return (idn_success);
}

Here is the caller graph for this function:

idn_result_t idn_nameprep_mapproc ( void handle,
const PRUint32 from,
PRUint32 to,
size_t  tolen 
)

Definition at line 326 of file nameprep.c.

                                                {
       return idn_nameprep_map((idn_nameprep_t)handle, from, to, tolen);
}

Here is the call graph for this function:

idn_result_t idn_nameprep_prohibitproc ( void handle,
const PRUint32 str,
const PRUint32 **  found 
)

Definition at line 332 of file nameprep.c.

Here is the call graph for this function:

idn_result_t idn_nameprep_unassignedproc ( void handle,
const PRUint32 str,
const PRUint32 **  found 
)

Definition at line 338 of file nameprep.c.

Here is the call graph for this function:


Variable Documentation

struct idn_nameprep nameprep_versions[] [static]