rdiscount 2.2.0.2 → 2.2.7.1

data/ext/gethopt.c

@@ -0,0 +1,285 @@
+/*
+ * gehopt;  options processing with both single-character and whole-word
+ *           options both introduced with -
+ */
+
+#include <stdio.h>
+#include <string.h>
+
+#include "gethopt.h"
+
+
+void
+hoptset(ctx, argc, argv)
+struct h_context *ctx;
+int argc;
+char **argv;
+{
+    memset(ctx, 0, sizeof *ctx);
+    ctx->argc = argc;
+    ctx->argv = argv;
+    ctx->optind = 1;
+}
+
+
+char *
+hoptarg(ctx)
+struct h_context *ctx;
+{
+    return ctx->optarg;
+}
+
+int
+hoptind(ctx)
+struct h_context *ctx;
+{
+    return ctx->optind;
+}
+
+char
+hoptopt(ctx)
+struct h_context *ctx;
+{
+    return ctx->optopt;
+}
+
+
+int
+hopterr(struct h_context *ctx, int val)
+{
+    int old = ctx->opterr;
+    
+    ctx->opterr = !!val;
+    return old;
+}
+
+
+struct h_opt *
+gethopt(ctx, opts, nropts)
+struct h_context *ctx;
+struct h_opt *opts;
+int nropts;
+{
+    int i;
+    int dashes;
+    
+
+    if ( (ctx == 0) || ctx->optend || (ctx->optind >= ctx->argc) )
+	return 0;
+    
+    ctx->optarg = 0;
+    ctx->optopt = 0;
+    
+    if ( ctx->optchar == 0) {
+	/* check for leading -
+	 */
+	if ( ctx->argv[ctx->optind][0] != '-' ) {
+	    /* out of arguments */
+	    ctx->optend = 1;
+	    return 0;
+	}
+
+	if ( ctx->argv[ctx->optind][1] == 0
+	  || strcmp(ctx->argv[ctx->optind], "--") == 0 ) {
+	    /* option list finishes with - or -- token
+	     */
+	    ctx->optend = 1;
+	    ctx->optind++;
+	    return 0;
+	}
+
+	dashes = 1;
+	if ( ctx->argv[ctx->optind][dashes] == '-' ) {
+	    /* support GNU-style long option double-dash prefix
+	     * (if gethopt is passed an unknown option with a double-dash
+	     *  prefix, it won't match a word and then the second dash
+	     *  will be scanned as if it was a regular old single-character
+	     *  option.)
+	     */
+	    dashes = 2;
+	}
+	
+	for ( i=0; i < nropts; i++ ) {
+	    if ( ! opts[i].optword ) 
+		continue;
+
+	    if (strcmp(opts[i].optword, dashes+(ctx->argv[ctx->optind]) ) == 0 ) {
+		if ( opts[i].opthasarg ) {
+		    if ( ctx->argc > ctx->optind ) {
+			ctx->optarg = ctx->argv[ctx->optind+1];
+			ctx->optind += 2;
+		    }
+		    else {
+			/* word argument with required arg at end of
+			 *command line
+			 */
+			if ( ctx->opterr )
+			    fprintf(stderr,
+				    "%s: option requires an argument -- %s\n",
+				    ctx->argv[0], opts[i].optword);
+			ctx->optind ++;
+			return HOPTERR;
+		    }
+		}
+		else {
+		    ctx->optind ++;
+		}
+		return &opts[i];
+	    }
+	}
+	ctx->optchar = 1;
+    }
+
+    ctx->optopt = ctx->argv[ctx->optind][ctx->optchar++];
+
+    if ( !ctx->optopt ) {
+	/* fell off the end of this argument */
+	ctx->optind ++;
+	ctx->optchar = 0;
+	return gethopt(ctx, opts, nropts);
+    }
+
+    for ( i=0; i<nropts; i++ ) {
+	if ( opts[i].optchar == ctx->optopt ) {
+	    /* found a single-char option!
+	     */
+	    if ( opts[i].opthasarg ) {
+		if ( ctx->argv[ctx->optind][ctx->optchar] ) {
+		    /* argument immediately follows this options (-Oc)
+		     */
+		    ctx->optarg = &ctx->argv[ctx->optind][ctx->optchar];
+		    ctx->optind ++;
+		    ctx->optchar = 0;
+		}
+		else if ( ctx->optind < ctx->argc-1 ) {
+		    /* argument is next arg (-O c)
+		     */
+		    ctx->optarg = &ctx->argv[ctx->optind+1][0];
+		    ctx->optind += 2;
+		    ctx->optchar = 0;
+		}
+		else {
+		    /* end of arg string (-O); set optarg to null, return
+		     * (should it opterr on me?)
+		     */
+		    ctx->optarg = 0;
+		    ctx->optind ++;
+		    ctx->optchar = 0;
+		    if ( ctx->opterr )
+			fprintf(stderr,
+				"%s: option requires an argument -- %c\n",
+				ctx->argv[0], opts[i].optchar);
+		    return HOPTERR;
+		}
+	    }
+	    else {
+		if ( !ctx->argv[ctx->optind][ctx->optchar] ) {
+		    ctx->optind ++;
+		    ctx->optchar = 0;
+		}
+	    }
+	    return &opts[i];
+	}
+    }
+    if ( ctx->opterr )
+	fprintf(stderr, "%s: illegal option -- %c\n", ctx->argv[0], ctx->optopt);
+    return HOPTERR;
+}
+
+
+void
+hoptusage(char *pgm, struct h_opt opts[], int nropts, char *arguments)
+{
+    int i;
+    int optcount;
+    
+    fprintf(stderr, "usage: %s", pgm);
+
+    /* print out the options that don't have flags first */
+    
+    for ( optcount=i=0; i < nropts; i++ ) {
+	if ( opts[i].optchar && !opts[i].opthasarg) {
+	    if (optcount == 0 )
+		fputs(" [-", stderr);
+	    fputc(opts[i].optchar, stderr);
+	    optcount++;
+	}
+    }
+    if ( optcount )
+	fputc(']', stderr);
+
+    /* print out the options WITH flags */
+    for ( i = 0; i < nropts; i++ )
+	if ( opts[i].optchar && opts[i].opthasarg)
+	    fprintf(stderr, " [-%c %s]", opts[i].optchar, opts[i].opthasarg);
+
+    /* print out the long options */
+    for ( i = 0; i < nropts; i++ )
+	if ( opts[i].optword ) {
+	    fprintf(stderr, " [-%s", opts[i].optword);
+	    if ( opts[i].opthasarg )
+		fprintf(stderr, " %s", opts[i].opthasarg);
+	    fputc(']', stderr);
+	}
+
+    /* print out the arguments string, if any */
+
+    if ( arguments )
+	fprintf(stderr, " %s", arguments);
+
+    /* and we're done */
+    fputc('\n', stderr);
+}
+
+
+#if DEBUG
+struct h_opt opts[] = {
+    { 0, "css",    0,  1, "css file" },
+    { 1, "header", 0,  1, "header file" },
+    { 2, 0,       'a', 0, "option a (no arg)" },
+    { 3, 0,       'b', 1, "option B (with arg)" },
+    { 4, "help",  '?', 0, "help message" },
+} ;
+
+#define NROPT (sizeof opts/sizeof opts[0])
+
+
+int
+main(argc, argv)
+char **argv;
+{
+    struct h_opt *ret;
+    struct h_context ctx;
+    int i;
+
+
+    hoptset(&ctx, argc, argv);
+    hopterr(&ctx, 1);
+
+    while (( ret = gethopt(&ctx, opts, NROPT) )) {
+
+	if ( ret != HOPTERR ) {
+	    if ( ret->optword )
+		printf("%s", ret->optword);
+	    else
+		printf("%c", ret->optchar);
+
+	    if ( ret->opthasarg ) {
+		if ( hoptarg(&ctx) )
+		    printf(" with argument \"%s\"", hoptarg(&ctx));
+		else
+		    printf(" with no argument?");
+	    }
+	    printf(" (%s)\n", ret->optdesc);
+	}
+    }
+
+    argc -= hoptind(&ctx);
+    argv += hoptind(&ctx);
+
+    for ( i=0; i < argc; i++ )
+	printf("%d: %s\n", i, argv[i]);
+    return 0;
+}
+
+#endif /*DEBUG*/

