empty_element_suffix\n");
645 | }
646 |
647 |
648 | function doAnchors($text) {
649 | #
650 | # Turn Markdown link shortcuts into XHTML tags.
651 | #
652 | if ($this->in_anchor) return $text;
653 | $this->in_anchor = true;
654 |
655 | #
656 | # First, handle reference-style links: [link text] [id]
657 | #
658 | $text = preg_replace_callback('{
659 | ( # wrap whole match in $1
660 | \[
661 | ('.$this->nested_brackets_re.') # link text = $2
662 | \]
663 |
664 | [ ]? # one optional space
665 | (?:\n[ ]*)? # one optional newline followed by spaces
666 |
667 | \[
668 | (.*?) # id = $3
669 | \]
670 | )
671 | }xs',
672 | array(&$this, '_doAnchors_reference_callback'), $text);
673 |
674 | #
675 | # Next, inline-style links: [link text](url "optional title")
676 | #
677 | $text = preg_replace_callback('{
678 | ( # wrap whole match in $1
679 | \[
680 | ('.$this->nested_brackets_re.') # link text = $2
681 | \]
682 | \( # literal paren
683 | [ \n]*
684 | (?:
685 | <(.+?)> # href = $3
686 | |
687 | ('.$this->nested_url_parenthesis_re.') # href = $4
688 | )
689 | [ \n]*
690 | ( # $5
691 | ([\'"]) # quote char = $6
692 | (.*?) # Title = $7
693 | \6 # matching quote
694 | [ \n]* # ignore any spaces/tabs between closing quote and )
695 | )? # title is optional
696 | \)
697 | )
698 | }xs',
699 | array(&$this, '_doAnchors_inline_callback'), $text);
700 |
701 | #
702 | # Last, handle reference-style shortcuts: [link text]
703 | # These must come last in case you've also got [link text][1]
704 | # or [link text](/foo)
705 | #
706 | $text = preg_replace_callback('{
707 | ( # wrap whole match in $1
708 | \[
709 | ([^\[\]]+) # link text = $2; can\'t contain [ or ]
710 | \]
711 | )
712 | }xs',
713 | array(&$this, '_doAnchors_reference_callback'), $text);
714 |
715 | $this->in_anchor = false;
716 | return $text;
717 | }
718 | function _doAnchors_reference_callback($matches) {
719 | $whole_match = $matches[1];
720 | $link_text = $matches[2];
721 | $link_id =& $matches[3];
722 |
723 | if ($link_id == "") {
724 | # for shortcut links like [this][] or [this].
725 | $link_id = $link_text;
726 | }
727 |
728 | # lower-case and turn embedded newlines into spaces
729 | $link_id = strtolower($link_id);
730 | $link_id = preg_replace('{[ ]?\n}', ' ', $link_id);
731 |
732 | if (isset($this->urls[$link_id])) {
733 | $url = $this->urls[$link_id];
734 | $url = $this->encodeAttribute($url);
735 |
736 | $result = "titles[$link_id] ) ) {
738 | $title = $this->titles[$link_id];
739 | $title = $this->encodeAttribute($title);
740 | $result .= " title=\"$title\"";
741 | }
742 |
743 | $link_text = $this->runSpanGamut($link_text);
744 | $result .= ">$link_text";
745 | $result = $this->hashPart($result);
746 | }
747 | else {
748 | $result = $whole_match;
749 | }
750 | return $result;
751 | }
752 | function _doAnchors_inline_callback($matches) {
753 | $whole_match = $matches[1];
754 | $link_text = $this->runSpanGamut($matches[2]);
755 | $url = $matches[3] == '' ? $matches[4] : $matches[3];
756 | $title =& $matches[7];
757 |
758 | $url = $this->encodeAttribute($url);
759 |
760 | $result = "encodeAttribute($title);
763 | $result .= " title=\"$title\"";
764 | }
765 |
766 | $link_text = $this->runSpanGamut($link_text);
767 | $result .= ">$link_text";
768 |
769 | return $this->hashPart($result);
770 | }
771 |
772 |
773 | function doImages($text) {
774 | #
775 | # Turn Markdown image shortcuts into ![]()
tags.
776 | #
777 | #
778 | # First, handle reference-style labeled images: ![alt text][id]
779 | #
780 | $text = preg_replace_callback('{
781 | ( # wrap whole match in $1
782 | !\[
783 | ('.$this->nested_brackets_re.') # alt text = $2
784 | \]
785 |
786 | [ ]? # one optional space
787 | (?:\n[ ]*)? # one optional newline followed by spaces
788 |
789 | \[
790 | (.*?) # id = $3
791 | \]
792 |
793 | )
794 | }xs',
795 | array(&$this, '_doImages_reference_callback'), $text);
796 |
797 | #
798 | # Next, handle inline images: 
799 | # Don't forget: encode * and _
800 | #
801 | $text = preg_replace_callback('{
802 | ( # wrap whole match in $1
803 | !\[
804 | ('.$this->nested_brackets_re.') # alt text = $2
805 | \]
806 | \s? # One optional whitespace character
807 | \( # literal paren
808 | [ \n]*
809 | (?:
810 | <(\S*)> # src url = $3
811 | |
812 | ('.$this->nested_url_parenthesis_re.') # src url = $4
813 | )
814 | [ \n]*
815 | ( # $5
816 | ([\'"]) # quote char = $6
817 | (.*?) # title = $7
818 | \6 # matching quote
819 | [ \n]*
820 | )? # title is optional
821 | \)
822 | )
823 | }xs',
824 | array(&$this, '_doImages_inline_callback'), $text);
825 |
826 | return $text;
827 | }
828 | function _doImages_reference_callback($matches) {
829 | $whole_match = $matches[1];
830 | $alt_text = $matches[2];
831 | $link_id = strtolower($matches[3]);
832 |
833 | if ($link_id == "") {
834 | $link_id = strtolower($alt_text); # for shortcut links like ![this][].
835 | }
836 |
837 | $alt_text = $this->encodeAttribute($alt_text);
838 | if (isset($this->urls[$link_id])) {
839 | $url = $this->encodeAttribute($this->urls[$link_id]);
840 | $result = "![\"$alt_text\"";](\"$url\")
titles[$link_id])) {
842 | $title = $this->titles[$link_id];
843 | $title = $this->encodeAttribute($title);
844 | $result .= " title=\"$title\"";
845 | }
846 | $result .= $this->empty_element_suffix;
847 | $result = $this->hashPart($result);
848 | }
849 | else {
850 | # If there's no such link ID, leave intact:
851 | $result = $whole_match;
852 | }
853 |
854 | return $result;
855 | }
856 | function _doImages_inline_callback($matches) {
857 | $whole_match = $matches[1];
858 | $alt_text = $matches[2];
859 | $url = $matches[3] == '' ? $matches[4] : $matches[3];
860 | $title =& $matches[7];
861 |
862 | $alt_text = $this->encodeAttribute($alt_text);
863 | $url = $this->encodeAttribute($url);
864 | $result = "encodeAttribute($title);
867 | $result .= " title=\"$title\""; # $title already quoted
868 | }
869 | $result .= $this->empty_element_suffix;
870 |
871 | return $this->hashPart($result);
872 | }
873 |
874 |
875 | function doHeaders($text) {
876 | # Setext-style headers:
877 | # Header 1
878 | # ========
879 | #
880 | # Header 2
881 | # --------
882 | #
883 | $text = preg_replace_callback('{ ^(.+?)[ ]*\n(=+|-+)[ ]*\n+ }mx',
884 | array(&$this, '_doHeaders_callback_setext'), $text);
885 |
886 | # atx-style headers:
887 | # # Header 1
888 | # ## Header 2
889 | # ## Header 2 with closing hashes ##
890 | # ...
891 | # ###### Header 6
892 | #
893 | $text = preg_replace_callback('{
894 | ^(\#{1,6}) # $1 = string of #\'s
895 | [ ]*
896 | (.+?) # $2 = Header text
897 | [ ]*
898 | \#* # optional closing #\'s (not counted)
899 | \n+
900 | }xm',
901 | array(&$this, '_doHeaders_callback_atx'), $text);
902 |
903 | return $text;
904 | }
905 | function _doHeaders_callback_setext($matches) {
906 | # Terrible hack to check we haven't found an empty list item.
907 | if ($matches[2] == '-' && preg_match('{^-(?: |$)}', $matches[1]))
908 | return $matches[0];
909 |
910 | $level = $matches[2]{0} == '=' ? 1 : 2;
911 | $block = "".$this->runSpanGamut($matches[1])."";
912 | return "\n" . $this->hashBlock($block) . "\n\n";
913 | }
914 | function _doHeaders_callback_atx($matches) {
915 | $level = strlen($matches[1]);
916 | $block = "".$this->runSpanGamut($matches[2])."";
917 | return "\n" . $this->hashBlock($block) . "\n\n";
918 | }
919 |
920 |
921 | function doLists($text) {
922 | #
923 | # Form HTML ordered (numbered) and unordered (bulleted) lists.
924 | #
925 | $less_than_tab = $this->tab_width - 1;
926 |
927 | # Re-usable patterns to match list item bullets and number markers:
928 | $marker_ul_re = '[*+-]';
929 | $marker_ol_re = '\d+[\.]';
930 | $marker_any_re = "(?:$marker_ul_re|$marker_ol_re)";
931 |
932 | $markers_relist = array(
933 | $marker_ul_re => $marker_ol_re,
934 | $marker_ol_re => $marker_ul_re,
935 | );
936 |
937 | foreach ($markers_relist as $marker_re => $other_marker_re) {
938 | # Re-usable pattern to match any entirel ul or ol list:
939 | $whole_list_re = '
940 | ( # $1 = whole list
941 | ( # $2
942 | ([ ]{0,'.$less_than_tab.'}) # $3 = number of spaces
943 | ('.$marker_re.') # $4 = first list item marker
944 | [ ]+
945 | )
946 | (?s:.+?)
947 | ( # $5
948 | \z
949 | |
950 | \n{2,}
951 | (?=\S)
952 | (?! # Negative lookahead for another list item marker
953 | [ ]*
954 | '.$marker_re.'[ ]+
955 | )
956 | |
957 | (?= # Lookahead for another kind of list
958 | \n
959 | \3 # Must have the same indentation
960 | '.$other_marker_re.'[ ]+
961 | )
962 | )
963 | )
964 | '; // mx
965 |
966 | # We use a different prefix before nested lists than top-level lists.
967 | # See extended comment in _ProcessListItems().
968 |
969 | if ($this->list_level) {
970 | $text = preg_replace_callback('{
971 | ^
972 | '.$whole_list_re.'
973 | }mx',
974 | array(&$this, '_doLists_callback'), $text);
975 | }
976 | else {
977 | $text = preg_replace_callback('{
978 | (?:(?<=\n)\n|\A\n?) # Must eat the newline
979 | '.$whole_list_re.'
980 | }mx',
981 | array(&$this, '_doLists_callback'), $text);
982 | }
983 | }
984 |
985 | return $text;
986 | }
987 | function _doLists_callback($matches) {
988 | # Re-usable patterns to match list item bullets and number markers:
989 | $marker_ul_re = '[*+-]';
990 | $marker_ol_re = '\d+[\.]';
991 | $marker_any_re = "(?:$marker_ul_re|$marker_ol_re)";
992 |
993 | $list = $matches[1];
994 | $list_type = preg_match("/$marker_ul_re/", $matches[4]) ? "ul" : "ol";
995 |
996 | $marker_any_re = ( $list_type == "ul" ? $marker_ul_re : $marker_ol_re );
997 |
998 | $list .= "\n";
999 | $result = $this->processListItems($list, $marker_any_re);
1000 |
1001 | $result = $this->hashBlock("<$list_type>\n" . $result . "");
1002 | return "\n". $result ."\n\n";
1003 | }
1004 |
1005 | var $list_level = 0;
1006 |
1007 | function processListItems($list_str, $marker_any_re) {
1008 | #
1009 | # Process the contents of a single ordered or unordered list, splitting it
1010 | # into individual list items.
1011 | #
1012 | # The $this->list_level global keeps track of when we're inside a list.
1013 | # Each time we enter a list, we increment it; when we leave a list,
1014 | # we decrement. If it's zero, we're not in a list anymore.
1015 | #
1016 | # We do this because when we're not inside a list, we want to treat
1017 | # something like this:
1018 | #
1019 | # I recommend upgrading to version
1020 | # 8. Oops, now this line is treated
1021 | # as a sub-list.
1022 | #
1023 | # As a single paragraph, despite the fact that the second line starts
1024 | # with a digit-period-space sequence.
1025 | #
1026 | # Whereas when we're inside a list (or sub-list), that line will be
1027 | # treated as the start of a sub-list. What a kludge, huh? This is
1028 | # an aspect of Markdown's syntax that's hard to parse perfectly
1029 | # without resorting to mind-reading. Perhaps the solution is to
1030 | # change the syntax rules such that sub-lists must start with a
1031 | # starting cardinal number; e.g. "1." or "a.".
1032 |
1033 | $this->list_level++;
1034 |
1035 | # trim trailing blank lines:
1036 | $list_str = preg_replace("/\n{2,}\\z/", "\n", $list_str);
1037 |
1038 | $list_str = preg_replace_callback('{
1039 | (\n)? # leading line = $1
1040 | (^[ ]*) # leading whitespace = $2
1041 | ('.$marker_any_re.' # list marker and space = $3
1042 | (?:[ ]+|(?=\n)) # space only required if item is not empty
1043 | )
1044 | ((?s:.*?)) # list item text = $4
1045 | (?:(\n+(?=\n))|\n) # tailing blank line = $5
1046 | (?= \n* (\z | \2 ('.$marker_any_re.') (?:[ ]+|(?=\n))))
1047 | }xm',
1048 | array(&$this, '_processListItems_callback'), $list_str);
1049 |
1050 | $this->list_level--;
1051 | return $list_str;
1052 | }
1053 | function _processListItems_callback($matches) {
1054 | $item = $matches[4];
1055 | $leading_line =& $matches[1];
1056 | $leading_space =& $matches[2];
1057 | $marker_space = $matches[3];
1058 | $tailing_blank_line =& $matches[5];
1059 |
1060 | if ($leading_line || $tailing_blank_line ||
1061 | preg_match('/\n{2,}/', $item))
1062 | {
1063 | # Replace marker with the appropriate whitespace indentation
1064 | $item = $leading_space . str_repeat(' ', strlen($marker_space)) . $item;
1065 | $item = $this->runBlockGamut($this->outdent($item)."\n");
1066 | }
1067 | else {
1068 | # Recursion for sub-lists:
1069 | $item = $this->doLists($this->outdent($item));
1070 | $item = preg_replace('/\n+$/', '', $item);
1071 | $item = $this->runSpanGamut($item);
1072 | }
1073 |
1074 | return "" . $item . "\n";
1075 | }
1076 |
1077 |
1078 | function doCodeBlocks($text) {
1079 | #
1080 | # Process Markdown `` blocks.
1081 | #
1082 | $text = preg_replace_callback('{
1083 | (?:\n\n|\A\n?)
1084 | ( # $1 = the code block -- one or more lines, starting with a space/tab
1085 | (?>
1086 | [ ]{'.$this->tab_width.'} # Lines must start with a tab or a tab-width of spaces
1087 | .*\n+
1088 | )+
1089 | )
1090 | ((?=^[ ]{0,'.$this->tab_width.'}\S)|\Z) # Lookahead for non-space at line-start, or end of doc
1091 | }xm',
1092 | array(&$this, '_doCodeBlocks_callback'), $text);
1093 |
1094 | return $text;
1095 | }
1096 | function _doCodeBlocks_callback($matches) {
1097 | $codeblock = $matches[1];
1098 |
1099 | $codeblock = $this->outdent($codeblock);
1100 | $codeblock = htmlspecialchars($codeblock, ENT_NOQUOTES);
1101 |
1102 | # trim leading newlines and trailing newlines
1103 | $codeblock = preg_replace('/\A\n+|\n+\z/', '', $codeblock);
1104 |
1105 | $codeblock = "$codeblock\n
";
1106 | return "\n\n".$this->hashBlock($codeblock)."\n\n";
1107 | }
1108 |
1109 |
1110 | function makeCodeSpan($code) {
1111 | #
1112 | # Create a code span markup for $code. Called from handleSpanToken.
1113 | #
1114 | $code = htmlspecialchars(trim($code), ENT_NOQUOTES);
1115 | return $this->hashPart("$code");
1116 | }
1117 |
1118 |
1119 | var $em_relist = array(
1120 | '' => '(?:(? '(?<=\S|^)(? '(?<=\S|^)(? '(?:(? '(?<=\S|^)(? '(?<=\S|^)(? '(?:(? '(?<=\S|^)(? '(?<=\S|^)(?em_relist as $em => $em_re) {
1142 | foreach ($this->strong_relist as $strong => $strong_re) {
1143 | # Construct list of allowed token expressions.
1144 | $token_relist = array();
1145 | if (isset($this->em_strong_relist["$em$strong"])) {
1146 | $token_relist[] = $this->em_strong_relist["$em$strong"];
1147 | }
1148 | $token_relist[] = $em_re;
1149 | $token_relist[] = $strong_re;
1150 |
1151 | # Construct master expression from list.
1152 | $token_re = '{('. implode('|', $token_relist) .')}';
1153 | $this->em_strong_prepared_relist["$em$strong"] = $token_re;
1154 | }
1155 | }
1156 | }
1157 |
1158 | function doItalicsAndBold($text) {
1159 | $token_stack = array('');
1160 | $text_stack = array('');
1161 | $em = '';
1162 | $strong = '';
1163 | $tree_char_em = false;
1164 |
1165 | while (1) {
1166 | #
1167 | # Get prepared regular expression for seraching emphasis tokens
1168 | # in current context.
1169 | #
1170 | $token_re = $this->em_strong_prepared_relist["$em$strong"];
1171 |
1172 | #
1173 | # Each loop iteration search for the next emphasis token.
1174 | # Each token is then passed to handleSpanToken.
1175 | #
1176 | $parts = preg_split($token_re, $text, 2, PREG_SPLIT_DELIM_CAPTURE);
1177 | $text_stack[0] .= $parts[0];
1178 | $token =& $parts[1];
1179 | $text =& $parts[2];
1180 |
1181 | if (empty($token)) {
1182 | # Reached end of text span: empty stack without emitting.
1183 | # any more emphasis.
1184 | while ($token_stack[0]) {
1185 | $text_stack[1] .= array_shift($token_stack);
1186 | $text_stack[0] .= array_shift($text_stack);
1187 | }
1188 | break;
1189 | }
1190 |
1191 | $token_len = strlen($token);
1192 | if ($tree_char_em) {
1193 | # Reached closing marker while inside a three-char emphasis.
1194 | if ($token_len == 3) {
1195 | # Three-char closing marker, close em and strong.
1196 | array_shift($token_stack);
1197 | $span = array_shift($text_stack);
1198 | $span = $this->runSpanGamut($span);
1199 | $span = "$span";
1200 | $text_stack[0] .= $this->hashPart($span);
1201 | $em = '';
1202 | $strong = '';
1203 | } else {
1204 | # Other closing marker: close one em or strong and
1205 | # change current token state to match the other
1206 | $token_stack[0] = str_repeat($token{0}, 3-$token_len);
1207 | $tag = $token_len == 2 ? "strong" : "em";
1208 | $span = $text_stack[0];
1209 | $span = $this->runSpanGamut($span);
1210 | $span = "<$tag>$span";
1211 | $text_stack[0] = $this->hashPart($span);
1212 | $$tag = ''; # $$tag stands for $em or $strong
1213 | }
1214 | $tree_char_em = false;
1215 | } else if ($token_len == 3) {
1216 | if ($em) {
1217 | # Reached closing marker for both em and strong.
1218 | # Closing strong marker:
1219 | for ($i = 0; $i < 2; ++$i) {
1220 | $shifted_token = array_shift($token_stack);
1221 | $tag = strlen($shifted_token) == 2 ? "strong" : "em";
1222 | $span = array_shift($text_stack);
1223 | $span = $this->runSpanGamut($span);
1224 | $span = "<$tag>$span";
1225 | $text_stack[0] .= $this->hashPart($span);
1226 | $$tag = ''; # $$tag stands for $em or $strong
1227 | }
1228 | } else {
1229 | # Reached opening three-char emphasis marker. Push on token
1230 | # stack; will be handled by the special condition above.
1231 | $em = $token{0};
1232 | $strong = "$em$em";
1233 | array_unshift($token_stack, $token);
1234 | array_unshift($text_stack, '');
1235 | $tree_char_em = true;
1236 | }
1237 | } else if ($token_len == 2) {
1238 | if ($strong) {
1239 | # Unwind any dangling emphasis marker:
1240 | if (strlen($token_stack[0]) == 1) {
1241 | $text_stack[1] .= array_shift($token_stack);
1242 | $text_stack[0] .= array_shift($text_stack);
1243 | }
1244 | # Closing strong marker:
1245 | array_shift($token_stack);
1246 | $span = array_shift($text_stack);
1247 | $span = $this->runSpanGamut($span);
1248 | $span = "$span";
1249 | $text_stack[0] .= $this->hashPart($span);
1250 | $strong = '';
1251 | } else {
1252 | array_unshift($token_stack, $token);
1253 | array_unshift($text_stack, '');
1254 | $strong = $token;
1255 | }
1256 | } else {
1257 | # Here $token_len == 1
1258 | if ($em) {
1259 | if (strlen($token_stack[0]) == 1) {
1260 | # Closing emphasis marker:
1261 | array_shift($token_stack);
1262 | $span = array_shift($text_stack);
1263 | $span = $this->runSpanGamut($span);
1264 | $span = "$span";
1265 | $text_stack[0] .= $this->hashPart($span);
1266 | $em = '';
1267 | } else {
1268 | $text_stack[0] .= $token;
1269 | }
1270 | } else {
1271 | array_unshift($token_stack, $token);
1272 | array_unshift($text_stack, '');
1273 | $em = $token;
1274 | }
1275 | }
1276 | }
1277 | return $text_stack[0];
1278 | }
1279 |
1280 |
1281 | function doBlockQuotes($text) {
1282 | $text = preg_replace_callback('/
1283 | ( # Wrap whole match in $1
1284 | (?>
1285 | ^[ ]*>[ ]? # ">" at the start of a line
1286 | .+\n # rest of the first line
1287 | (.+\n)* # subsequent consecutive lines
1288 | \n* # blanks
1289 | )+
1290 | )
1291 | /xm',
1292 | array(&$this, '_doBlockQuotes_callback'), $text);
1293 |
1294 | return $text;
1295 | }
1296 | function _doBlockQuotes_callback($matches) {
1297 | $bq = $matches[1];
1298 | # trim one level of quoting - trim whitespace-only lines
1299 | $bq = preg_replace('/^[ ]*>[ ]?|^[ ]+$/m', '', $bq);
1300 | $bq = $this->runBlockGamut($bq); # recurse
1301 |
1302 | $bq = preg_replace('/^/m', " ", $bq);
1303 | # These leading spaces cause problem with content,
1304 | # so we need to fix that:
1305 | $bq = preg_replace_callback('{(\s*.+?
)}sx',
1306 | array(&$this, '_doBlockQuotes_callback2'), $bq);
1307 |
1308 | return "\n". $this->hashBlock("\n$bq\n
")."\n\n";
1309 | }
1310 | function _doBlockQuotes_callback2($matches) {
1311 | $pre = $matches[1];
1312 | $pre = preg_replace('/^ /m', '', $pre);
1313 | return $pre;
1314 | }
1315 |
1316 |
1317 | function formParagraphs($text) {
1318 | #
1319 | # Params:
1320 | # $text - string to process with html tags
1321 | #
1322 | # Strip leading and trailing lines:
1323 | $text = preg_replace('/\A\n+|\n+\z/', '', $text);
1324 |
1325 | $grafs = preg_split('/\n{2,}/', $text, -1, PREG_SPLIT_NO_EMPTY);
1326 |
1327 | #
1328 | # Wrap
tags and unhashify HTML blocks
1329 | #
1330 | foreach ($grafs as $key => $value) {
1331 | if (!preg_match('/^B\x1A[0-9]+B$/', $value)) {
1332 | # Is a paragraph.
1333 | $value = $this->runSpanGamut($value);
1334 | $value = preg_replace('/^([ ]*)/', "
", $value);
1335 | $value .= "
";
1336 | $grafs[$key] = $this->unhash($value);
1337 | }
1338 | else {
1339 | # Is a block.
1340 | # Modify elements of @grafs in-place...
1341 | $graf = $value;
1342 | $block = $this->html_hashes[$graf];
1343 | $graf = $block;
1344 | // if (preg_match('{
1345 | // \A
1346 | // ( # $1 = tag
1347 | //
]*
1349 | // \b
1350 | // markdown\s*=\s* ([\'"]) # $2 = attr quote char
1351 | // 1
1352 | // \2
1353 | // [^>]*
1354 | // >
1355 | // )
1356 | // ( # $3 = contents
1357 | // .*
1358 | // )
1359 | // (
) # $4 = closing tag
1360 | // \z
1361 | // }xs', $block, $matches))
1362 | // {
1363 | // list(, $div_open, , $div_content, $div_close) = $matches;
1364 | //
1365 | // # We can't call Markdown(), because that resets the hash;
1366 | // # that initialization code should be pulled into its own sub, though.
1367 | // $div_content = $this->hashHTMLBlocks($div_content);
1368 | //
1369 | // # Run document gamut methods on the content.
1370 | // foreach ($this->document_gamut as $method => $priority) {
1371 | // $div_content = $this->$method($div_content);
1372 | // }
1373 | //
1374 | // $div_open = preg_replace(
1375 | // '{\smarkdown\s*=\s*([\'"]).+?\1}', '', $div_open);
1376 | //
1377 | // $graf = $div_open . "\n" . $div_content . "\n" . $div_close;
1378 | // }
1379 | $grafs[$key] = $graf;
1380 | }
1381 | }
1382 |
1383 | return implode("\n\n", $grafs);
1384 | }
1385 |
1386 |
1387 | function encodeAttribute($text) {
1388 | #
1389 | # Encode text for a double-quoted HTML attribute. This function
1390 | # is *not* suitable for attributes enclosed in single quotes.
1391 | #
1392 | $text = $this->encodeAmpsAndAngles($text);
1393 | $text = str_replace('"', '"', $text);
1394 | return $text;
1395 | }
1396 |
1397 |
1398 | function encodeAmpsAndAngles($text) {
1399 | #
1400 | # Smart processing for ampersands and angle brackets that need to
1401 | # be encoded. Valid character entities are left alone unless the
1402 | # no-entities mode is set.
1403 | #
1404 | if ($this->no_entities) {
1405 | $text = str_replace('&', '&', $text);
1406 | } else {
1407 | # Ampersand-encoding based entirely on Nat Irons's Amputator
1408 | # MT plugin:
1409 | $text = preg_replace('/&(?!#?[xX]?(?:[0-9a-fA-F]+|\w+);)/',
1410 | '&', $text);;
1411 | }
1412 | # Encode remaining <'s
1413 | $text = str_replace('<', '<', $text);
1414 |
1415 | return $text;
1416 | }
1417 |
1418 |
1419 | function doAutoLinks($text) {
1420 | $text = preg_replace_callback('{<((https?|ftp|dict):[^\'">\s]+)>}i',
1421 | array(&$this, '_doAutoLinks_url_callback'), $text);
1422 |
1423 | # Email addresses:
1424 | $text = preg_replace_callback('{
1425 | <
1426 | (?:mailto:)?
1427 | (
1428 | (?:
1429 | [-!#$%&\'*+/=?^_`.{|}~\w\x80-\xFF]+
1430 | |
1431 | ".*?"
1432 | )
1433 | \@
1434 | (?:
1435 | [-a-z0-9\x80-\xFF]+(\.[-a-z0-9\x80-\xFF]+)*\.[a-z]+
1436 | |
1437 | \[[\d.a-fA-F:]+\] # IPv4 & IPv6
1438 | )
1439 | )
1440 | >
1441 | }xi',
1442 | array(&$this, '_doAutoLinks_email_callback'), $text);
1443 |
1444 | return $text;
1445 | }
1446 | function _doAutoLinks_url_callback($matches) {
1447 | $url = $this->encodeAttribute($matches[1]);
1448 | $link = "$url";
1449 | return $this->hashPart($link);
1450 | }
1451 | function _doAutoLinks_email_callback($matches) {
1452 | $address = $matches[1];
1453 | $link = $this->encodeEmailAddress($address);
1454 | return $this->hashPart($link);
1455 | }
1456 |
1457 |
1458 | function encodeEmailAddress($addr) {
1459 | #
1460 | # Input: an email address, e.g. "foo@example.com"
1461 | #
1462 | # Output: the email address as a mailto link, with each character
1463 | # of the address encoded as either a decimal or hex entity, in
1464 | # the hopes of foiling most address harvesting spam bots. E.g.:
1465 | #
1466 | # foo@exampl
1469 | # e.com
1470 | #
1471 | # Based by a filter by Matthew Wickline, posted to BBEdit-Talk.
1472 | # With some optimizations by Milian Wolff.
1473 | #
1474 | $addr = "mailto:" . $addr;
1475 | $chars = preg_split('/(? $char) {
1479 | $ord = ord($char);
1480 | # Ignore non-ascii chars.
1481 | if ($ord < 128) {
1482 | $r = ($seed * (1 + $key)) % 100; # Pseudo-random function.
1483 | # roughly 10% raw, 45% hex, 45% dec
1484 | # '@' *must* be encoded. I insist.
1485 | if ($r > 90 && $char != '@') /* do nothing */;
1486 | else if ($r < 45) $chars[$key] = '&#x'.dechex($ord).';';
1487 | else $chars[$key] = '&#'.$ord.';';
1488 | }
1489 | }
1490 |
1491 | $addr = implode('', $chars);
1492 | $text = implode('', array_slice($chars, 7)); # text without `mailto:`
1493 | $addr = "$text";
1494 |
1495 | return $addr;
1496 | }
1497 |
1498 |
1499 | function parseSpan($str) {
1500 | #
1501 | # Take the string $str and parse it into tokens, hashing embeded HTML,
1502 | # escaped characters and handling code spans.
1503 | #
1504 | $output = '';
1505 |
1506 | $span_re = '{
1507 | (
1508 | \\\\'.$this->escape_chars_re.'
1509 | |
1510 | (?no_markup ? '' : '
1513 | |
1514 | # comment
1515 | |
1516 | <\?.*?\?> | <%.*?%> # processing instruction
1517 | |
1518 | <[/!$]?[-a-zA-Z0-9:_]+ # regular tags
1519 | (?>
1520 | \s
1521 | (?>[^"\'>]+|"[^"]*"|\'[^\']*\')*
1522 | )?
1523 | >
1524 | ').'
1525 | )
1526 | }xs';
1527 |
1528 | while (1) {
1529 | #
1530 | # Each loop iteration seach for either the next tag, the next
1531 | # openning code span marker, or the next escaped character.
1532 | # Each token is then passed to handleSpanToken.
1533 | #
1534 | $parts = preg_split($span_re, $str, 2, PREG_SPLIT_DELIM_CAPTURE);
1535 |
1536 | # Create token from text preceding tag.
1537 | if ($parts[0] != "") {
1538 | $output .= $parts[0];
1539 | }
1540 |
1541 | # Check if we reach the end.
1542 | if (isset($parts[1])) {
1543 | $output .= $this->handleSpanToken($parts[1], $parts[2]);
1544 | $str = $parts[2];
1545 | }
1546 | else {
1547 | break;
1548 | }
1549 | }
1550 |
1551 | return $output;
1552 | }
1553 |
1554 |
1555 | function handleSpanToken($token, &$str) {
1556 | #
1557 | # Handle $token provided by parseSpan by determining its nature and
1558 | # returning the corresponding value that should replace it.
1559 | #
1560 | switch ($token{0}) {
1561 | case "\\":
1562 | return $this->hashPart("&#". ord($token{1}). ";");
1563 | case "`":
1564 | # Search for end marker in remaining text.
1565 | if (preg_match('/^(.*?[^`])'.preg_quote($token).'(?!`)(.*)$/sm',
1566 | $str, $matches))
1567 | {
1568 | $str = $matches[2];
1569 | $codespan = $this->makeCodeSpan($matches[1]);
1570 | return $this->hashPart($codespan);
1571 | }
1572 | return $token; // return as text since no ending marker found.
1573 | default:
1574 | return $this->hashPart($token);
1575 | }
1576 | }
1577 |
1578 |
1579 | function outdent($text) {
1580 | #
1581 | # Remove one level of line-leading tabs or spaces
1582 | #
1583 | return preg_replace('/^(\t|[ ]{1,'.$this->tab_width.'})/m', '', $text);
1584 | }
1585 |
1586 |
1587 | # String length function for detab. `_initDetab` will create a function to
1588 | # hanlde UTF-8 if the default function does not exist.
1589 | var $utf8_strlen = 'mb_strlen';
1590 |
1591 | function detab($text) {
1592 | #
1593 | # Replace tabs with the appropriate amount of space.
1594 | #
1595 | # For each line we separate the line in blocks delemited by
1596 | # tab characters. Then we reconstruct every line by adding the
1597 | # appropriate number of space between each blocks.
1598 |
1599 | $text = preg_replace_callback('/^.*\t.*$/m',
1600 | array(&$this, '_detab_callback'), $text);
1601 |
1602 | return $text;
1603 | }
1604 | function _detab_callback($matches) {
1605 | $line = $matches[0];
1606 | $strlen = $this->utf8_strlen; # strlen function for UTF-8.
1607 |
1608 | # Split in blocks.
1609 | $blocks = explode("\t", $line);
1610 | # Add each blocks to the line.
1611 | $line = $blocks[0];
1612 | unset($blocks[0]); # Do not add first block twice.
1613 | foreach ($blocks as $block) {
1614 | # Calculate amount of space, insert spaces, insert block.
1615 | $amount = $this->tab_width -
1616 | $strlen($line, 'UTF-8') % $this->tab_width;
1617 | $line .= str_repeat(" ", $amount) . $block;
1618 | }
1619 | return $line;
1620 | }
1621 | function _initDetab() {
1622 | #
1623 | # Check for the availability of the function in the `utf8_strlen` property
1624 | # (initially `mb_strlen`). If the function is not available, create a
1625 | # function that will loosely count the number of UTF-8 characters with a
1626 | # regular expression.
1627 | #
1628 | if (function_exists($this->utf8_strlen)) return;
1629 | $this->utf8_strlen = create_function('$text', 'return preg_match_all(
1630 | "/[\\\\x00-\\\\xBF]|[\\\\xC0-\\\\xFF][\\\\x80-\\\\xBF]*/",
1631 | $text, $m);');
1632 | }
1633 |
1634 |
1635 | function unhash($text) {
1636 | #
1637 | # Swap back in all the tags hashed by _HashHTMLBlocks.
1638 | #
1639 | return preg_replace_callback('/(.)\x1A[0-9]+\1/',
1640 | array(&$this, '_unhash_callback'), $text);
1641 | }
1642 | function _unhash_callback($matches) {
1643 | return $this->html_hashes[$matches[0]];
1644 | }
1645 |
1646 | }
1647 |
1648 | /*
1649 |
1650 | PHP Markdown
1651 | ============
1652 |
1653 | Description
1654 | -----------
1655 |
1656 | This is a PHP translation of the original Markdown formatter written in
1657 | Perl by John Gruber.
1658 |
1659 | Markdown is a text-to-HTML filter; it translates an easy-to-read /
1660 | easy-to-write structured text format into HTML. Markdown's text format
1661 | is most similar to that of plain text email, and supports features such
1662 | as headers, *emphasis*, code blocks, blockquotes, and links.
1663 |
1664 | Markdown's syntax is designed not as a generic markup language, but
1665 | specifically to serve as a front-end to (X)HTML. You can use span-level
1666 | HTML tags anywhere in a Markdown document, and you can use block level
1667 | HTML tags (like and
as well).
1668 |
1669 | For more information about Markdown's syntax, see:
1670 |
1671 |
1672 |
1673 |
1674 | Bugs
1675 | ----
1676 |
1677 | To file bug reports please send email to:
1678 |
1679 |
1680 |
1681 | Please include with your report: (1) the example input; (2) the output you
1682 | expected; (3) the output Markdown actually produced.
1683 |
1684 |
1685 | Version History
1686 | ---------------
1687 |
1688 | See the readme file for detailed release notes for this version.
1689 |
1690 |
1691 | Copyright and License
1692 | ---------------------
1693 |
1694 | PHP Markdown
1695 | Copyright (c) 2004-2009 Michel Fortin
1696 |
1697 | All rights reserved.
1698 |
1699 | Based on Markdown
1700 | Copyright (c) 2003-2006 John Gruber
1701 |
1702 | All rights reserved.
1703 |
1704 | Redistribution and use in source and binary forms, with or without
1705 | modification, are permitted provided that the following conditions are
1706 | met:
1707 |
1708 | * Redistributions of source code must retain the above copyright notice,
1709 | this list of conditions and the following disclaimer.
1710 |
1711 | * Redistributions in binary form must reproduce the above copyright
1712 | notice, this list of conditions and the following disclaimer in the
1713 | documentation and/or other materials provided with the distribution.
1714 |
1715 | * Neither the name "Markdown" nor the names of its contributors may
1716 | be used to endorse or promote products derived from this software
1717 | without specific prior written permission.
1718 |
1719 | This software is provided by the copyright holders and contributors "as
1720 | is" and any express or implied warranties, including, but not limited
1721 | to, the implied warranties of merchantability and fitness for a
1722 | particular purpose are disclaimed. In no event shall the copyright owner
1723 | or contributors be liable for any direct, indirect, incidental, special,
1724 | exemplary, or consequential damages (including, but not limited to,
1725 | procurement of substitute goods or services; loss of use, data, or
1726 | profits; or business interruption) however caused and on any theory of
1727 | liability, whether in contract, strict liability, or tort (including
1728 | negligence or otherwise) arising in any way out of the use of this
1729 | software, even if advised of the possibility of such damage.
1730 |
1731 | */
1732 | ?>
--------------------------------------------------------------------------------
/scoreboard.php:
--------------------------------------------------------------------------------
1 |
16 | Problems
17 | Submissions
18 | Scoreboard
19 | Account
20 | Logout
21 |
22 |
23 |
24 |
25 |
26 |
27 |
28 | The current standings of all the participants, the number of problems they have attempted and solved.
29 |
30 |
31 | | Name |
32 | Solved |
33 | Attempted |
34 |
35 |
36 | ".$row['username']." ");
44 | if($row['status'] == 0) echo(" Banned");
45 | echo(" | ".mysql_num_rows($res));
46 | $sql = "SELECT * FROM solve WHERE (status='1' AND username='".$row['username']."')";
47 | $res = mysql_query($sql);
48 | echo(" | ".mysql_num_rows($res)." | ");
49 | }
50 | ?>
51 |
52 |
53 |
28 | \nYour program exceeded the time limit. Maybe you should improve your algorithm.\n
");
31 | if(isset($_GET['cerror']))
32 | echo("\n
The following errors occured:\n
\n".$_SESSION['cerror']."\n
\n
\nYour program output did not match the solution for the problem. Please check your program and try again.\n
");
35 | else if(isset($_GET['lerror']))
36 | echo("\nYou did not use one of the allowed languages. Please use a language that is allowed.\n
");
37 | else if(isset($_GET['serror']))
38 | echo("\nCould not connect to the compiler server. Please contact the admin to solve the problem.\n
");
39 | else if(isset($_GET['derror']))
40 | echo("\nPlease enter all the details asked before you can continue!\n
");
41 | else if(isset($_GET['ferror']))
42 | echo("\nPlease enter a legal filename.\n
");
43 |
44 | $query = "SELECT * FROM prefs";
45 | $result = mysql_query($query);
46 | $accept = mysql_fetch_array($result);
47 | $query = "SELECT status FROM users WHERE username='".$_SESSION['username']."'";
48 | $result = mysql_query($query);
49 | $status = mysql_fetch_array($result);
50 | if($accept['accept'] == 0)
51 | echo("\nSubmissions are closed now!\n
");
52 | if($status['status'] == 0)
53 | echo("\nYou have been banned. You cannot submit a solution.\n
");
54 | ?>
55 | Submit Solution
56 | \n".$row['name']."
\n");
65 | echo($out);
66 | ?>
67 |
Time Limit: seconds
68 |
69 |
78 |
121 |
124 |
125 |
126 |
140 |
143 |
--------------------------------------------------------------------------------
/submissions.php:
--------------------------------------------------------------------------------
1 |
16 | Problems
17 | Submissions
18 | Scoreboard
19 | Account
20 | Logout
21 |
22 |
23 |
24 |
25 |
26 |
27 |
28 | Below is a list of submissions you have made. Click on any to edit it.
29 |
30 |
31 | | Problem |
32 | Attempts |
33 | Status |
34 |
35 |
36 | ".$field['name']." | ".$row['attempts']);
46 | if($row['status'] == 1)
47 | echo(" | Attempted | \n");
48 | else if($row['status'] == 2)
49 | echo("Solved | \n");
50 | }
51 | }
52 | ?>
53 |
54 |
55 |