Warning, file /education/cantor/thirdparty/discount-2.2.6-patched/mkdio.c was not indexed or was modified since last indexation (in which case cross-reference links may be missing, inaccurate or erroneous).

 /*
  * mkdio -- markdown front end input functions
  *
  * Copyright (C) 2007 David L Parsons.
  * The redistribution terms are provided in the COPYRIGHT file that must
  * be distributed with this source code.
  */
 #include "config.h"
 #include <stdio.h>
 #include <stdlib.h>
 #include <ctype.h>
 
 #include "cstring.h"
 #include "markdown.h"
 #include "amalloc.h"
 
 typedef ANCHOR(Line) LineAnchor;
 
 
 /* create a new blank Document
  */
 Document*
 __mkd_new_Document()
 {
     Document *ret = calloc(sizeof(Document), 1);
 
     if ( ret ) {
     if ( ret->ctx = calloc(sizeof(MMIOT), 1) ) {
         ret->magic = VALID_DOCUMENT;
         return ret;
     }
     free(ret);
     }
     return 0;
 }
 
 
 /* add a line to the markdown input chain, expanding tabs and
  * noting the presence of special characters as we go.
  */
 void
 __mkd_enqueue(Document* a, Cstring *line)
 {
     Line *p = calloc(sizeof *p, 1);
     unsigned char c;
     int xp = 0;
     int           size = S(*line);
     unsigned char *str = (unsigned char*)T(*line);
 
     CREATE(p->text);
     ATTACH(a->content, p);
 
     while ( size-- ) {
     if ( (c = *str++) == '\t' ) {
         /* expand tabs into ->tabstop spaces.  We use ->tabstop
          * because the ENTIRE FREAKING COMPUTER WORLD uses editors
          * that don't do ^T/^D, but instead use tabs for indentation,
          * and, of course, set their tabs down to 4 spaces 
          */
         do {
         EXPAND(p->text) = ' ';
         } while ( ++xp % a->tabstop );
     }
     else if ( c >= ' ' ) {
         if ( c == '|' )
         p->flags |= PIPECHAR;
         EXPAND(p->text) = c;
         ++xp;
     }
     }
     EXPAND(p->text) = 0;
     S(p->text)--;
     p->dle = mkd_firstnonblank(p);
 }
 
 
 /* trim leading characters from a line, then adjust the dle.
  */
 void
 __mkd_trim_line(Line *p, int clip)
 {
     if ( clip >= S(p->text) ) {
     S(p->text) = p->dle = 0;
     T(p->text)[0] = 0;
     }
     else if ( clip > 0 ) {
     CLIP(p->text, 0, clip);
     p->dle = mkd_firstnonblank(p);
     }
 }
 
 
 /* build a Document from any old input.
  */
 typedef int (*getc_func)(void*);
 
 Document *
 populate(getc_func getc, void* ctx, mkd_flag_t flags)
 {
     Cstring line;
     Document *a = __mkd_new_Document();
     int c;
     int pandoc = 0;
 
     if ( !a ) return 0;
 
     a->tabstop = is_flag_set(flags, MKD_TABSTOP) ? 4 : TABSTOP;
 
     CREATE(line);
 
     while ( (c = (*getc)(ctx)) != EOF ) {
     if ( c == '\n' ) {
         if ( pandoc != EOF && pandoc < 3 ) {
         if ( S(line) && (T(line)[0] == '%') )
             pandoc++;
         else
             pandoc = EOF;
         }
         __mkd_enqueue(a, &line);
         S(line) = 0;
     }
     else if ( isprint(c) || isspace(c) || (c & 0x80) )
         EXPAND(line) = c;
     }
 
     if ( S(line) )
     __mkd_enqueue(a, &line);
 
     DELETE(line);
 
     if ( (pandoc == 3) && !(is_flag_set(flags, MKD_NOHEADER) || is_flag_set(flags, MKD_STRICT)) ) {
     /* the first three lines started with %, so we have a header.
      * clip the first three lines out of content and hang them
      * off header.
      */
     Line *headers = T(a->content);
 
     a->title = headers;             __mkd_trim_line(a->title, 1);
     a->author= headers->next;       __mkd_trim_line(a->author, 1);
     a->date  = headers->next->next; __mkd_trim_line(a->date, 1);
 
     T(a->content) = headers->next->next->next;
     }
 
     return a;
 }
 
 
 /* convert a file into a linked list
  */
 Document *
 mkd_in(FILE *f, mkd_flag_t flags)
 {
     return populate((getc_func)fgetc, f, flags & INPUT_MASK);
 }
 
 
 /* return a single character out of a buffer
  */
 int
 __mkd_io_strget(struct string_stream *in)
 {
     if ( !in->size ) return EOF;
 
     --(in->size);
 
     return *(in->data)++;
 }
 
 
 /* convert a block of text into a linked list
  */
 Document *
 mkd_string(const char *buf, int len, mkd_flag_t flags)
 {
     struct string_stream about;
 
     about.data = buf;
     about.size = len;
 
     return populate((getc_func)__mkd_io_strget, &about, flags & INPUT_MASK);
 }
 
 
 /* write the html to a file (xmlified if necessary)
  */
 int
 mkd_generatehtml(Document *p, FILE *output)
 {
     char *doc;
     int szdoc;
 
     DO_OR_DIE( szdoc = mkd_document(p,&doc) );
     if ( is_flag_set(p->ctx->flags, MKD_CDATA) )
     DO_OR_DIE( mkd_generatexml(doc, szdoc, output) );
     else if ( fwrite(doc, szdoc, 1, output) != 1 )
     return EOF;
     DO_OR_DIE( putc('\n', output) );
     return 0;
 }
 
 
 /* convert some markdown text to html
  */
 int
 markdown(Document *document, FILE *out, mkd_flag_t flags)
 {
     if ( mkd_compile(document, flags) ) {
     mkd_generatehtml(document, out);
     mkd_cleanup(document);
     return 0;
     }
     return -1;
 }
 
 
 /* anchor_format a string, returning the formatted string in malloc()ed space
  * MKD_URLENCODEDANCHOR is now perverted to being a html5 anchor
  *
  * !labelformat:  print all characters
  * labelformat && h4anchor: prefix nonalpha label with L,
  *                          expand all nonalnum, _, ':', '.' to hex
  *                          except space which maps to -
  * labelformat && !h4anchor:expand space to -, other isspace() & '%' to hex
  */
 static char *
 mkd_anchor_format(char *s, int len, int labelformat, mkd_flag_t flags)
 {
     char *res;
     unsigned char c;
     int i, needed, out = 0;
     int h4anchor = !is_flag_set(flags, MKD_URLENCODEDANCHOR);
     static const unsigned char hexchars[] = "0123456789abcdef";
 
     needed = labelformat ? (4*len) : len;
 
     if ( (res = malloc(needed)) == NULL )
     return NULL;
 
     if ( h4anchor && labelformat && !isalpha(s[0]) )
     res[out++] = 'L';
     
     
     for ( i=0; i < len ; i++ ) {
     c = s[i];
     if ( labelformat ) {
         if ( h4anchor
             ? (isalnum(c) || (c == '_') || (c == ':') || (c == '.' ) )
             : !(isspace(c) || c == '%') )
         res[out++] = c;
         else if ( c == ' ' )
         res[out++] = '-';
         else {
             res[out++] = h4anchor ? '-' : '%';
             res[out++] = hexchars[c >> 4 & 0xf];
             res[out++] = hexchars[c      & 0xf];
             if ( h4anchor )
             res[out++] = '-';
         }
     }
     else
         res[out++] = c;
     }
     
     res[out++] = 0;
     return res;
 } /* mkd_anchor_format */
 
 
 /* write out a Cstring, mangled into a form suitable for `<a href=` or `<a id=`
  */
 void
 mkd_string_to_anchor(char *s, int len, mkd_sta_function_t outchar,
                        void *out, int labelformat,
                        MMIOT *f)
 {
     char *res;
     char *line;
     int size;
 
     int i;
 
     size = mkd_line(s, len, &line, IS_LABEL);
 
     if ( !line )
     return;
 
     if ( f->cb->e_anchor )
     res = (*(f->cb->e_anchor))(line, size, f->cb->e_data);
     else
     res = mkd_anchor_format(line, size, labelformat, f->flags);
 
     free(line);
 
     if ( !res )
     return;
 
     for ( i=0; res[i]; i++ )
     (*outchar)(res[i], out);
 
     if ( f->cb->e_anchor ) {
     if ( f->cb->e_free )
         (*(f->cb->e_free))(res, f->cb->e_data);
     }
     else 
     free(res);
 }
 
 
 /*  ___mkd_reparse() a line
  */
 static void
 mkd_parse_line(char *bfr, int size, MMIOT *f, mkd_flag_t flags)
 {
     ___mkd_initmmiot(f, 0);
     f->flags = flags & USER_FLAGS;
     ___mkd_reparse(bfr, size, 0, f, 0);
     ___mkd_emblock(f);
 }
 
 
 /* ___mkd_reparse() a line, returning it in malloc()ed memory
  */
 int
 mkd_line(char *bfr, int size, char **res, mkd_flag_t flags)
 {
     MMIOT f;
     int len;
     
     mkd_parse_line(bfr, size, &f, flags);
 
     if ( len = S(f.out) ) {
     EXPAND(f.out) = 0;
     /* strdup() doesn't use amalloc(), so in an amalloc()ed
      * build this copies the string safely out of our memory
      * paranoia arena.  In a non-amalloc world, it's a spurious
      * memory allocation, but it avoids unintentional hilarity
      * with amalloc()
      */
     *res = strdup(T(f.out));
     }
     else {
      *res = 0;
      len = EOF;
      }
     ___mkd_freemmiot(&f, 0);
     return len;
 }
 
 
 /* ___mkd_reparse() a line, writing it to a FILE
  */
 int
 mkd_generateline(char *bfr, int size, FILE *output, mkd_flag_t flags)
 {
     MMIOT f;
     int status;
 
     mkd_parse_line(bfr, size, &f, flags);
     if ( is_flag_set(flags, MKD_CDATA) )
     status = mkd_generatexml(T(f.out), S(f.out), output) != EOF;
     else
     status = fwrite(T(f.out), S(f.out), 1, output) == S(f.out);
 
     ___mkd_freemmiot(&f, 0);
     return status ? 0 : EOF;
 }
 
 
 /* set the url display callback
  */
 void
 mkd_e_url(Document *f, mkd_callback_t edit)
 {
     if ( f ) {
     if ( f->cb.e_url != edit )
         f->dirty = 1;
     f->cb.e_url = edit;
     }
 }
 
 
 /* set the url options callback
  */
 void
 mkd_e_flags(Document *f, mkd_callback_t edit)
 {
     if ( f ) {
     if ( f->cb.e_flags != edit )
         f->dirty = 1;
     f->cb.e_flags = edit;
     }
 }
 
 
 /* set the anchor formatter
  */
 void
 mkd_e_anchor(Document *f, mkd_callback_t format)
 {
     if ( f ) {
     if ( f->cb.e_anchor != format )
         f->dirty = 1;
     f->cb.e_anchor = format;
     }
 }
 
 
 /* set the url display/options deallocator
  */
 void
 mkd_e_free(Document *f, mkd_free_t dealloc)
 {
     if ( f ) {
     if ( f->cb.e_free != dealloc )
         f->dirty = 1;
     f->cb.e_free = dealloc;
     }
 }
 
 
 /* set the url display/options context data field
  */
 void
 mkd_e_data(Document *f, void *data)
 {
     if ( f ) {
     if ( f->cb.e_data != data )
         f->dirty = 1;
     f->cb.e_data = data;
     }
 }
 
 
 /* set the code block display callback
  */
 void
 mkd_e_code_format(Document *f, mkd_callback_t codefmt)
 {
     if ( f && (f->cb.e_codefmt != codefmt) ) {
     f->dirty = 1;
     f->cb.e_codefmt = codefmt;
     }
 }
 
 
 /* set the href prefix for markdown extra style footnotes
  */
 void
 mkd_ref_prefix(Document *f, char *data)
 {
     if ( f ) {
     if ( f->ref_prefix != data )
         f->dirty = 1;
     f->ref_prefix = data;
     }
 }