data/ext/gethopt.h

@@ -0,0 +1,43 @@
+/*
+ * gethopt;  options processing with both single-character and whole-work
+ *           options both introduced with -
+ */
+
+#ifndef __GETHOPT_D
+#define __GETHOPT_D
+
+#include <stdio.h>
+#include <string.h>
+
+
+struct h_opt {
+    int  option;
+    char *optword;
+    char optchar;
+    char *opthasarg;
+    char *optdesc;
+} ;
+
+#define HOPTERR	((struct h_opt*)-1)
+
+struct h_context {
+    char **argv;
+    int    argc;
+    int    optchar;
+    int    optind;
+    char  *optarg;
+    char   optopt;
+    int    opterr:1;
+    int    optend:1;
+} ;
+
+extern char *hoptarg(struct h_context *);
+extern int   hoptind(struct h_context *);
+extern char  hoptopt(struct h_context *);
+extern void  hoptset(struct h_context *, int, char **);
+extern int   hopterr(struct h_context *, int);
+extern struct h_opt *gethopt(struct h_context *, struct h_opt*, int);
+
+extern void hoptusage(char *, struct h_opt*, int, char *);
+
+#endif/*__GETHOPT_D*/

data/ext/github_flavoured.c

@@ -30,7 +30,7 @@ gfm_populate(getc_func getc, void* ctx, int flags)
 
     if ( !a ) return 0;
 
