crasher 0.0.1
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- data/COPYING +52 -0
- data/README.markdown +58 -0
- data/Rakefile +199 -0
- data/bin/rdiscount +5 -0
- data/crasher.gemspec +41 -0
- data/ext/Csio.c +49 -0
- data/ext/amalloc.h +29 -0
- data/ext/config.h +9 -0
- data/ext/cstring.h +73 -0
- data/ext/docheader.c +43 -0
- data/ext/dumptree.c +147 -0
- data/ext/extconf.rb +8 -0
- data/ext/generate.c +1389 -0
- data/ext/markdown.c +962 -0
- data/ext/markdown.h +135 -0
- data/ext/mkdio.c +241 -0
- data/ext/mkdio.h +66 -0
- data/ext/rdiscount.c +95 -0
- data/ext/resource.c +169 -0
- data/ext/toc.c +86 -0
- data/lib/crasher.rb +72 -0
- data/lib/markdown.rb +1 -0
- data/test/benchmark.rb +56 -0
- data/test/benchmark.txt +306 -0
- data/test/markdown_test.rb +119 -0
- data/test/rdiscount_test.rb +43 -0
- metadata +81 -0
data/ext/cstring.h
ADDED
@@ -0,0 +1,73 @@
|
|
1
|
+
/* two template types: STRING(t) which defines a pascal-style string
|
2
|
+
* of element (t) [STRING(char) is the closest to the pascal string],
|
3
|
+
* and ANCHOR(t) which defines a baseplate that a linked list can be
|
4
|
+
* built up from. [The linked list /must/ contain a ->next pointer
|
5
|
+
* for linking the list together with.]
|
6
|
+
*/
|
7
|
+
#ifndef _CSTRING_D
|
8
|
+
#define _CSTRING_D
|
9
|
+
|
10
|
+
#include <string.h>
|
11
|
+
#include <stdlib.h>
|
12
|
+
|
13
|
+
#include "amalloc.h"
|
14
|
+
|
15
|
+
/* expandable Pascal-style string.
|
16
|
+
*/
|
17
|
+
#define STRING(type) struct { type *text; int size, alloc; }
|
18
|
+
|
19
|
+
#define CREATE(x) T(x) = (void*)(S(x) = (x).alloc = 0)
|
20
|
+
#define EXPAND(x) (S(x)++)[(S(x) < (x).alloc) \
|
21
|
+
? (T(x)) \
|
22
|
+
: (T(x) = T(x) ? realloc(T(x), sizeof T(x)[0] * ((x).alloc += 100)) \
|
23
|
+
: malloc(sizeof T(x)[0] * ((x).alloc += 100)) )]
|
24
|
+
|
25
|
+
#define DELETE(x) (x).alloc ? (free(T(x)), S(x) = (x).alloc = 0) \
|
26
|
+
: ( S(x) = 0 )
|
27
|
+
#define CLIP(t,i,sz) \
|
28
|
+
( ((i) >= 0) && ((sz) > 0) && (((i)+(sz)) <= S(t)) ) ? \
|
29
|
+
(memmove(&T(t)[i], &T(t)[i+sz], (S(t)-(i+sz)+1)*sizeof(T(t)[0])), \
|
30
|
+
S(t) -= (sz)) : -1
|
31
|
+
|
32
|
+
#define RESERVE(x, sz) T(x) = ((x).alloc > S(x) + (sz) \
|
33
|
+
? T(x) \
|
34
|
+
: T(x) \
|
35
|
+
? realloc(T(x), sizeof T(x)[0] * ((x).alloc = 100+(sz)+S(x))) \
|
36
|
+
: malloc(sizeof T(x)[0] * ((x).alloc = 100+(sz)+S(x))))
|
37
|
+
#define SUFFIX(t,p,sz) \
|
38
|
+
memcpy(((S(t) += (sz)) - (sz)) + \
|
39
|
+
(T(t) = T(t) ? realloc(T(t), sizeof T(t)[0] * ((t).alloc += sz)) \
|
40
|
+
: malloc(sizeof T(t)[0] * ((t).alloc += sz))), \
|
41
|
+
(p), sizeof(T(t)[0])*(sz))
|
42
|
+
|
43
|
+
#define PREFIX(t,p,sz) \
|
44
|
+
RESERVE( (t), (sz) ); \
|
45
|
+
if ( S(t) ) { memmove(T(t)+(sz), T(t), S(t)); } \
|
46
|
+
memcpy( T(t), (p), (sz) ); \
|
47
|
+
S(t) += (sz)
|
48
|
+
|
49
|
+
/* reference-style links (and images) are stored in an array
|
50
|
+
*/
|
51
|
+
#define T(x) (x).text
|
52
|
+
#define S(x) (x).size
|
53
|
+
#define ALL(x) (x).alloc
|
54
|
+
|
55
|
+
/* abstract anchor type that defines a list base
|
56
|
+
* with a function that attaches an element to
|
57
|
+
* the end of the list.
|
58
|
+
*
|
59
|
+
* the list base field is named .text so that the T()
|
60
|
+
* macro will work with it.
|
61
|
+
*/
|
62
|
+
#define ANCHOR(t) struct { t *text, *end; }
|
63
|
+
|
64
|
+
#define ATTACH(t, p) ( (t).text ?( ((t).end->next = (p)), ((t).end = (p)) ) \
|
65
|
+
:( ((t).text = (t).end = (p)) ) )
|
66
|
+
|
67
|
+
typedef STRING(char) Cstring;
|
68
|
+
|
69
|
+
extern void Csputc(int, Cstring *);
|
70
|
+
extern int Csprintf(Cstring *, char *, ...);
|
71
|
+
extern void Csreparse(Cstring *, char *, int, int);
|
72
|
+
|
73
|
+
#endif/*_CSTRING_D*/
|
data/ext/docheader.c
ADDED
@@ -0,0 +1,43 @@
|
|
1
|
+
/*
|
2
|
+
* docheader -- get values from the document header
|
3
|
+
*
|
4
|
+
* Copyright (C) 2007 David L Parsons.
|
5
|
+
* The redistribution terms are provided in the COPYRIGHT file that must
|
6
|
+
* be distributed with this source code.
|
7
|
+
*/
|
8
|
+
#include "config.h"
|
9
|
+
#include <stdio.h>
|
10
|
+
#include <stdlib.h>
|
11
|
+
#include <ctype.h>
|
12
|
+
|
13
|
+
#include "cstring.h"
|
14
|
+
#include "markdown.h"
|
15
|
+
#include "amalloc.h"
|
16
|
+
|
17
|
+
#define afterdle(t) (T((t)->text) + (t)->dle)
|
18
|
+
|
19
|
+
char *
|
20
|
+
mkd_doc_title(Document *doc)
|
21
|
+
{
|
22
|
+
if ( doc && doc->headers )
|
23
|
+
return afterdle(doc->headers);
|
24
|
+
return 0;
|
25
|
+
}
|
26
|
+
|
27
|
+
|
28
|
+
char *
|
29
|
+
mkd_doc_author(Document *doc)
|
30
|
+
{
|
31
|
+
if ( doc && doc->headers && doc->headers->next )
|
32
|
+
return afterdle(doc->headers->next);
|
33
|
+
return 0;
|
34
|
+
}
|
35
|
+
|
36
|
+
|
37
|
+
char *
|
38
|
+
mkd_doc_date(Document *doc)
|
39
|
+
{
|
40
|
+
if ( doc && doc->headers && doc->headers->next && doc->headers->next->next )
|
41
|
+
return afterdle(doc->headers->next->next);
|
42
|
+
return 0;
|
43
|
+
}
|
data/ext/dumptree.c
ADDED
@@ -0,0 +1,147 @@
|
|
1
|
+
/* markdown: a C implementation of John Gruber's Markdown markup language.
|
2
|
+
*
|
3
|
+
* Copyright (C) 2007 David L Parsons.
|
4
|
+
* The redistribution terms are provided in the COPYRIGHT file that must
|
5
|
+
* be distributed with this source code.
|
6
|
+
*/
|
7
|
+
#include <stdio.h>
|
8
|
+
#include "markdown.h"
|
9
|
+
#include "cstring.h"
|
10
|
+
#include "amalloc.h"
|
11
|
+
|
12
|
+
struct frame {
|
13
|
+
int indent;
|
14
|
+
char c;
|
15
|
+
};
|
16
|
+
|
17
|
+
typedef STRING(struct frame) Stack;
|
18
|
+
|
19
|
+
static char *
|
20
|
+
Pptype(int typ)
|
21
|
+
{
|
22
|
+
switch (typ) {
|
23
|
+
case WHITESPACE: return "whitespace";
|
24
|
+
case CODE : return "code";
|
25
|
+
case QUOTE : return "quote";
|
26
|
+
case MARKUP : return "markup";
|
27
|
+
case HTML : return "html";
|
28
|
+
case DL : return "dl";
|
29
|
+
case UL : return "ul";
|
30
|
+
case OL : return "ol";
|
31
|
+
case LISTITEM : return "item";
|
32
|
+
case HDR : return "header";
|
33
|
+
case HR : return "HR";
|
34
|
+
default : return "mystery node!";
|
35
|
+
}
|
36
|
+
}
|
37
|
+
|
38
|
+
static void
|
39
|
+
pushpfx(int indent, char c, Stack *sp)
|
40
|
+
{
|
41
|
+
struct frame *q = &EXPAND(*sp);
|
42
|
+
|
43
|
+
q->indent = indent;
|
44
|
+
q->c = c;
|
45
|
+
}
|
46
|
+
|
47
|
+
|
48
|
+
static void
|
49
|
+
poppfx(Stack *sp)
|
50
|
+
{
|
51
|
+
S(*sp)--;
|
52
|
+
}
|
53
|
+
|
54
|
+
|
55
|
+
static void
|
56
|
+
changepfx(Stack *sp, char c)
|
57
|
+
{
|
58
|
+
char ch;
|
59
|
+
|
60
|
+
if ( !S(*sp) ) return;
|
61
|
+
|
62
|
+
ch = T(*sp)[S(*sp)-1].c;
|
63
|
+
|
64
|
+
if ( ch == '+' || ch == '|' )
|
65
|
+
T(*sp)[S(*sp)-1].c = c;
|
66
|
+
}
|
67
|
+
|
68
|
+
|
69
|
+
static void
|
70
|
+
printpfx(Stack *sp, FILE *f)
|
71
|
+
{
|
72
|
+
int i;
|
73
|
+
char c;
|
74
|
+
|
75
|
+
if ( !S(*sp) ) return;
|
76
|
+
|
77
|
+
c = T(*sp)[S(*sp)-1].c;
|
78
|
+
|
79
|
+
if ( c == '+' || c == '-' ) {
|
80
|
+
fprintf(f, "--%c", c);
|
81
|
+
T(*sp)[S(*sp)-1].c = (c == '-') ? ' ' : '|';
|
82
|
+
}
|
83
|
+
else
|
84
|
+
for ( i=0; i < S(*sp); i++ ) {
|
85
|
+
if ( i )
|
86
|
+
fprintf(f, " ");
|
87
|
+
fprintf(f, "%*s%c", T(*sp)[i].indent + 2, " ", T(*sp)[i].c);
|
88
|
+
if ( T(*sp)[i].c == '`' )
|
89
|
+
T(*sp)[i].c = ' ';
|
90
|
+
}
|
91
|
+
fprintf(f, "--");
|
92
|
+
}
|
93
|
+
|
94
|
+
|
95
|
+
static void
|
96
|
+
dumptree(Paragraph *pp, Stack *sp, FILE *f)
|
97
|
+
{
|
98
|
+
int count;
|
99
|
+
Line *p;
|
100
|
+
int d;
|
101
|
+
static char *Begin[] = { 0, "P", "center" };
|
102
|
+
|
103
|
+
while ( pp ) {
|
104
|
+
if ( !pp->next )
|
105
|
+
changepfx(sp, '`');
|
106
|
+
printpfx(sp, f);
|
107
|
+
|
108
|
+
d = fprintf(f, "[%s", Pptype(pp->typ));
|
109
|
+
if ( pp->align )
|
110
|
+
d += fprintf(f, ", <%s>", Begin[pp->align]);
|
111
|
+
|
112
|
+
for (count=0, p=pp->text; p; ++count, (p = p->next) )
|
113
|
+
;
|
114
|
+
|
115
|
+
if ( count )
|
116
|
+
d += fprintf(f, ", %d line%s", count, (count==1)?"":"s");
|
117
|
+
|
118
|
+
d += fprintf(f, "]");
|
119
|
+
|
120
|
+
if ( pp->down ) {
|
121
|
+
pushpfx(d, pp->down->next ? '+' : '-', sp);
|
122
|
+
dumptree(pp->down, sp, f);
|
123
|
+
poppfx(sp);
|
124
|
+
}
|
125
|
+
else fputc('\n', f);
|
126
|
+
pp = pp->next;
|
127
|
+
}
|
128
|
+
}
|
129
|
+
|
130
|
+
|
131
|
+
int
|
132
|
+
mkd_dump(Document *doc, FILE *out, int flags, char *title)
|
133
|
+
{
|
134
|
+
Stack stack;
|
135
|
+
|
136
|
+
if (mkd_compile(doc, flags) ) {
|
137
|
+
|
138
|
+
CREATE(stack);
|
139
|
+
pushpfx(fprintf(out, "%s", title), doc->code->next ? '+' : '-', &stack);
|
140
|
+
dumptree(doc->code, &stack, out);
|
141
|
+
DELETE(stack);
|
142
|
+
|
143
|
+
mkd_cleanup(doc);
|
144
|
+
return 0;
|
145
|
+
}
|
146
|
+
return -1;
|
147
|
+
}
|
data/ext/extconf.rb
ADDED
data/ext/generate.c
ADDED
@@ -0,0 +1,1389 @@
|
|
1
|
+
/* markdown: a C implementation of John Gruber's Markdown markup language.
|
2
|
+
*
|
3
|
+
* Copyright (C) 2007 David L Parsons.
|
4
|
+
* The redistribution terms are provided in the COPYRIGHT file that must
|
5
|
+
* be distributed with this source code.
|
6
|
+
*/
|
7
|
+
#include <stdio.h>
|
8
|
+
#include <string.h>
|
9
|
+
#include <stdarg.h>
|
10
|
+
#include <stdlib.h>
|
11
|
+
#include <time.h>
|
12
|
+
#include <ctype.h>
|
13
|
+
|
14
|
+
#include "config.h"
|
15
|
+
|
16
|
+
#include "cstring.h"
|
17
|
+
#include "markdown.h"
|
18
|
+
#include "amalloc.h"
|
19
|
+
|
20
|
+
/* prefixes for <automatic links>
|
21
|
+
*/
|
22
|
+
static char *autoprefix[] = { "http://", "https://", "ftp://", "news://" };
|
23
|
+
#define SZAUTOPREFIX (sizeof autoprefix / sizeof autoprefix[0])
|
24
|
+
|
25
|
+
typedef int (*stfu)(const void*,const void*);
|
26
|
+
|
27
|
+
|
28
|
+
/* forward declarations */
|
29
|
+
static int iscodeblock(MMIOT*);
|
30
|
+
static void code(int, MMIOT*);
|
31
|
+
static void text(MMIOT *f);
|
32
|
+
static Paragraph *display(Paragraph*, MMIOT*);
|
33
|
+
|
34
|
+
/* externals from markdown.c */
|
35
|
+
int __mkd_footsort(Footnote *, Footnote *);
|
36
|
+
|
37
|
+
/*
|
38
|
+
* push text into the generator input buffer
|
39
|
+
*/
|
40
|
+
static void
|
41
|
+
push(char *bfr, int size, MMIOT *f)
|
42
|
+
{
|
43
|
+
while ( size-- > 0 )
|
44
|
+
EXPAND(f->in) = *bfr++;
|
45
|
+
}
|
46
|
+
|
47
|
+
|
48
|
+
/* look <i> characters ahead of the cursor.
|
49
|
+
*/
|
50
|
+
static int
|
51
|
+
peek(MMIOT *f, int i)
|
52
|
+
{
|
53
|
+
|
54
|
+
i += (f->isp-1);
|
55
|
+
|
56
|
+
return (i >= 0) && (i < S(f->in)) ? T(f->in)[i] : EOF;
|
57
|
+
}
|
58
|
+
|
59
|
+
|
60
|
+
/* pull a byte from the input buffer
|
61
|
+
*/
|
62
|
+
static int
|
63
|
+
pull(MMIOT *f)
|
64
|
+
{
|
65
|
+
return ( f->isp < S(f->in) ) ? T(f->in)[f->isp++] : EOF;
|
66
|
+
}
|
67
|
+
|
68
|
+
|
69
|
+
/* return a pointer to the current position in the input buffer.
|
70
|
+
*/
|
71
|
+
static char*
|
72
|
+
cursor(MMIOT *f)
|
73
|
+
{
|
74
|
+
return T(f->in) + f->isp;
|
75
|
+
}
|
76
|
+
|
77
|
+
|
78
|
+
static int
|
79
|
+
isthisspace(MMIOT *f, int i)
|
80
|
+
{
|
81
|
+
int c = peek(f, i);
|
82
|
+
|
83
|
+
return isspace(c) || (c == EOF);
|
84
|
+
}
|
85
|
+
|
86
|
+
|
87
|
+
static int
|
88
|
+
isthisalnum(MMIOT *f, int i)
|
89
|
+
{
|
90
|
+
int c = peek(f, i);
|
91
|
+
|
92
|
+
return (c != EOF) && isalnum(c);
|
93
|
+
}
|
94
|
+
|
95
|
+
|
96
|
+
static int
|
97
|
+
isthisnonword(MMIOT *f, int i)
|
98
|
+
{
|
99
|
+
return isthisspace(f, i) || ispunct(peek(f,i));
|
100
|
+
}
|
101
|
+
|
102
|
+
|
103
|
+
/* return/set the current cursor position
|
104
|
+
*/
|
105
|
+
#define mmiotseek(f,x) (f->isp = x)
|
106
|
+
#define mmiottell(f) (f->isp)
|
107
|
+
|
108
|
+
|
109
|
+
/* move n characters forward ( or -n characters backward) in the input buffer.
|
110
|
+
*/
|
111
|
+
static void
|
112
|
+
shift(MMIOT *f, int i)
|
113
|
+
{
|
114
|
+
if (f->isp + i >= 0 )
|
115
|
+
f->isp += i;
|
116
|
+
}
|
117
|
+
|
118
|
+
|
119
|
+
/* Qchar()
|
120
|
+
*/
|
121
|
+
static void
|
122
|
+
Qchar(char c, MMIOT *f)
|
123
|
+
{
|
124
|
+
block *cur;
|
125
|
+
|
126
|
+
if ( S(f->Q) == 0 ) {
|
127
|
+
cur = &EXPAND(f->Q);
|
128
|
+
memset(cur, 0, sizeof *cur);
|
129
|
+
cur->b_type = bTEXT;
|
130
|
+
}
|
131
|
+
else
|
132
|
+
cur = &T(f->Q)[S(f->Q)-1];
|
133
|
+
|
134
|
+
EXPAND(cur->b_text) = c;
|
135
|
+
|
136
|
+
}
|
137
|
+
|
138
|
+
|
139
|
+
/* Qstring()
|
140
|
+
*/
|
141
|
+
static void
|
142
|
+
Qstring(char *s, MMIOT *f)
|
143
|
+
{
|
144
|
+
while (*s)
|
145
|
+
Qchar(*s++, f);
|
146
|
+
}
|
147
|
+
|
148
|
+
|
149
|
+
/* Qwrite()
|
150
|
+
*/
|
151
|
+
static void
|
152
|
+
Qwrite(char *s, int size, MMIOT *f)
|
153
|
+
{
|
154
|
+
while (size-- > 0)
|
155
|
+
Qchar(*s++, f);
|
156
|
+
}
|
157
|
+
|
158
|
+
|
159
|
+
/* Qprintf()
|
160
|
+
*/
|
161
|
+
static void
|
162
|
+
Qprintf(MMIOT *f, char *fmt, ...)
|
163
|
+
{
|
164
|
+
char bfr[80];
|
165
|
+
va_list ptr;
|
166
|
+
|
167
|
+
va_start(ptr,fmt);
|
168
|
+
vsnprintf(bfr, sizeof bfr, fmt, ptr);
|
169
|
+
va_end(ptr);
|
170
|
+
Qstring(bfr, f);
|
171
|
+
}
|
172
|
+
|
173
|
+
|
174
|
+
/* Qem()
|
175
|
+
*/
|
176
|
+
static void
|
177
|
+
Qem(MMIOT *f, char c, int count)
|
178
|
+
{
|
179
|
+
block *p = &EXPAND(f->Q);
|
180
|
+
|
181
|
+
memset(p, 0, sizeof *p);
|
182
|
+
p->b_type = (c == '*') ? bSTAR : bUNDER;
|
183
|
+
p->b_char = c;
|
184
|
+
p->b_count = count;
|
185
|
+
|
186
|
+
memset(&EXPAND(f->Q), 0, sizeof(block));
|
187
|
+
}
|
188
|
+
|
189
|
+
|
190
|
+
/* empair()
|
191
|
+
*/
|
192
|
+
static int
|
193
|
+
empair(MMIOT *f, int go, int level)
|
194
|
+
{
|
195
|
+
|
196
|
+
int i;
|
197
|
+
block *begin, *p;
|
198
|
+
|
199
|
+
begin = &T(f->Q)[go];
|
200
|
+
for (i=go+1; i < S(f->Q); i++) {
|
201
|
+
p = &T(f->Q)[i];
|
202
|
+
|
203
|
+
if ( (p->b_type != bTEXT) && (p->b_count <= 0) )
|
204
|
+
break;
|
205
|
+
|
206
|
+
if ( p->b_type == begin->b_type ) {
|
207
|
+
if ( p->b_count == level ) /* exact match */
|
208
|
+
return i-go;
|
209
|
+
|
210
|
+
if ( p->b_count > 2 ) /* fuzzy match */
|
211
|
+
return i-go;
|
212
|
+
}
|
213
|
+
}
|
214
|
+
return EOF;
|
215
|
+
}
|
216
|
+
|
217
|
+
|
218
|
+
|
219
|
+
static struct emtags {
|
220
|
+
char open[10];
|
221
|
+
char close[10];
|
222
|
+
int size;
|
223
|
+
} emtags[] = { { "<em>" , "</em>", 5 }, { "<strong>", "</strong>", 9 } };
|
224
|
+
|
225
|
+
|
226
|
+
static void
|
227
|
+
emclose(Cstring *s, int level)
|
228
|
+
{
|
229
|
+
PREFIX(*s, emtags[level-1].close, emtags[level-1].size);
|
230
|
+
}
|
231
|
+
|
232
|
+
|
233
|
+
static void
|
234
|
+
emopen(Cstring *s, int level)
|
235
|
+
{
|
236
|
+
SUFFIX(*s, emtags[level-1].open, emtags[level-1].size-1);
|
237
|
+
}
|
238
|
+
|
239
|
+
|
240
|
+
/* emmatch()
|
241
|
+
*/
|
242
|
+
static void
|
243
|
+
emmatch(MMIOT *f, int go)
|
244
|
+
{
|
245
|
+
block *start = &T(f->Q)[go], *end;
|
246
|
+
int e, e2, i, match;
|
247
|
+
|
248
|
+
while ( start->b_count ) {
|
249
|
+
switch (start->b_count) {
|
250
|
+
case 2: e = empair(f,go,match=2);
|
251
|
+
if ( e != EOF ) break;
|
252
|
+
case 1: e = empair(f,go,match=1); break;
|
253
|
+
default:
|
254
|
+
e = empair(f,go,1);
|
255
|
+
e2= empair(f,go,2);
|
256
|
+
|
257
|
+
if ( e == EOF || ((e2 != EOF) && (e2 >= e)) ) {
|
258
|
+
e = e2;
|
259
|
+
match = 2;
|
260
|
+
}
|
261
|
+
else
|
262
|
+
match = 1;
|
263
|
+
}
|
264
|
+
if ( e != EOF ) {
|
265
|
+
end = &T(f->Q)[go+e];
|
266
|
+
emclose(&end->b_post, match);
|
267
|
+
emopen(&start->b_text, match);
|
268
|
+
end->b_count -= match;
|
269
|
+
}
|
270
|
+
else {
|
271
|
+
for (i=0; i < match; i++)
|
272
|
+
EXPAND(start->b_text) = start->b_char;
|
273
|
+
}
|
274
|
+
|
275
|
+
start->b_count -= match;
|
276
|
+
}
|
277
|
+
}
|
278
|
+
|
279
|
+
|
280
|
+
/* ___mkd_emblock()
|
281
|
+
*/
|
282
|
+
void
|
283
|
+
___mkd_emblock(MMIOT *f)
|
284
|
+
{
|
285
|
+
int i;
|
286
|
+
block *p;
|
287
|
+
|
288
|
+
for (i=0; i < S(f->Q); i++) {
|
289
|
+
p = &T(f->Q)[i];
|
290
|
+
|
291
|
+
if ( p->b_type != bTEXT ) emmatch(f, i);
|
292
|
+
|
293
|
+
if ( S(p->b_post) ) { SUFFIX(f->out, T(p->b_post), S(p->b_post));
|
294
|
+
DELETE(p->b_post); }
|
295
|
+
if ( S(p->b_text) ) { SUFFIX(f->out, T(p->b_text), S(p->b_text));
|
296
|
+
DELETE(p->b_text); }
|
297
|
+
}
|
298
|
+
S(f->Q) = 0;
|
299
|
+
}
|
300
|
+
|
301
|
+
|
302
|
+
/* generate html from a markup fragment
|
303
|
+
*/
|
304
|
+
void
|
305
|
+
___mkd_reparse(char *bfr, int size, int flags, MMIOT *f)
|
306
|
+
{
|
307
|
+
MMIOT sub;
|
308
|
+
|
309
|
+
___mkd_initmmiot(&sub, f->footnotes);
|
310
|
+
|
311
|
+
sub.flags = f->flags | flags;
|
312
|
+
sub.base = f->base;
|
313
|
+
|
314
|
+
push(bfr, size, &sub);
|
315
|
+
EXPAND(sub.in) = 0;
|
316
|
+
S(sub.in)--;
|
317
|
+
|
318
|
+
text(&sub);
|
319
|
+
___mkd_emblock(&sub);
|
320
|
+
|
321
|
+
Qwrite(T(sub.out), S(sub.out), f);
|
322
|
+
|
323
|
+
___mkd_freemmiot(&sub, f->footnotes);
|
324
|
+
}
|
325
|
+
|
326
|
+
|
327
|
+
/*
|
328
|
+
* write out a url, escaping problematic characters
|
329
|
+
*/
|
330
|
+
static void
|
331
|
+
puturl(char *s, int size, MMIOT *f)
|
332
|
+
{
|
333
|
+
unsigned char c;
|
334
|
+
|
335
|
+
while ( size-- > 0 ) {
|
336
|
+
c = *s++;
|
337
|
+
|
338
|
+
if ( c == '&' )
|
339
|
+
Qstring("&", f);
|
340
|
+
else if ( c == '<' )
|
341
|
+
Qstring("<", f);
|
342
|
+
else if ( isalnum(c) || ispunct(c) )
|
343
|
+
Qchar(c, f);
|
344
|
+
else
|
345
|
+
Qprintf(f, "%%%02X", c);
|
346
|
+
}
|
347
|
+
}
|
348
|
+
|
349
|
+
|
350
|
+
/* advance forward until the next character is not whitespace
|
351
|
+
*/
|
352
|
+
static int
|
353
|
+
eatspace(MMIOT *f)
|
354
|
+
{
|
355
|
+
int c;
|
356
|
+
|
357
|
+
for ( ; ((c=peek(f, 1)) != EOF) && isspace(c); pull(f) )
|
358
|
+
;
|
359
|
+
return c;
|
360
|
+
}
|
361
|
+
|
362
|
+
|
363
|
+
/* (match (a (nested (parenthetical (string.)))))
|
364
|
+
*/
|
365
|
+
static int
|
366
|
+
parenthetical(int in, int out, MMIOT *f)
|
367
|
+
{
|
368
|
+
int size, indent, c;
|
369
|
+
|
370
|
+
for ( indent=1,size=0; indent; size++ ) {
|
371
|
+
if ( (c = pull(f)) == EOF )
|
372
|
+
return EOF;
|
373
|
+
else if ( c == in )
|
374
|
+
++indent;
|
375
|
+
else if ( c == out )
|
376
|
+
--indent;
|
377
|
+
}
|
378
|
+
return size-1;
|
379
|
+
}
|
380
|
+
|
381
|
+
|
382
|
+
/* extract a []-delimited label from the input stream.
|
383
|
+
*/
|
384
|
+
static char *
|
385
|
+
linkylabel(MMIOT *f, int *sizep)
|
386
|
+
{
|
387
|
+
char *ptr = cursor(f);
|
388
|
+
|
389
|
+
if ( (*sizep = parenthetical('[',']',f)) != EOF )
|
390
|
+
return ptr;
|
391
|
+
return 0;
|
392
|
+
}
|
393
|
+
|
394
|
+
|
395
|
+
/* extract a (-prefixed url from the input stream.
|
396
|
+
* the label is either of the format `<link>`, where I
|
397
|
+
* extract until I find a >, or it is of the format
|
398
|
+
* `text`, where I extract until I reach a ')' or
|
399
|
+
* whitespace.
|
400
|
+
*/
|
401
|
+
static char*
|
402
|
+
linkyurl(MMIOT *f, int *sizep)
|
403
|
+
{
|
404
|
+
int size = 0;
|
405
|
+
char *ptr;
|
406
|
+
int c;
|
407
|
+
|
408
|
+
if ( (c = eatspace(f)) == EOF )
|
409
|
+
return 0;
|
410
|
+
|
411
|
+
ptr = cursor(f);
|
412
|
+
|
413
|
+
if ( c == '<' ) {
|
414
|
+
pull(f);
|
415
|
+
ptr++;
|
416
|
+
if ( (size = parenthetical('<', '>', f)) == EOF )
|
417
|
+
return 0;
|
418
|
+
}
|
419
|
+
else {
|
420
|
+
for ( ; ((c=pull(f)) != ')') && !isspace(c); size++)
|
421
|
+
if ( c == EOF ) return 0;
|
422
|
+
if ( c == ')' )
|
423
|
+
shift(f, -1);
|
424
|
+
}
|
425
|
+
*sizep = size;
|
426
|
+
return ptr;
|
427
|
+
}
|
428
|
+
|
429
|
+
|
430
|
+
/* extract a =HHHxWWW size from the input stream
|
431
|
+
*/
|
432
|
+
static int
|
433
|
+
linkysize(MMIOT *f, int *heightp, int *widthp)
|
434
|
+
{
|
435
|
+
int height=0, width=0;
|
436
|
+
int c;
|
437
|
+
|
438
|
+
*heightp = 0;
|
439
|
+
*widthp = 0;
|
440
|
+
|
441
|
+
if ( (c = eatspace(f)) != '=' )
|
442
|
+
return (c != EOF);
|
443
|
+
pull(f); /* eat '=' */
|
444
|
+
|
445
|
+
for ( c = pull(f); isdigit(c); c = pull(f))
|
446
|
+
width = (width * 10) + (c - '0');
|
447
|
+
|
448
|
+
if ( c == 'x' ) {
|
449
|
+
for ( c = pull(f); isdigit(c); c = pull(f))
|
450
|
+
height = (height*10) + (c - '0');
|
451
|
+
|
452
|
+
if ( c != EOF ) {
|
453
|
+
if ( !isspace(c) ) shift(f, -1);
|
454
|
+
*heightp = height;
|
455
|
+
*widthp = width;
|
456
|
+
return 1;
|
457
|
+
}
|
458
|
+
}
|
459
|
+
return 0;
|
460
|
+
}
|
461
|
+
|
462
|
+
|
463
|
+
/* extract a )-terminated title from the input stream.
|
464
|
+
*/
|
465
|
+
static char*
|
466
|
+
linkytitle(MMIOT *f, int *sizep)
|
467
|
+
{
|
468
|
+
int countq=0, qc, c, size;
|
469
|
+
char *ret, *lastqc = 0;
|
470
|
+
|
471
|
+
eatspace(f);
|
472
|
+
if ( (qc=pull(f)) != '"' && qc != '\'' && qc != '(' )
|
473
|
+
return 0;
|
474
|
+
|
475
|
+
if ( qc == '(' ) qc = ')';
|
476
|
+
|
477
|
+
for ( ret = cursor(f); (c = pull(f)) != EOF; ) {
|
478
|
+
if ( (c == ')') && countq ) {
|
479
|
+
size = (lastqc ? lastqc : cursor(f)) - ret;
|
480
|
+
*sizep = size-1;
|
481
|
+
return ret;
|
482
|
+
}
|
483
|
+
else if ( c == qc ) {
|
484
|
+
lastqc = cursor(f);
|
485
|
+
countq++;
|
486
|
+
}
|
487
|
+
}
|
488
|
+
return 0;
|
489
|
+
}
|
490
|
+
|
491
|
+
|
492
|
+
/* look up (or construct) a footnote from the [xxx] link
|
493
|
+
* at the head of the stream.
|
494
|
+
*/
|
495
|
+
static int
|
496
|
+
linkykey(int image, Footnote *val, MMIOT *f)
|
497
|
+
{
|
498
|
+
Footnote *ret;
|
499
|
+
Cstring mylabel;
|
500
|
+
int here;
|
501
|
+
|
502
|
+
memset(val, 0, sizeof *val);
|
503
|
+
|
504
|
+
if ( (T(val->tag) = linkylabel(f, &S(val->tag))) == 0 )
|
505
|
+
return 0;
|
506
|
+
|
507
|
+
here = mmiottell(f);
|
508
|
+
eatspace(f);
|
509
|
+
switch ( pull(f) ) {
|
510
|
+
case '(':
|
511
|
+
/* embedded link */
|
512
|
+
if ( (T(val->link) = linkyurl(f,&S(val->link))) == 0 )
|
513
|
+
return 0;
|
514
|
+
|
515
|
+
if ( image && !linkysize(f, &val->height, &val->width) )
|
516
|
+
return 0;
|
517
|
+
|
518
|
+
T(val->title) = linkytitle(f, &S(val->title));
|
519
|
+
|
520
|
+
return peek(f,0) == ')';
|
521
|
+
|
522
|
+
case '[': /* footnote links /as defined in the standard/ */
|
523
|
+
default: /* footnote links -- undocumented extension */
|
524
|
+
/* footnote link */
|
525
|
+
mylabel = val->tag;
|
526
|
+
if ( peek(f,0) == '[' ) {
|
527
|
+
if ( (T(val->tag) = linkylabel(f, &S(val->tag))) == 0 )
|
528
|
+
return 0;
|
529
|
+
|
530
|
+
if ( !S(val->tag) )
|
531
|
+
val->tag = mylabel;
|
532
|
+
}
|
533
|
+
else if ( f->flags & MKD_1_COMPAT )
|
534
|
+
break;
|
535
|
+
else
|
536
|
+
mmiotseek(f,here);
|
537
|
+
|
538
|
+
ret = bsearch(val, T(*f->footnotes), S(*f->footnotes),
|
539
|
+
sizeof *val, (stfu)__mkd_footsort);
|
540
|
+
|
541
|
+
if ( ret ) {
|
542
|
+
val->tag = mylabel;
|
543
|
+
val->link = ret->link;
|
544
|
+
val->title = ret->title;
|
545
|
+
val->height = ret->height;
|
546
|
+
val->width = ret->width;
|
547
|
+
return 1;
|
548
|
+
}
|
549
|
+
}
|
550
|
+
return 0;
|
551
|
+
}
|
552
|
+
|
553
|
+
|
554
|
+
/*
|
555
|
+
* all the tag types that linkylinky can produce are
|
556
|
+
* defined by this structure.
|
557
|
+
*/
|
558
|
+
typedef struct linkytype {
|
559
|
+
char *pat;
|
560
|
+
int szpat;
|
561
|
+
char *link_pfx; /* tag prefix and link pointer (eg: "<a href="\"" */
|
562
|
+
char *link_sfx; /* link suffix (eg: "\"" */
|
563
|
+
int WxH; /* this tag allows width x height arguments */
|
564
|
+
char *text_pfx; /* text prefix (eg: ">" */
|
565
|
+
char *text_sfx; /* text suffix (eg: "</a>" */
|
566
|
+
int flags; /* reparse flags */
|
567
|
+
} linkytype;
|
568
|
+
|
569
|
+
static linkytype imaget = { 0, 0, "<img src=\"", "\"",
|
570
|
+
1, " alt=\"", "\" />", DENY_IMG|INSIDE_TAG };
|
571
|
+
static linkytype linkt = { 0, 0, "<a href=\"", "\"",
|
572
|
+
0, ">", "</a>", DENY_A };
|
573
|
+
|
574
|
+
/*
|
575
|
+
* pseudo-protocols for [][];
|
576
|
+
*
|
577
|
+
* id: generates <a id="link">tag</a>
|
578
|
+
* class: generates <span class="link">tag</span>
|
579
|
+
* raw: just dump the link without any processing
|
580
|
+
*/
|
581
|
+
static linkytype specials[] = {
|
582
|
+
{ "id:", 3, "<a id=\"", "\"", 0, ">", "</a>", 0 },
|
583
|
+
{ "class:", 6, "<span class=\"", "\"", 0, ">", "</span>", 0 },
|
584
|
+
{ "raw:", 4, 0, 0, 0, 0, 0, 0 },
|
585
|
+
} ;
|
586
|
+
|
587
|
+
#define NR(x) (sizeof x / sizeof x[0])
|
588
|
+
|
589
|
+
/* see if t contains one of our pseudo-protocols.
|
590
|
+
*/
|
591
|
+
static linkytype *
|
592
|
+
extratag(Cstring t)
|
593
|
+
{
|
594
|
+
int i;
|
595
|
+
linkytype *r;
|
596
|
+
|
597
|
+
for ( i=0; i < NR(specials); i++ ) {
|
598
|
+
r = &specials[i];
|
599
|
+
if ( (S(t) > r->szpat) && (strncasecmp(T(t), r->pat, r->szpat) == 0) )
|
600
|
+
return r;
|
601
|
+
}
|
602
|
+
return 0;
|
603
|
+
}
|
604
|
+
|
605
|
+
|
606
|
+
/*
|
607
|
+
* process embedded links and images
|
608
|
+
*/
|
609
|
+
static int
|
610
|
+
linkylinky(int image, MMIOT *f)
|
611
|
+
{
|
612
|
+
int start = mmiottell(f);
|
613
|
+
Footnote link;
|
614
|
+
linkytype *tag;
|
615
|
+
|
616
|
+
if ( !linkykey(image, &link, f) ) {
|
617
|
+
mmiotseek(f, start);
|
618
|
+
return 0;
|
619
|
+
}
|
620
|
+
|
621
|
+
if ( image )
|
622
|
+
tag = &imaget;
|
623
|
+
else if ( (f->flags & NO_PSEUDO_PROTO) || (tag = extratag(link.link)) == 0 )
|
624
|
+
tag = &linkt;
|
625
|
+
|
626
|
+
if ( f->flags & tag-> flags ) {
|
627
|
+
mmiotseek(f, start);
|
628
|
+
return 0;
|
629
|
+
}
|
630
|
+
|
631
|
+
if ( tag->link_pfx ) {
|
632
|
+
Qstring(tag->link_pfx, f);
|
633
|
+
if ( f->base && (T(link.link)[tag->szpat] == '/') )
|
634
|
+
puturl(f->base, strlen(f->base), f);
|
635
|
+
puturl(T(link.link) + tag->szpat, S(link.link) - tag->szpat, f);
|
636
|
+
Qstring(tag->link_sfx, f);
|
637
|
+
|
638
|
+
if ( tag->WxH && link.height && link.width ) {
|
639
|
+
Qprintf(f," height=\"%d\"", link.height);
|
640
|
+
Qprintf(f, " width=\"%d\"", link.width);
|
641
|
+
}
|
642
|
+
|
643
|
+
if ( S(link.title) ) {
|
644
|
+
Qstring(" title=\"", f);
|
645
|
+
___mkd_reparse(T(link.title), S(link.title), INSIDE_TAG, f);
|
646
|
+
Qchar('"', f);
|
647
|
+
}
|
648
|
+
|
649
|
+
Qstring(tag->text_pfx, f);
|
650
|
+
___mkd_reparse(T(link.tag), S(link.tag), tag->flags, f);
|
651
|
+
Qstring(tag->text_sfx, f);
|
652
|
+
}
|
653
|
+
else
|
654
|
+
Qwrite(T(link.link) + tag->szpat, S(link.link) - tag->szpat, f);
|
655
|
+
|
656
|
+
return 1;
|
657
|
+
}
|
658
|
+
|
659
|
+
|
660
|
+
/* write a character to output, doing text escapes ( & -> &,
|
661
|
+
* > -> > < -> < )
|
662
|
+
*/
|
663
|
+
static void
|
664
|
+
cputc(int c, MMIOT *f)
|
665
|
+
{
|
666
|
+
switch (c) {
|
667
|
+
case '&': Qstring("&", f); break;
|
668
|
+
case '>': Qstring(">", f); break;
|
669
|
+
case '<': Qstring("<", f); break;
|
670
|
+
default : Qchar(c, f); break;
|
671
|
+
}
|
672
|
+
}
|
673
|
+
|
674
|
+
|
675
|
+
/*
|
676
|
+
* convert an email address to a string of nonsense
|
677
|
+
*/
|
678
|
+
static void
|
679
|
+
mangle(char *s, int len, MMIOT *f)
|
680
|
+
{
|
681
|
+
while ( len-- > 0 ) {
|
682
|
+
Qstring("&#", f);
|
683
|
+
Qprintf(f, COINTOSS() ? "x%02x;" : "%02d;", *((unsigned char*)(s++)) );
|
684
|
+
}
|
685
|
+
}
|
686
|
+
|
687
|
+
|
688
|
+
/* before letting a tag through, validate against
|
689
|
+
* DENY_A and DENY_IMG
|
690
|
+
*/
|
691
|
+
static int
|
692
|
+
forbidden_tag(MMIOT *f)
|
693
|
+
{
|
694
|
+
int c = toupper(peek(f, 1));
|
695
|
+
|
696
|
+
if ( f->flags & DENY_HTML )
|
697
|
+
return 1;
|
698
|
+
|
699
|
+
if ( c == 'A' && (f->flags & DENY_A) && !isthisalnum(f,2) )
|
700
|
+
return 1;
|
701
|
+
if ( c == 'I' && (f->flags & DENY_IMG)
|
702
|
+
&& strncasecmp(cursor(f)+1, "MG", 2) == 0
|
703
|
+
&& !isthisalnum(f,4) )
|
704
|
+
return 1;
|
705
|
+
return 0;
|
706
|
+
}
|
707
|
+
|
708
|
+
|
709
|
+
|
710
|
+
/* a < may be just a regular character, the start of an embedded html
|
711
|
+
* tag, or the start of an <automatic link>. If it's an automatic
|
712
|
+
* link, we also need to know if it's an email address because if it
|
713
|
+
* is we need to mangle it in our futile attempt to cut down on the
|
714
|
+
* spaminess of the rendered page.
|
715
|
+
*/
|
716
|
+
static int
|
717
|
+
maybe_tag_or_link(MMIOT *f)
|
718
|
+
{
|
719
|
+
char *text;
|
720
|
+
int c, size, i;
|
721
|
+
int maybetag=1, maybeaddress=0;
|
722
|
+
int mailto;
|
723
|
+
|
724
|
+
if ( f->flags & INSIDE_TAG )
|
725
|
+
return 0;
|
726
|
+
|
727
|
+
for ( size=0; ((c = peek(f,size+1)) != '>') && !isspace(c); size++ ) {
|
728
|
+
if ( ! (c == '/' || isalnum(c) || c == '~') )
|
729
|
+
maybetag=0;
|
730
|
+
if ( c == '@' )
|
731
|
+
maybeaddress=1;
|
732
|
+
else if ( c == EOF )
|
733
|
+
return 0;
|
734
|
+
}
|
735
|
+
|
736
|
+
if ( size == 0 )
|
737
|
+
return 0;
|
738
|
+
|
739
|
+
if ( maybetag || (size >= 3 && strncmp(cursor(f), "!--", 3) == 0) ) {
|
740
|
+
Qstring(forbidden_tag(f) ? "<" : "<", f);
|
741
|
+
while ( ((c = peek(f, 1)) != EOF) && (c != '>') )
|
742
|
+
cputc(pull(f), f);
|
743
|
+
return 1;
|
744
|
+
}
|
745
|
+
|
746
|
+
if ( f->flags & DENY_A ) return 0;
|
747
|
+
|
748
|
+
text = cursor(f);
|
749
|
+
shift(f, size+1);
|
750
|
+
|
751
|
+
for ( i=0; i < SZAUTOPREFIX; i++ )
|
752
|
+
if ( strncasecmp(text, autoprefix[i], strlen(autoprefix[i])) == 0 ) {
|
753
|
+
Qstring("<a href=\"", f);
|
754
|
+
puturl(text,size,f);
|
755
|
+
Qstring("\">", f);
|
756
|
+
puturl(text,size,f);
|
757
|
+
Qstring("</a>", f);
|
758
|
+
return 1;
|
759
|
+
}
|
760
|
+
if ( maybeaddress ) {
|
761
|
+
|
762
|
+
Qstring("<a href=\"", f);
|
763
|
+
if ( (size > 7) && strncasecmp(text, "mailto:", 7) == 0 )
|
764
|
+
mailto = 7;
|
765
|
+
else {
|
766
|
+
mailto = 0;
|
767
|
+
/* supply a mailto: protocol if one wasn't attached */
|
768
|
+
mangle("mailto:", 7, f);
|
769
|
+
}
|
770
|
+
|
771
|
+
mangle(text, size, f);
|
772
|
+
Qstring("\">", f);
|
773
|
+
mangle(text+mailto, size-mailto, f);
|
774
|
+
Qstring("</a>", f);
|
775
|
+
return 1;
|
776
|
+
}
|
777
|
+
|
778
|
+
shift(f, -(size+1));
|
779
|
+
return 0;
|
780
|
+
} /* maybe_tag_or_link */
|
781
|
+
|
782
|
+
|
783
|
+
/* smartyquote code that's common for single and double quotes
|
784
|
+
*/
|
785
|
+
static int
|
786
|
+
smartyquote(int *flags, char typeofquote, MMIOT *f)
|
787
|
+
{
|
788
|
+
int bit = (typeofquote == 's') ? 0x01 : 0x02;
|
789
|
+
|
790
|
+
if ( bit & (*flags) ) {
|
791
|
+
if ( isthisnonword(f,1) ) {
|
792
|
+
Qprintf(f, "&r%cquo;", typeofquote);
|
793
|
+
(*flags) &= ~bit;
|
794
|
+
return 1;
|
795
|
+
}
|
796
|
+
}
|
797
|
+
else if ( isthisnonword(f,-1) && peek(f,1) != EOF ) {
|
798
|
+
Qprintf(f, "&l%cquo;", typeofquote);
|
799
|
+
(*flags) |= bit;
|
800
|
+
return 1;
|
801
|
+
}
|
802
|
+
return 0;
|
803
|
+
}
|
804
|
+
|
805
|
+
|
806
|
+
static int
|
807
|
+
islike(MMIOT *f, char *s)
|
808
|
+
{
|
809
|
+
int len;
|
810
|
+
int i;
|
811
|
+
|
812
|
+
if ( s[0] == '<' ) {
|
813
|
+
if ( !isthisnonword(f, -1) )
|
814
|
+
return 0;
|
815
|
+
++s;
|
816
|
+
}
|
817
|
+
|
818
|
+
if ( !(len = strlen(s)) )
|
819
|
+
return 0;
|
820
|
+
|
821
|
+
if ( s[len-1] == '>' ) {
|
822
|
+
if ( !isthisnonword(f,len-1) )
|
823
|
+
return 0;
|
824
|
+
len--;
|
825
|
+
}
|
826
|
+
|
827
|
+
for (i=1; i < len; i++)
|
828
|
+
if (tolower(peek(f,i)) != s[i])
|
829
|
+
return 0;
|
830
|
+
return 1;
|
831
|
+
}
|
832
|
+
|
833
|
+
|
834
|
+
static struct smarties {
|
835
|
+
char c0;
|
836
|
+
char *pat;
|
837
|
+
char *entity;
|
838
|
+
int shift;
|
839
|
+
} smarties[] = {
|
840
|
+
{ '\'', "'s>", "rsquo", 0 },
|
841
|
+
{ '\'', "'t>", "rsquo", 0 },
|
842
|
+
{ '\'', "'re>", "rsquo", 0 },
|
843
|
+
{ '\'', "'ll>", "rsquo", 0 },
|
844
|
+
{ '-', "--", "mdash", 1 },
|
845
|
+
{ '-', "<->", "ndash", 0 },
|
846
|
+
{ '.', "...", "hellip", 2 },
|
847
|
+
{ '.', ". . .", "hellip", 4 },
|
848
|
+
{ '(', "(c)", "copy", 2 },
|
849
|
+
{ '(', "(r)", "reg", 2 },
|
850
|
+
{ '(', "(tm)", "trade", 3 },
|
851
|
+
{ '3', "<3/4>", "frac34", 2 },
|
852
|
+
{ '3', "<3/4ths>", "frac34", 2 },
|
853
|
+
{ '1', "<1/2>", "frac12", 2 },
|
854
|
+
{ '1', "<1/4>", "frac14", 2 },
|
855
|
+
{ '1', "<1/4th>", "frac14", 2 },
|
856
|
+
{ '&', "�", 0, 3 },
|
857
|
+
} ;
|
858
|
+
#define NRSMART ( sizeof smarties / sizeof smarties[0] )
|
859
|
+
|
860
|
+
|
861
|
+
/* Smarty-pants-style chrome for quotes, -, ellipses, and (r)(c)(tm)
|
862
|
+
*/
|
863
|
+
static int
|
864
|
+
smartypants(int c, int *flags, MMIOT *f)
|
865
|
+
{
|
866
|
+
int i;
|
867
|
+
|
868
|
+
if ( f->flags & DENY_SMARTY )
|
869
|
+
return 0;
|
870
|
+
|
871
|
+
for ( i=0; i < NRSMART; i++)
|
872
|
+
if ( (c == smarties[i].c0) && islike(f, smarties[i].pat) ) {
|
873
|
+
if ( smarties[i].entity )
|
874
|
+
Qprintf(f, "&%s;", smarties[i].entity);
|
875
|
+
shift(f, smarties[i].shift);
|
876
|
+
return 1;
|
877
|
+
}
|
878
|
+
|
879
|
+
switch (c) {
|
880
|
+
case '<' : return 0;
|
881
|
+
case '\'': if ( smartyquote(flags, 's', f) ) return 1;
|
882
|
+
break;
|
883
|
+
|
884
|
+
case '"': if ( smartyquote(flags, 'd', f) ) return 1;
|
885
|
+
break;
|
886
|
+
|
887
|
+
case '`': if ( peek(f, 1) == '`' ) {
|
888
|
+
int j = 2;
|
889
|
+
|
890
|
+
while ( (c=peek(f,j)) != EOF ) {
|
891
|
+
if ( c == '\\' )
|
892
|
+
j += 2;
|
893
|
+
else if ( c == '`' )
|
894
|
+
break;
|
895
|
+
else if ( c == '\'' && peek(f, j+1) == '\'' ) {
|
896
|
+
Qstring("“", f);
|
897
|
+
___mkd_reparse(cursor(f)+1, j-2, 0, f);
|
898
|
+
Qstring("”", f);
|
899
|
+
shift(f,j+1);
|
900
|
+
return 1;
|
901
|
+
}
|
902
|
+
else ++j;
|
903
|
+
}
|
904
|
+
|
905
|
+
}
|
906
|
+
break;
|
907
|
+
}
|
908
|
+
return 0;
|
909
|
+
} /* smartypants */
|
910
|
+
|
911
|
+
|
912
|
+
#define tag_text(f) (f->flags & INSIDE_TAG)
|
913
|
+
|
914
|
+
|
915
|
+
static void
|
916
|
+
text(MMIOT *f)
|
917
|
+
{
|
918
|
+
int c, j;
|
919
|
+
int rep;
|
920
|
+
int smartyflags = 0;
|
921
|
+
|
922
|
+
while ( (c = pull(f)) != EOF ) {
|
923
|
+
if ( smartypants(c, &smartyflags, f) )
|
924
|
+
continue;
|
925
|
+
switch (c) {
|
926
|
+
case 0: break;
|
927
|
+
|
928
|
+
case '>': if ( tag_text(f) )
|
929
|
+
Qstring(">", f);
|
930
|
+
else
|
931
|
+
Qchar(c, f);
|
932
|
+
break;
|
933
|
+
|
934
|
+
case '"': if ( tag_text(f) )
|
935
|
+
Qstring(""", f);
|
936
|
+
else
|
937
|
+
Qchar(c, f);
|
938
|
+
break;
|
939
|
+
|
940
|
+
case '!': if ( peek(f,1) == '[' ) {
|
941
|
+
pull(f);
|
942
|
+
if ( tag_text(f) || !linkylinky(1, f) )
|
943
|
+
Qstring("![", f);
|
944
|
+
}
|
945
|
+
else
|
946
|
+
Qchar(c, f);
|
947
|
+
break;
|
948
|
+
case '[': if ( tag_text(f) || !linkylinky(0, f) )
|
949
|
+
Qchar(c, f);
|
950
|
+
break;
|
951
|
+
#if SUPERSCRIPT
|
952
|
+
/* A^B -> A<sup>B</sup> */
|
953
|
+
case '^': if ( (f->flags & (STRICT|INSIDE_TAG)) || isthisspace(f,-1) || isthisspace(f,1) )
|
954
|
+
Qchar(c,f);
|
955
|
+
else {
|
956
|
+
char *sup = cursor(f);
|
957
|
+
int len = 0;
|
958
|
+
Qstring("<sup>",f);
|
959
|
+
while ( !isthisspace(f,1+len) ) {
|
960
|
+
++len;
|
961
|
+
}
|
962
|
+
shift(f,len);
|
963
|
+
___mkd_reparse(sup, len, 0, f);
|
964
|
+
Qstring("</sup>", f);
|
965
|
+
}
|
966
|
+
break;
|
967
|
+
#endif
|
968
|
+
case '_':
|
969
|
+
#if RELAXED_EMPHASIS
|
970
|
+
/* Underscores don't count if they're in the middle of a word */
|
971
|
+
if ( (!(f->flags & STRICT))
|
972
|
+
&& ((isthisspace(f,-1) && isthisspace(f,1))
|
973
|
+
|| (isthisalnum(f,-1) && isthisalnum(f,1))) ){
|
974
|
+
Qchar(c, f);
|
975
|
+
break;
|
976
|
+
}
|
977
|
+
/* else fall into the regular old emphasis case */
|
978
|
+
#endif
|
979
|
+
case '*': if ( tag_text(f) )
|
980
|
+
Qchar(c, f);
|
981
|
+
else {
|
982
|
+
for (rep = 1; peek(f,1) == c; pull(f) )
|
983
|
+
++rep;
|
984
|
+
Qem(f,c,rep);
|
985
|
+
}
|
986
|
+
break;
|
987
|
+
|
988
|
+
case '`': if ( tag_text(f) || !iscodeblock(f) )
|
989
|
+
Qchar(c, f);
|
990
|
+
else {
|
991
|
+
Qstring("<code>", f);
|
992
|
+
if ( peek(f, 1) == '`' ) {
|
993
|
+
pull(f);
|
994
|
+
code(2, f);
|
995
|
+
}
|
996
|
+
else
|
997
|
+
code(1, f);
|
998
|
+
Qstring("</code>", f);
|
999
|
+
}
|
1000
|
+
break;
|
1001
|
+
|
1002
|
+
case '\\': switch ( c = pull(f) ) {
|
1003
|
+
case '&': Qstring("&", f);
|
1004
|
+
break;
|
1005
|
+
case '<': Qstring("<", f);
|
1006
|
+
break;
|
1007
|
+
case '\\':
|
1008
|
+
case '>': case '#': case '.': case '-':
|
1009
|
+
case '+': case '{': case '}': case ']':
|
1010
|
+
case '(': case ')': case '"': case '\'':
|
1011
|
+
case '!': case '[': case '*': case '_':
|
1012
|
+
case '`': Qchar(c, f);
|
1013
|
+
break;
|
1014
|
+
default:
|
1015
|
+
Qchar('\\', f);
|
1016
|
+
if ( c != EOF )
|
1017
|
+
shift(f,-1);
|
1018
|
+
break;
|
1019
|
+
}
|
1020
|
+
break;
|
1021
|
+
|
1022
|
+
case '<': if ( !maybe_tag_or_link(f) )
|
1023
|
+
Qstring("<", f);
|
1024
|
+
break;
|
1025
|
+
|
1026
|
+
case '&': j = (peek(f,1) == '#' ) ? 2 : 1;
|
1027
|
+
while ( isthisalnum(f,j) )
|
1028
|
+
++j;
|
1029
|
+
|
1030
|
+
if ( peek(f,j) != ';' )
|
1031
|
+
Qstring("&", f);
|
1032
|
+
else
|
1033
|
+
Qchar(c, f);
|
1034
|
+
break;
|
1035
|
+
|
1036
|
+
default: Qchar(c, f);
|
1037
|
+
break;
|
1038
|
+
}
|
1039
|
+
}
|
1040
|
+
/* truncate the input string after we've finished processing it */
|
1041
|
+
S(f->in) = f->isp = 0;
|
1042
|
+
} /* text */
|
1043
|
+
|
1044
|
+
|
1045
|
+
static int
|
1046
|
+
iscodeblock(MMIOT *f)
|
1047
|
+
{
|
1048
|
+
int i=1, single = 1, c;
|
1049
|
+
|
1050
|
+
if ( peek(f,i) == '`' ) {
|
1051
|
+
single=0;
|
1052
|
+
i++;
|
1053
|
+
}
|
1054
|
+
while ( (c=peek(f,i)) != EOF ) {
|
1055
|
+
if ( (c == '`') && (single || peek(f,i+1) == '`') )
|
1056
|
+
return 1;
|
1057
|
+
else if ( c == '\\' )
|
1058
|
+
i++;
|
1059
|
+
i++;
|
1060
|
+
}
|
1061
|
+
return 0;
|
1062
|
+
|
1063
|
+
}
|
1064
|
+
|
1065
|
+
static int
|
1066
|
+
endofcode(int escape, int offset, MMIOT *f)
|
1067
|
+
{
|
1068
|
+
switch (escape) {
|
1069
|
+
case 2: if ( peek(f, offset+1) == '`' ) {
|
1070
|
+
shift(f,1);
|
1071
|
+
case 1: shift(f,offset);
|
1072
|
+
return 1;
|
1073
|
+
}
|
1074
|
+
default:return 0;
|
1075
|
+
}
|
1076
|
+
}
|
1077
|
+
|
1078
|
+
|
1079
|
+
/* the only characters that have special meaning in a code block are
|
1080
|
+
* `<' and `&' , which are /always/ expanded to < and &
|
1081
|
+
*/
|
1082
|
+
static void
|
1083
|
+
code(int escape, MMIOT *f)
|
1084
|
+
{
|
1085
|
+
int c;
|
1086
|
+
|
1087
|
+
if ( escape && (peek(f,1) == ' ') )
|
1088
|
+
shift(f,1);
|
1089
|
+
|
1090
|
+
while ( (c = pull(f)) != EOF ) {
|
1091
|
+
switch (c) {
|
1092
|
+
case ' ': if ( peek(f,1) == '`' && endofcode(escape, 1, f) )
|
1093
|
+
return;
|
1094
|
+
Qchar(c, f);
|
1095
|
+
break;
|
1096
|
+
|
1097
|
+
case '`': if ( endofcode(escape, 0, f) )
|
1098
|
+
return;
|
1099
|
+
Qchar(c, f);
|
1100
|
+
break;
|
1101
|
+
|
1102
|
+
case '\\': cputc(c, f);
|
1103
|
+
if ( peek(f,1) == '>' || (c = pull(f)) == EOF )
|
1104
|
+
break;
|
1105
|
+
|
1106
|
+
default: cputc(c, f);
|
1107
|
+
break;
|
1108
|
+
}
|
1109
|
+
}
|
1110
|
+
} /* code */
|
1111
|
+
|
1112
|
+
|
1113
|
+
/* print a header block
|
1114
|
+
*/
|
1115
|
+
static void
|
1116
|
+
printheader(Paragraph *pp, MMIOT *f)
|
1117
|
+
{
|
1118
|
+
Qprintf(f, "<h%d", pp->hnumber);
|
1119
|
+
if ( f->flags & TOC ) {
|
1120
|
+
Qprintf(f, " id=\"", pp->hnumber);
|
1121
|
+
mkd_string_to_anchor(T(pp->text->text), S(pp->text->text), Qchar, f);
|
1122
|
+
Qchar('"', f);
|
1123
|
+
}
|
1124
|
+
Qchar('>', f);
|
1125
|
+
push(T(pp->text->text), S(pp->text->text), f);
|
1126
|
+
text(f);
|
1127
|
+
Qprintf(f, "</h%d>", pp->hnumber);
|
1128
|
+
}
|
1129
|
+
|
1130
|
+
|
1131
|
+
static int
|
1132
|
+
printblock(Paragraph *pp, MMIOT *f)
|
1133
|
+
{
|
1134
|
+
Line *t = pp->text;
|
1135
|
+
static char *Begin[] = { "", "<p>", "<center>" };
|
1136
|
+
static char *End[] = { "", "</p>","</center>" };
|
1137
|
+
|
1138
|
+
while (t) {
|
1139
|
+
if ( S(t->text) ) {
|
1140
|
+
if ( S(t->text) > 2 && T(t->text)[S(t->text)-2] == ' '
|
1141
|
+
&& T(t->text)[S(t->text)-1] == ' ') {
|
1142
|
+
push(T(t->text), S(t->text)-2, f);
|
1143
|
+
push("<br/>\n", 6, f);
|
1144
|
+
}
|
1145
|
+
else {
|
1146
|
+
___mkd_tidy(t);
|
1147
|
+
push(T(t->text), S(t->text), f);
|
1148
|
+
if ( t->next )
|
1149
|
+
push("\n", 1, f);
|
1150
|
+
}
|
1151
|
+
}
|
1152
|
+
t = t->next;
|
1153
|
+
}
|
1154
|
+
Qstring(Begin[pp->align], f);
|
1155
|
+
text(f);
|
1156
|
+
Qstring(End[pp->align], f);
|
1157
|
+
return 1;
|
1158
|
+
}
|
1159
|
+
|
1160
|
+
|
1161
|
+
static void
|
1162
|
+
printcode(Line *t, MMIOT *f)
|
1163
|
+
{
|
1164
|
+
int blanks;
|
1165
|
+
|
1166
|
+
for ( blanks = 0; t ; t = t->next )
|
1167
|
+
if ( S(t->text) > t->dle ) {
|
1168
|
+
while ( blanks ) {
|
1169
|
+
push("\n", 1, f);
|
1170
|
+
--blanks;
|
1171
|
+
}
|
1172
|
+
push(T(t->text), S(t->text), f);
|
1173
|
+
push("\n", 1, f);
|
1174
|
+
}
|
1175
|
+
else blanks++;
|
1176
|
+
|
1177
|
+
Qstring("<pre><code>", f);
|
1178
|
+
code(0, f);
|
1179
|
+
Qstring("</code></pre>", f);
|
1180
|
+
}
|
1181
|
+
|
1182
|
+
|
1183
|
+
static void
|
1184
|
+
printhtml(Line *t, MMIOT *f)
|
1185
|
+
{
|
1186
|
+
int blanks;
|
1187
|
+
|
1188
|
+
for ( blanks=0; t ; t = t->next )
|
1189
|
+
if ( S(t->text) ) {
|
1190
|
+
for ( ; blanks; --blanks )
|
1191
|
+
Qchar('\n', f);
|
1192
|
+
|
1193
|
+
Qwrite(T(t->text), S(t->text), f);
|
1194
|
+
Qchar('\n', f);
|
1195
|
+
}
|
1196
|
+
else
|
1197
|
+
blanks++;
|
1198
|
+
}
|
1199
|
+
|
1200
|
+
|
1201
|
+
static void
|
1202
|
+
htmlify(Paragraph *p, char *block, char *arguments, MMIOT *f)
|
1203
|
+
{
|
1204
|
+
___mkd_emblock(f);
|
1205
|
+
if ( block )
|
1206
|
+
Qprintf(f, arguments ? "<%s %s>" : "<%s>", block, arguments);
|
1207
|
+
___mkd_emblock(f);
|
1208
|
+
|
1209
|
+
while (( p = display(p, f) )) {
|
1210
|
+
___mkd_emblock(f);
|
1211
|
+
Qstring("\n\n", f);
|
1212
|
+
}
|
1213
|
+
|
1214
|
+
if ( block )
|
1215
|
+
Qprintf(f, "</%s>", block);
|
1216
|
+
___mkd_emblock(f);
|
1217
|
+
}
|
1218
|
+
|
1219
|
+
|
1220
|
+
#if DL_TAG_EXTENSION
|
1221
|
+
static void
|
1222
|
+
definitionlist(Paragraph *p, MMIOT *f)
|
1223
|
+
{
|
1224
|
+
Line *tag;
|
1225
|
+
|
1226
|
+
if ( p ) {
|
1227
|
+
Qstring("<dl>\n", f);
|
1228
|
+
|
1229
|
+
for ( ; p ; p = p->next) {
|
1230
|
+
for ( tag = p->text; tag; tag = tag->next ) {
|
1231
|
+
Qstring("<dt>", f);
|
1232
|
+
___mkd_reparse(T(tag->text), S(tag->text), 0, f);
|
1233
|
+
Qstring("</dt>\n", f);
|
1234
|
+
}
|
1235
|
+
|
1236
|
+
htmlify(p->down, "dd", p->ident, f);
|
1237
|
+
}
|
1238
|
+
|
1239
|
+
Qstring("</dl>", f);
|
1240
|
+
}
|
1241
|
+
}
|
1242
|
+
#endif
|
1243
|
+
|
1244
|
+
|
1245
|
+
static void
|
1246
|
+
listdisplay(int typ, Paragraph *p, MMIOT* f)
|
1247
|
+
{
|
1248
|
+
if ( p ) {
|
1249
|
+
Qprintf(f, "<%cl", (typ==UL)?'u':'o');
|
1250
|
+
if ( typ == AL )
|
1251
|
+
Qprintf(f, " type=a");
|
1252
|
+
Qprintf(f, ">\n");
|
1253
|
+
|
1254
|
+
for ( ; p ; p = p->next ) {
|
1255
|
+
htmlify(p->down, "li", p->ident, f);
|
1256
|
+
Qchar('\n', f);
|
1257
|
+
}
|
1258
|
+
|
1259
|
+
Qprintf(f, "</%cl>\n", (typ==UL)?'u':'o');
|
1260
|
+
}
|
1261
|
+
}
|
1262
|
+
|
1263
|
+
|
1264
|
+
/* dump out a Paragraph in the desired manner
|
1265
|
+
*/
|
1266
|
+
static Paragraph*
|
1267
|
+
display(Paragraph *p, MMIOT *f)
|
1268
|
+
{
|
1269
|
+
if ( !p ) return 0;
|
1270
|
+
|
1271
|
+
switch ( p->typ ) {
|
1272
|
+
case STYLE:
|
1273
|
+
case WHITESPACE:
|
1274
|
+
break;
|
1275
|
+
|
1276
|
+
case HTML:
|
1277
|
+
printhtml(p->text, f);
|
1278
|
+
break;
|
1279
|
+
|
1280
|
+
case CODE:
|
1281
|
+
printcode(p->text, f);
|
1282
|
+
break;
|
1283
|
+
|
1284
|
+
case QUOTE:
|
1285
|
+
htmlify(p->down, p->ident ? "div" : "blockquote", p->ident, f);
|
1286
|
+
break;
|
1287
|
+
|
1288
|
+
case UL:
|
1289
|
+
case OL:
|
1290
|
+
case AL:
|
1291
|
+
listdisplay(p->typ, p->down, f);
|
1292
|
+
break;
|
1293
|
+
|
1294
|
+
#if DL_TAG_EXTENSION
|
1295
|
+
case DL:
|
1296
|
+
definitionlist(p->down, f);
|
1297
|
+
break;
|
1298
|
+
#endif
|
1299
|
+
|
1300
|
+
case HR:
|
1301
|
+
Qstring("<hr />", f);
|
1302
|
+
break;
|
1303
|
+
|
1304
|
+
case HDR:
|
1305
|
+
printheader(p, f);
|
1306
|
+
break;
|
1307
|
+
|
1308
|
+
default:
|
1309
|
+
printblock(p, f);
|
1310
|
+
break;
|
1311
|
+
}
|
1312
|
+
return p->next;
|
1313
|
+
}
|
1314
|
+
|
1315
|
+
|
1316
|
+
/*
|
1317
|
+
* dump out stylesheet sections.
|
1318
|
+
*/
|
1319
|
+
static int
|
1320
|
+
stylesheets(Paragraph *p, FILE *f)
|
1321
|
+
{
|
1322
|
+
Line* q;
|
1323
|
+
|
1324
|
+
for ( ; p ; p = p->next ) {
|
1325
|
+
if ( p->typ == STYLE ) {
|
1326
|
+
for ( q = p->text; q ; q = q->next )
|
1327
|
+
if ( fwrite(T(q->text), S(q->text), 1, f) == 1 )
|
1328
|
+
putc('\n', f);
|
1329
|
+
else
|
1330
|
+
return EOF;
|
1331
|
+
}
|
1332
|
+
if ( p->down && (stylesheets(p->down, f) == EOF) )
|
1333
|
+
return EOF;
|
1334
|
+
}
|
1335
|
+
return 0;
|
1336
|
+
}
|
1337
|
+
|
1338
|
+
|
1339
|
+
/* return a pointer to the compiled markdown
|
1340
|
+
* document.
|
1341
|
+
*/
|
1342
|
+
int
|
1343
|
+
mkd_document(Document *p, char **res)
|
1344
|
+
{
|
1345
|
+
if ( p && p->compiled ) {
|
1346
|
+
if ( ! p->html ) {
|
1347
|
+
htmlify(p->code, 0, 0, p->ctx);
|
1348
|
+
p->html = 1;
|
1349
|
+
}
|
1350
|
+
|
1351
|
+
*res = T(p->ctx->out);
|
1352
|
+
return S(p->ctx->out);
|
1353
|
+
}
|
1354
|
+
return EOF;
|
1355
|
+
}
|
1356
|
+
|
1357
|
+
|
1358
|
+
/* public interface for ___mkd_reparse()
|
1359
|
+
*/
|
1360
|
+
int
|
1361
|
+
mkd_text(char *bfr, int size, FILE *output, int flags)
|
1362
|
+
{
|
1363
|
+
MMIOT f;
|
1364
|
+
|
1365
|
+
___mkd_initmmiot(&f, 0);
|
1366
|
+
f.flags = flags & USER_FLAGS;
|
1367
|
+
|
1368
|
+
___mkd_reparse(bfr, size, 0, &f);
|
1369
|
+
___mkd_emblock(&f);
|
1370
|
+
if ( flags & CDATA_OUTPUT )
|
1371
|
+
___mkd_xml(T(f.out), S(f.out), output);
|
1372
|
+
else
|
1373
|
+
fwrite(T(f.out), S(f.out), 1, output);
|
1374
|
+
|
1375
|
+
___mkd_freemmiot(&f, 0);
|
1376
|
+
return 0;
|
1377
|
+
}
|
1378
|
+
|
1379
|
+
|
1380
|
+
/* dump any embedded styles
|
1381
|
+
*/
|
1382
|
+
int
|
1383
|
+
mkd_style(Document *d, FILE *f)
|
1384
|
+
{
|
1385
|
+
if ( d && d->compiled )
|
1386
|
+
return stylesheets(d->code, f);
|
1387
|
+
return EOF;
|
1388
|
+
}
|
1389
|
+
|