-    a->tabstop = (flags & MKD_TABSTOP) ? 4 : TABSTOP;
+    a->tabstop = is_flag_set(flags, MKD_TABSTOP) ? 4 : TABSTOP;
 
     CREATE(line);
 
@@ -59,16 +59,17 @@ gfm_populate(getc_func getc, void* ctx, int flags)
 
     DELETE(line);
 
-    if ( (pandoc == 3) && !(flags & (MKD_NOHEADER|MKD_STRICT)) ) {
+    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_header_dle(a->title);
-	a->author= headers->next;       __mkd_header_dle(a->author);
-	a->date  = headers->next->next; __mkd_header_dle(a->date);
+	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;
     }
@@ -80,7 +81,7 @@ gfm_populate(getc_func getc, void* ctx, int flags)
 /* convert a block of text into a linked list
  */
 Document *
-gfm_string(const char *buf, int len, DWORD flags)
+gfm_string(const char *buf, int len, mkd_flag_t flags)
 {
     struct string_stream about;
 
@@ -94,7 +95,7 @@ gfm_string(const char *buf, int len, DWORD flags)
 /* convert a file into a linked list
  */
 Document *
-gfm_in(FILE *f, DWORD flags)
+gfm_in(FILE *f, mkd_flag_t flags)
 {
     return gfm_populate((getc_func)fgetc, f, flags & INPUT_MASK);
 }

data/ext/h1title.c

@@ -0,0 +1,36 @@
+#include <stdio.h>
+#include "markdown.h"
+
+static Paragraph *
+mkd_h1(Paragraph *p)
+{
+    Paragraph *found;
+
+    while ( p ) {
+	if ( p->typ == HDR && p->hnumber == 1 )
+	     return p;
+       if ( p->down && (found = mkd_h1(p->down)) )
+	   return found;
+	p = p->next;
+    }
+    return 0;
+}
+
+char *
+mkd_h1_title(Document *doc, int flags)
+{
+    Paragraph *title;
+
+    if (doc && (title = mkd_h1(doc->code)) ) {
+	  char *generated;
+	  int size;
+
+	  /* assert that a H1 header is one line long, so that's
+	   * the only thing needed
+	    */
+	  size = mkd_line(T(title->text->text),
+			  S(title->text->text), &generated, flags|MKD_TAGTEXT);
+	  if ( size ) return generated;
+    }
+    return 0;
+}

data/ext/html5.c

@@ -13,7 +13,6 @@ mkd_with_html5_tags()
     mkd_define_tag("ASIDE", 0);
     mkd_define_tag("FOOTER", 0);
     mkd_define_tag("HEADER", 0);
-    mkd_define_tag("HGROUP", 0);
     mkd_define_tag("NAV", 0);
     mkd_define_tag("SECTION", 0);
     mkd_define_tag("ARTICLE", 0);