"Fossies" - the Fresh Open Source Software Archive

Member "pp-2.14.3/test/pp-test.ref" (24 Nov 2021, 35806 Bytes) of package /linux/privat/pp-2.14.3.tar.gz:


As a special service "Fossies" has tried to format the requested text file into HTML format (style: standard) with prefixed line numbers. Alternatively you can here view or download the uninterpreted source code file. See also the latest Fossies "Diffs" side-by-side code changes report for "pp-test.ref": 2.14.2_vs_2.14.3.

    1 % PP test file (markdown)
    2 % Christophe Delord
    3 
    4 Introduction
    5 ============
    6 
    7 This document is a test file for `pp` version 2.14.3 by Christophe Delord.
    8 Copyright 2015-2021 Christophe Delord.
    9 
   10 It is preprocessed and compared with `pp-test.ref`.
   11 
   12 Macros definition
   13 =================
   14 
   15 ## Definition
   16 
   17 ----------------------------------- -----------------------------------------------------------------
   18 Definition of `mac1`                
   19 Show macro definition:              This is macro `mac1`
   20 Show macro value:                   This is macro `mac1`
   21 ----------------------------------- -----------------------------------------------------------------
   22 
   23 ## Undefinition
   24 
   25 ----------------------------------- -----------------------------------------------------------------
   26 Undefined macro `mac2`              
   27 Show macro definition:              
   28 Show macro value:                   !mac2
   29 ----------------------------------- -----------------------------------------------------------------
   30 
   31 ## Definition with arguments
   32 
   33 ----------------------------------- -----------------------------------------------------------------
   34 Definition with arguments:          
   35 Show macro definition:              !2 !1
   36 Show macro value:                   !mac2 This is macro `mac1`
   37 ----------------------------------- -----------------------------------------------------------------
   38 
   39 ## Passing arguments between user macros (see issue #29)
   40 
   41 ----------------------------------- -----------------------------------------------------------------
   42 A calls B calls C:                  C got 42
   43 same with 3 args:                   C got 44 42 43
   44 ----------------------------------- -----------------------------------------------------------------
   45 
   46 ----------------------------------- -----------------------------------------------------------------
   47 Undefinition:                       
   48 ----------------------------------- -----------------------------------------------------------------
   49 
   50 ----------------------------------- -----------------------------------------------------------------
   51 Definition test:                    
   52 Definition test:                    swap is defined
   53 Definition test:                    mac1 is not defined
   54 Definition test:                    swap is defined
   55 Undefinition test:                  mac1 is not defined
   56 Undefinition test:                  
   57 Undefinition test:                  mac1 is not defined
   58 Undefinition test:                  swap is defined
   59 Macro defined:                      1 0
   60 ----------------------------------- -------------------------------------------------------------
   61 
   62 ## Multiple code block arguments
   63 
   64  
   65 
   66 foo is defined
   67 
   68 bar is not defined
   69 
   70 ## Expressions
   71 
   72 
   73 "-1" => -1 (true)
   74 
   75 "1" => 1 (true)
   76 
   77 "2+3" => 5 (true)
   78 
   79 "4-5" => -1 (true)
   80 
   81 "6*7*8" => 336 (true)
   82 
   83 "8/2" => 4 (true)
   84 
   85 "! 0" => 1 (true)
   86  "not 0" => 1 (true)
   87  "! """ => 1 (true)
   88  "not """ => 1 (true)
   89 
   90 "! 3" => 0 (false)
   91  "not 3" => 0 (false)
   92  "! "?"" => 0 (false)
   93  "not "?"" => 0 (false)
   94 
   95 "3 and 4" => 1 (true)
   96  "3 and 0" => 0 (false)
   97  "0 and 4" => 0 (false)
   98  "0 and 0" => 0 (false)
   99 
  100 "3 && 4" => 1 (true)
  101  "3 && 0" => 0 (false)
  102  "0 && 4" => 0 (false)
  103  "0 && 0" => 0 (false)
  104 
  105 "3 or 4" => 1 (true)
  106  "3 or 0" => 1 (true)
  107  "0 or 4" => 1 (true)
  108  "0 or 0" => 0 (false)
  109 
  110 "3 || 4" => 1 (true)
  111  "3 || 0" => 1 (true)
  112  "0 || 4" => 1 (true)
  113  "0 || 0" => 0 (false)
  114 
  115 "3 xor 4" => 0 (false)
  116  "3 xor 0" => 1 (true)
  117  "0 xor 4" => 1 (true)
  118  "0 xor 0" => 0 (false)
  119 
  120 "3 == 2+1" => 1 (true)
  121  "3 == 2+2" => 0 (false)
  122  "3 == 2-1" => 0 (false)
  123 
  124 "3 /= 2+1" => 0 (false)
  125  "3 /= 2+2" => 1 (true)
  126  "3 /= 2-1" => 1 (true)
  127 
  128 "3 != 2+1" => 0 (false)
  129  "3 != 2+2" => 1 (true)
  130  "3 != 2-1" => 1 (true)
  131 
  132 "3 <= 2+1" => 1 (true)
  133  "3 <= 2+2" => 1 (true)
  134  "3 <= 2-1" => 0 (false)
  135 
  136 "3 < 2+1" => 0 (false)
  137  "3 < 2+2" => 1 (true)
  138  "3 < 2-1" => 0 (false)
  139 
  140 "3 >= 2+1" => 1 (true)
  141  "3 >= 2+2" => 0 (false)
  142  "3 >= 2-1" => 1 (true)
  143 
  144 "3 > 2+1" => 0 (false)
  145  "3 > 2+2" => 0 (false)
  146  "3 > 2-1" => 1 (true)
  147 
  148 "1" => 1 (true)
  149 
  150 "0" => 0 (false)
  151 
  152 "1 and 0" => 0 (false)
  153 
  154 "1 or 0" => 1 (true)
  155 
  156 "1 and not 0" => 1 (true)
  157 
  158 
  159 ## Testing argument scopes (see issue #33)
  160 
  161 
  162 
  163 ----------------------------------- -------------------------------------------------------------
  164 Before calling f:                    
  165 call with 2 args:                   f take 2 args: one and two but not !3
  166 between two calls:                   
  167 call with 1 arg:                    f take 2 args: one' and  but not !3
  168 between two calls:                   
  169 call with 2 args:                   f take 2 args: one'' and two'' but not !3
  170 after calling f:                     
  171 ----------------------------------- -------------------------------------------------------------
  172 
  173 
  174 ----------------------------------- -------------------------------------------------------------
  175 Before calling g:                    
  176 call with 2 args:                   f take 2 args: one and two but not !3
  177 between two calls:                   
  178 call with 1 arg:                    f take 2 args: one' and  but not !3
  179 between two calls:                   
  180 call with 2 args:                   f take 2 args: one'' and two'' but not !3
  181 after calling g:                     
  182 ----------------------------------- -------------------------------------------------------------
  183 
  184 
  185 ----------------------------------- -------------------------------------------------------------
  186 Before calling g:                    
  187 call with 2 args:                   f take 2 args: one and -two- but not !3
  188 between two calls:                   
  189 call with 1 arg:                    f take 2 args: one' and -- but not !3
  190 between two calls:                   
  191 call with 2 args:                   f take 2 args: one'' and -two''- but not !3
  192 after calling g:                     
  193 ----------------------------------- -------------------------------------------------------------
  194 
  195 ## Equality / Inequality
  196 
  197   
  198 
  199 ----------------------------------- -----------------------------------------------------------------
  200 Equality test:                      one == un
  201 Equality test:                      
  202 Equality test:                      one == un
  203 Equality test:                      one /= two
  204 Inequality test:                    
  205 Inequality test:                    one /= two
  206 Inequality test:                    one == un
  207 Inequality test:                    one /= two
  208 ----------------------------------- -----------------------------------------------------------------
  209 
  210 ----------------------------------- -----------------------------------------------------------------
  211 Raw text:                           !swap(a)(b)
  212 Evaluated:                          b a
  213 ----------------------------------- -----------------------------------------------------------------
  214 
  215 File inclusion
  216 ==============
  217 
  218 ## Before including `subdir/pp-test.i`
  219 
  220 ----------------------------------- -----------------------------------------------------------------
  221 File name of the main file:         test/pp-test.md
  222 Directory of the main file:         test
  223 File name of the current file:      test/pp-test.md
  224 Directory of the current file:      test
  225 ----------------------------------- -----------------------------------------------------------------
  226 
  227 ## Inclusion of `subdir/pp-test.i`
  228 
  229 First line of the included file.
  230 
  231 ----------------------------------- -----------------------------------------------------------------
  232 File name of the main file:         test/pp-test.md
  233 Directory of the main file:         test
  234 File name of the included file:     test/subdir/pp-test.i
  235 Directory of the included file:     test/subdir
  236 Definitions:                        answer = 42
  237 ----------------------------------- -----------------------------------------------------------------
  238 
  239 Last line of the included file.
  240 
  241 
  242 ## After including `subdir/pp-test.i`
  243 
  244 ----------------------------------- -----------------------------------------------------------------
  245 Definitions:                        42
  246 ----------------------------------- -----------------------------------------------------------------
  247 
  248 ## Files included without preprocessing
  249 
  250 ----------------------------------- -----------------------------------------------------------------
  251 Undefinition:                       
  252 ----------------------------------- -----------------------------------------------------------------
  253 
  254 First line of the included file.
  255 
  256 ----------------------------------- -----------------------------------------------------------------
  257 File name of the main file:         !main
  258 Directory of the main file:         !root
  259 File name of the included file:     !file
  260 Directory of the included file:     !cwd
  261 Definitions:                        !def(answer)(42)answer = !answer
  262 ----------------------------------- -----------------------------------------------------------------
  263 
  264 Last line of the included file.
  265 
  266 
  267 ----------------------------------- -----------------------------------------------------------------
  268 No definitions:                     !answer
  269 ----------------------------------- -----------------------------------------------------------------
  270 
  271 ## Files imported
  272 
  273 In the document:
  274 
  275 
  276 
  277 Before importing: answer = !answer
  278 
  279 After import: answer = 42
  280 
  281 And from the command line:
  282 
  283 imported_macro: The imported macro works!
  284 
  285 ## Mustache template preprocessor
  286 
  287 
  288 
  289 **Greetings from a YAML file**
  290 
  291 Hi chris!
  292 Hi mark!
  293 Hi scott!
  294 Hi Éric!
  295 
  296 The template is preprocessed before mustache is called.
  297 
  298 **Greetings from a JSON file**
  299 
  300 Hi chris!
  301 Hi mark!
  302 Hi scott!
  303 Hi Éric!
  304 
  305 The template is preprocessed before mustache is called.
  306 
  307 Comments and quiet definitions
  308 ==============================
  309 
  310 ## Comments
  311 
  312 
  313 
  314 ## Quiet definitions
  315 
  316 
  317 ----------------------------------- -----------------------------------------------------------------
  318 Definitions:                        3.14
  319 ----------------------------------- -----------------------------------------------------------------
  320 
  321 File modification date
  322 ======================
  323 
  324 
  325 ----------------------------------- -----------------------------------------------------------------
  326 Current file date:                  mdate = date of test/pp-test.md
  327 Specific file date:                 Wednesday 23 June 2010
  328 ----------------------------------- -----------------------------------------------------------------
  329 
  330 Environment variables
  331 =====================
  332 
  333 ----------------------------------- -----------------------------------------------------------------
  334 Undefined environment variable:     
  335 Environment variable:               42
  336 ----------------------------------- -----------------------------------------------------------------
  337 
  338 OS architecture
  339 ===============
  340 
  341 ----------------------------------- -----------------------------------------------------------------
  342 OS:                                 linux
  343 Architecture:                       x86_64
  344 ----------------------------------- -----------------------------------------------------------------
  345 
  346 Simple arithmetic
  347 =================
  348 
  349 ----------------------------------- -----------------------------------------------------------------
  350 undefined + 1 =                     1
  351 1 + 1 =                             2
  352 undefined + 3 =                     3
  353 3 + 4 =                             7
  354 ----------------------------------- -----------------------------------------------------------------
  355 
  356 Simple string manipulation
  357 ==========================
  358 
  359 ----------------------------------- -----------------------------------------------------------------
  360 append(undefined, "foo")            foo
  361 append(foo, "bar")                  foobar
  362 ----------------------------------- -----------------------------------------------------------------
  363 
  364 Dialect, Output language and output format
  365 ==========================================
  366 
  367 ## Dialect
  368 
  369 ----------------------------------- -----------------------------------------------------------------
  370 The current dialect is md:          md
  371 All dialects:                       md rst
  372 Section for a markdown document:    Hello World!
  373 Section for a rst document:         
  374 ----------------------------------- -----------------------------------------------------------------
  375 
  376 ## Language
  377 
  378 ----------------------------------- -----------------------------------------------------------------
  379 The current language is "en":       en
  380 All languages:                      en es fr it
  381 Section in english:                 Hello World!
  382 Section in french:                  
  383 ----------------------------------- -----------------------------------------------------------------
  384 
  385 ## Format
  386 
  387 ----------------------------------- -----------------------------------------------------------------
  388 The current format is HTML:         html
  389 All formats:                        epub html mobi odf pdf
  390 Section for an HTML document:       Hello World!
  391 Section for a PDF document:         
  392 ----------------------------------- -----------------------------------------------------------------
  393 
  394 External commands and scripts execution
  395 =======================================
  396 
  397 
  398 
  399 ----------------------------------- ------------------------------------------------------------------------------
  400 Command line (uses sh):             exec(echo "hi é")
  401 `sh` script:                        hi é
  402 `bash` script:                      hi à
  403 `zsh` script:                       hi à
  404 `fish` script:                      not tested
  405 `bat` script:                       not tested
  406 `cmd` script:                       not tested
  407 `python` script:                    hi
  408 `python2` script:                   hi
  409 `python3` script:                   hi
  410 `lua` script:                       hi
  411 `haskell` script:                   hi
  412 `exec` script:                      !def(x)(42)!x
  413 `rawexec` script:                   !def(x)(42)!x
  414 Raw script output:                  !mymacro(42)
  415 Preprocessed script output:         mymacro(42) has been evaluated!
  416 ----------------------------------- ------------------------------------------------------------------------------
  417 
  418 A Haskell Stack script:
  419 
  420 hi
  421 
  422 A R script:
  423 
  424 ```
  425 
  426 Call:
  427 lm(formula = dist ~ speed, data = cars)
  428 
  429 Residuals:
  430     Min      1Q  Median      3Q     Max 
  431 -29.069  -9.525  -2.272   9.215  43.201 
  432 
  433 Coefficients:
  434             Estimate Std. Error t value Pr(>|t|)    
  435 (Intercept) -17.5791     6.7584  -2.601   0.0123 *  
  436 speed         3.9324     0.4155   9.464 1.49e-12 ***
  437 ---
  438 Signif. codes:  0 ‘***’ 0.001 ‘**’ 0.01 ‘*’ 0.05 ‘.’ 0.1 ‘ ’ 1
  439 
  440 Residual standard error: 15.38 on 48 degrees of freedom
  441 Multiple R-squared:  0.6511,	Adjusted R-squared:  0.6438 
  442 F-statistic: 89.57 on 1 and 48 DF,  p-value: 1.49e-12
  443 
  444 ```
  445 
  446 Any other script language can be used, provided the shebang header is interpreted, with `sh`and `exec`:
  447 
  448 Hello from Python
  449 
  450 Hello from Lua
  451 
  452 Diagrams
  453 ========
  454 
  455 The diagram test does not check the generated images, just the links in the output document.
  456 
  457 ![Test of dot](img/dot-test.svg)
  458 ![Test of neato](img/neato-test.svg)
  459 ![Test of twopi](img/twopi-test.svg)
  460 ![Test of circo](img/circo-test.svg)
  461 ![Test of fdp](img/fdp-test.svg)
  462 ![Test of patchwork](img/patchwork-test.svg)
  463 ![Test of osage](img/osage-test.svg)
  464 
  465 ![Test of uml](img/uml-test.svg)
  466 
  467 ![Test of ditaa](img/ditaa-test.svg)
  468 
  469 ![Test of blockdiag](img/blockdiag-test.svg)
  470 
  471 ![Test of seqdiag](img/seqdiag-test.svg)
  472 
  473 ![Test of actdiag](img/actdiag-test.svg)
  474 
  475 ![Test of nwdiag](img/nwdiag-test.svg)
  476 
  477 ![Test of rackdiag](img/rackdiag-test.svg)
  478 
  479 ![Test of packetdiag](img/packetdiag-test.svg)
  480 
  481 ![Test of Asymptote](img/asy-test.svg)
  482 
  483 ![](img/size_small.svg){.img width=50}
  484 
  485 ![Small with title](img/size_smallt.svg){.img width=50}
  486 
  487 ![](img/size_normal.svg){.img width=100}
  488 
  489 ![Normal with title](img/size_normalt.svg){.img width=100}
  490 
  491 ![](img/size_big.svg){.img width=150}
  492 
  493 ![Big with title](img/size_bigt.svg){.img width=150}
  494 
  495 ![Test of R plot](img/rplot-test.svg)
  496 
  497 Literate programming
  498 ====================
  499 
  500 Lets write and test a useful library:
  501 
  502 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ {.c}
  503 // This is a C library
  504 @functionDeclarations
  505 
  506 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  507 
  508 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ {.c}
  509 // This is a C library
  510 @functionImplementations
  511 
  512 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  513 
  514 The `fib` function computes Fibonacci's numbers:
  515 
  516 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ {.C}
  517 int fib(int n);
  518 
  519 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  520 
  521 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ {.C}
  522 int fib(int n)
  523 {
  524     return (n < 2) ? 1 : fib(n-1) + fib(n-2);
  525 }
  526 
  527 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  528 
  529 The `fact` function computes factorial numbers:
  530 
  531 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ {.C}
  532 int fact(int n);
  533 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  534 
  535 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ {.C}
  536 int fact(int n)
  537 {
  538     return (n <= 1) ? 1 : n * fact(n-1);
  539 }
  540 
  541 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  542 
  543 Some tests of `mylib.c`:
  544 
  545 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ {.C}
  546 #include <stdio.h>
  547 #include <stdlib.h>
  548 
  549 #include "mylib.h"
  550 
  551 int main(int argc, char * argv[])
  552 {
  553     int i;
  554     for (i = 1; i < argc; i++)
  555     {
  556         int n = atoi(argv[i]);
  557         printf("fact(%d) = %3d; fib(%d) = %3d\n", n, fact(n), n, fib(n));
  558     }
  559     return 0;
  560 }
  561 
  562 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  563 
  564 
  565 
  566 
  567 
  568 
  569 `mylibtest 0 1 2 3 4 5` outputs:
  570 
  571 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  572 fact(0) =   1; fib(0) =   1
  573 fact(1) =   1; fib(1) =   1
  574 fact(2) =   2; fib(2) =   2
  575 fact(3) =   6; fib(3) =   3
  576 fact(4) =  24; fib(4) =   5
  577 fact(5) = 120; fib(5) =   8
  578 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  579 
  580 The complete source files are:
  581 
  582 `mylib.h`:
  583 
  584 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ {.c}
  585 // This is a C library
  586 @functionDeclarations
  587 
  588 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  589 
  590 
  591 `mylib.c`:
  592 
  593 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ {.c}
  594 // This is a C library
  595 @functionImplementations
  596 
  597 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  598 
  599 
  600 `mylibtest.c`:
  601 
  602 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ {.C}
  603 #include <stdio.h>
  604 #include <stdlib.h>
  605 
  606 #include "mylib.h"
  607 
  608 int main(int argc, char * argv[])
  609 {
  610     int i;
  611     for (i = 1; i < argc; i++)
  612     {
  613         int n = atoi(argv[i]);
  614         printf("fact(%d) = %3d; fib(%d) = %3d\n", n, fact(n), n, fib(n));
  615     }
  616     return 0;
  617 }
  618 
  619 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  620 
  621 
  622 A source file, not necessarily generated with !lit can be
  623 formated with !source or !src:
  624 
  625 `mylib.h`:
  626 
  627 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ {.c}
  628 // This is a C library
  629 int fib(int n);
  630 int fact(int n);
  631 
  632 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  633 
  634 
  635 And with a different codeblock separator:
  636 
  637 15 '~':
  638 
  639 ~~~~~~~~~~~~~~~ {.c}
  640 // This is a C library
  641 int fib(int n);
  642 int fact(int n);
  643 
  644 ~~~~~~~~~~~~~~~
  645 
  646 
  647 20 '`':
  648 
  649 ```````````````````` {.c}
  650 // This is a C library
  651 int fib(int n);
  652 int fact(int n);
  653 
  654 ````````````````````
  655 
  656 
  657 25 '~' (default character):
  658 
  659 ~~~~~~~~~~~~~~~~~~~~~~~~~ {.c}
  660 // This is a C library
  661 int fib(int n);
  662 int fact(int n);
  663 
  664 ~~~~~~~~~~~~~~~~~~~~~~~~~
  665 
  666 
  667 CSV tables
  668 ==========
  669 
  670 This file with a header:
  671 
  672 ~~~~~~~~~~~~~~~~~~~~~~~~~
  673 Year,Make,Model,Description,Price
  674 1997,Ford,E350,"ac, abs, moon",3000.00
  675 1999,Chevy,"Venture ""Extended Edition""","",4900.00
  676 1999,Chevy,"Venture ""Extended Edition, Very Large""",,5000.00
  677 1996,Jeep,Grand Cherokee,"MUST SELL!
  678 air, moon roof, loaded",4799.00
  679 
  680 ~~~~~~~~~~~~~~~~~~~~~~~~~
  681 
  682 
  683 is rendered by `!csv(file.csv)` as:
  684 
  685 | Year | Make  | Model                                  | Description                       |   Price |
  686 |-----:|:------|:---------------------------------------|:----------------------------------|--------:|
  687 | 1997 | Ford  | E350                                   | ac, abs, moon                     | 3000.00 |
  688 | 1999 | Chevy | Venture "Extended Edition"             |                                   | 4900.00 |
  689 | 1999 | Chevy | Venture "Extended Edition, Very Large" |                                   | 5000.00 |
  690 | 1996 | Jeep  | Grand Cherokee                         | MUST SELL! air, moon roof, loaded | 4799.00 |
  691 
  692 
  693 This file without any header:
  694 
  695 ~~~~~~~~~~~~~~~~~~~~~~~~~
  696 1997,Ford,E350,"ac, abs, moon",3000.00
  697 1999,Chevy,"Venture ""Extended Edition""","",4900.00
  698 1999,Chevy,"Venture ""Extended Edition, Very Large""",,5000.00
  699 1996,Jeep,Grand Cherokee,"MUST SELL!
  700 air, moon roof, loaded",4799.00
  701 
  702 ~~~~~~~~~~~~~~~~~~~~~~~~~
  703 
  704 
  705 is rendered by `!csv(file.csv)(Year|Make|Model|Description|Price)` as:
  706 
  707 | Year | Make  | Model                                  | Description                       |   Price |
  708 |-----:|:------|:---------------------------------------|:----------------------------------|--------:|
  709 | 1997 | Ford  | E350                                   | ac, abs, moon                     | 3000.00 |
  710 | 1999 | Chevy | Venture "Extended Edition"             |                                   | 4900.00 |
  711 | 1999 | Chevy | Venture "Extended Edition, Very Large" |                                   | 5000.00 |
  712 | 1996 | Jeep  | Grand Cherokee                         | MUST SELL! air, moon roof, loaded | 4799.00 |
  713 
  714 
  715 Parser customization
  716 ====================
  717 
  718 
  719 
  720 
  721 ## Macro calls
  722 
  723 Test the default behaviour:
  724 
  725 Inactive: `+` => +foo
  726 Inactive: `=` => =foo
  727 Inactive: `\` => \foo
  728 Active  : `!` => foo has been called
  729 
  730 Set new macro chars: `+=` 
  731 
  732 Active  : `+` => foo has been called
  733 Active  : `=` => foo has been called
  734 Inactive: `\` => \foo
  735 Inactive: `!` => !foo
  736 
  737 Restore the default behaviour: `!` 
  738 
  739 Inactive: `+` => +foo
  740 Inactive: `=` => =foo
  741 Inactive: `\` => \foo
  742 Active  : `!` => foo has been called
  743 
  744 ## Macro args
  745 
  746 Test the default behaviour:
  747 
  748 Active  : `()` => bar:arg1="42" - text after macro call:
  749 Active  : `{}` => bar:arg1="42" - text after macro call:
  750 Active  : `[]` => bar:arg1="42" - text after macro call:
  751 Inactive: `<>` => bar:arg1="" - text after macro call:<42>
  752 Inactive: `«»` => bar:arg1="" - text after macro call:«42»
  753 
  754 Set new parameter separators: `<>«»` 
  755 
  756 Inactive: `()` => bar:arg1="" - text after macro call:(42)
  757 Inactive: `{}` => bar:arg1="" - text after macro call:{42}
  758 Inactive: `[]` => bar:arg1="" - text after macro call:[42]
  759 Active  : `<>` => bar:arg1="42" - text after macro call:
  760 Active  : `«»` => bar:arg1="42" - text after macro call:
  761 
  762 Restore the default behaviour: `(){}[]` 
  763 
  764 Active  : `()` => bar:arg1="42" - text after macro call:
  765 Active  : `{}` => bar:arg1="42" - text after macro call:
  766 Active  : `[]` => bar:arg1="42" - text after macro call:
  767 Inactive: `<>` => bar:arg1="" - text after macro call:<42>
  768 Inactive: `«»` => bar:arg1="" - text after macro call:«42»
  769 
  770 Change the macro block args: 
  771 
  772 foo has been called
  773 `````````
  774 This is not an argument here!
  775 `````````
  776 
  777 foo has been called
  778 
  779 foo has been called
  780 
  781 Restore the default behaviour: 
  782 
  783 foo has been called
  784 +++++++++
  785 This is not an argument here!
  786 +++++++++
  787 
  788 foo has been called
  789 
  790 foo has been called
  791 
  792 ## Literate macros
  793 
  794 Set new literate macro chars: `$` 
  795 
  796 ~~~~~~~~~~~~~~~~~~~~~~~~~
  797 $foo - $foo
  798 ~~~~~~~~~~~~~~~~~~~~~~~~~
  799 
  800 ~~~~~~~~~~~~~~~~~~~~~~~~~
  801 I'm foo
  802 ~~~~~~~~~~~~~~~~~~~~~~~~~
  803 
  804 
  805 Result: 
  806 
  807 ```
  808 I'm foo - I'm foo
  809 ```
  810 
  811 Restore the default behaviour: `@` 
  812 
  813 Builtin macro documentation
  814 ===========================
  815 
  816 ## macros
  817 
  818 define
  819 def
  820 undefine
  821 undef
  822 defined
  823 rawdef
  824 ifdef
  825 ifndef
  826 ifeq
  827 ifne
  828 if
  829 eval
  830 info
  831 warning
  832 warn
  833 error
  834 exit
  835 import
  836 include
  837 inc
  838 raw
  839 rawinclude
  840 rawinc
  841 comment
  842 quiet
  843 pp
  844 mustache
  845 mdate
  846 main
  847 file
  848 root
  849 cwd
  850 lang
  851 langs
  852 en
  853 fr
  854 it
  855 es
  856 format
  857 formats
  858 html
  859 pdf
  860 odf
  861 epub
  862 mobi
  863 dialect
  864 dialects
  865 md
  866 rst
  867 env
  868 os
  869 arch
  870 add
  871 append
  872 exec
  873 rawexec
  874 sh
  875 bash
  876 zsh
  877 fish
  878 cmd
  879 bat
  880 python
  881 python2
  882 python3
  883 lua
  884 haskell
  885 stack
  886 Rscript
  887 powershell
  888 dot
  889 neato
  890 twopi
  891 circo
  892 fdp
  893 sfdp
  894 patchwork
  895 osage
  896 uml
  897 ditaa
  898 blockdiag
  899 seqdiag
  900 actdiag
  901 nwdiag
  902 rackdiag
  903 packetdiag
  904 asy
  905 Rplot
  906 literate
  907 lit
  908 flushliterate
  909 flushlit
  910 source
  911 src
  912 codeblock
  913 indent
  914 csv
  915 macrochars
  916 macroargs
  917 macroblockargs
  918 literatemacrochars
  919 macros
  920 usermacros
  921 help
  922 userhelp
  923 
  924 
  925 ## help
  926 
  927 **`define`**, **`def`**
  928 :   `!def[ine](SYMBOL)[[(DOC)](VALUE)]` adds the symbol `SYMBOL` to
  929     the current environment and associate it with the optional value
  930     `VALUE`. Arguments are denoted by `!1` ... `!n` in `VALUE`. If
  931     `DOC` is given it is used to document the macro (see the `-help`
  932     option).
  933 
  934 **`undefine`**, **`undef`**
  935 :   `!undef[ine](SYMBOL)` removes the symbol `SYMBOL` from the current
  936     environment.
  937 
  938 **`defined`**
  939 :   `!defined(SYMBOL)` returns 1 if `SYMBOL` is defined, 0 otherwise.
  940 
  941 **`rawdef`**
  942 :   `!rawdef(X)` returns the raw (unevaluated) definition of `X`.
  943 
  944 **`ifdef`**
  945 :   `!ifdef(SYMBOL)(TEXT_IF_DEFINED)[(TEXT_IF_NOT_DEFINED)]` returns
  946     `TEXT_IF_DEFINED` if `SYMBOL` is defined or `TEXT_IF_NOT_DEFINED`
  947     if it is not defined.
  948 
  949 **`ifndef`**
  950 :   `!ifndef(SYMBOL)(TEXT_IF_NOT_DEFINED)[(TEXT_IF_DEFINED)]` returns
  951     `TEXT_IF_NOT_DEFINED` if `SYMBOL` is not defined or `TEXT_IF_DEFINED`
  952     if it is defined.
  953 
  954 **`ifeq`**
  955 :   `!ifeq(X)(Y)(TEXT_IF_EQUAL)[(TEXT_IF_DIFFERENT)]` returns `TEXT_IF_EQUAL`
  956     if `X` and `Y` are equal or `TEXT_IF_DIFFERENT` if `X` and `Y`
  957     are different. Two pieces of text are equal if all non-space characters
  958     are the same.
  959 
  960 **`ifne`**
  961 :   `!ifne(X)(Y)(TEXT_IF_DIFFERENT)[(TEXT_IF_EQUAL)]` returns `TEXT_IF_DIFFERENT`
  962     if `X` and `Y` are different or `TEXT_IF_EQUAL` if `X` and `Y`
  963     are equal.
  964 
  965 **`if`**
  966 :   `!if(EXPR)(TEXT_IF_EXPR_IS_TRUE)[(TEXT_IF_EXPR_IS_FALSE)]` returns
  967     `TEXT_IF_EXPR_IS_TRUE` if `EXPR` is true or `TEXT_IF_EXPR_IS_FALSE`
  968     if `EXPR` is false.
  969 
  970 **`eval`**
  971 :   `!eval(EXPR) evaluates `EXPR`.
  972 
  973 **`info`**
  974 :   `!info(MESSAGE) prints `MESSAGE` on stderr.
  975 
  976 **`warning`**, **`warn`**
  977 :   `!warn[ing](MESSAGE) prints `MESSAGE` on stderr.
  978 
  979 **`error`**
  980 :   `!error[(CODE)](MESSAGE) prints `MESSAGE` on stderr and exits
  981     with error code `CODE`.
  982 
  983 **`exit`**
  984 :   `!exit(CODE) exits with error code `CODE`.
  985 
  986 **`import`**
  987 :   `!import(FILENAME)` works as `!include(FILENAME)` but returns
  988     nothing. This is useful to import macro definitions.
  989 
  990 **`include`**, **`inc`**
  991 :   `!inc[lude](FILENAME)` preprocesses and returns the content of
  992     the file named `FILENAME` and includes it in the current document.
  993     If the file path is relative it is searched first in the directory
  994     of the current file then in the directory of the main file.
  995 
  996 **`raw`**
  997 :   `!raw(TEXT)` returns `TEXT` without any preprocessing.
  998 
  999 **`rawinclude`**, **`rawinc`**
 1000 :   `!rawinc[lude](FILE)` returns the content of `FILE` without any
 1001     preprocessing.
 1002 
 1003 **`comment`**
 1004 :   `!comment(TEXT)` considers `TEXT` as well as any additional parameters
 1005     as comment. Nothing is preprocessed or returned.
 1006 
 1007 **`quiet`**
 1008 :   `!quiet(TEXT)` quietly preprocesses `TEXT` and returns nothing.
 1009     Only the side effects (e.g. macro definitions) are kept in the
 1010     environment.
 1011 
 1012 **`pp`**
 1013 :   `!pp(TEXT)` preprocesses and return `TEXT`. This macro is useful
 1014     to preprocess the output of script macros for instance (`!sh`,
 1015     `!python`, ...).
 1016 
 1017 **`mustache`**
 1018 :   `!mustache(JSON/YAML file)(TEMPLATE)` preprocesses `TEMPLATE`
 1019     with mustache, using a `JSON/YAML file`.
 1020 
 1021 **`mdate`**
 1022 :   `!mdate(FILES)` returns the modification date of the most recent
 1023     file.
 1024 
 1025 **`main`**
 1026 :   `!main` returns the name of the main file (given on the command
 1027     line).
 1028 
 1029 **`file`**
 1030 :   `!file` returns the name of the current file.
 1031 
 1032 **`root`**
 1033 :   `!root` returns the directory name of the main file.
 1034 
 1035 **`cwd`**
 1036 :   `!cwd` returns the directory name of the current file.
 1037 
 1038 **`lang`**
 1039 :   `!lang` returns the current language.
 1040 
 1041 **`langs`**
 1042 :   `!langs` lists the known languages (en, fr, it, es).
 1043 
 1044 **`en`**
 1045 :   `!en(TEXT)` returns `TEXT` if the current language is `en`.
 1046 
 1047 **`fr`**
 1048 :   `!fr(TEXT)` returns `TEXT` if the current language is `fr`.
 1049 
 1050 **`it`**
 1051 :   `!it(TEXT)` returns `TEXT` if the current language is `it`.
 1052 
 1053 **`es`**
 1054 :   `!es(TEXT)` returns `TEXT` if the current language is `es`.
 1055 
 1056 **`format`**
 1057 :   `!format` returns the current output format.
 1058 
 1059 **`formats`**
 1060 :   `!formats` lists the known formats (html, pdf, odf, epub, mobi).
 1061 
 1062 **`html`**
 1063 :   `!html(TEXT)` returns `TEXT` if the current format is `html`.
 1064 
 1065 **`pdf`**
 1066 :   `!pdf(TEXT)` returns `TEXT` if the current format is `pdf`.
 1067 
 1068 **`odf`**
 1069 :   `!odf(TEXT)` returns `TEXT` if the current format is `odf`.
 1070 
 1071 **`epub`**
 1072 :   `!epub(TEXT)` returns `TEXT` if the current format is `epub`.
 1073 
 1074 **`mobi`**
 1075 :   `!mobi(TEXT)` returns `TEXT` if the current format is `mobi`.
 1076 
 1077 **`dialect`**
 1078 :   `!dialect` returns the current output dialect.
 1079 
 1080 **`dialects`**
 1081 :   `!dialects` lists the kown output dialects (md, rst).
 1082 
 1083 **`md`**
 1084 :   `!md(TEXT)` returns `TEXT` if the current dialect is `md`.
 1085 
 1086 **`rst`**
 1087 :   `!rst(TEXT)` returns `TEXT` if the current dialect is `rst`.
 1088 
 1089 **`env`**
 1090 :   `!env(VARNAME)` preprocesses and returns the value of the process
 1091     environment variable `VARNAME`.
 1092 
 1093 **`os`**
 1094 :   `!os` returns the OS name (e.g. `linux` on Linux, `darwin` on
 1095     MacOS, `windows` on Windows).
 1096 
 1097 **`arch`**
 1098 :   `!arch` returns the machine architecture (e.g. `x86_64`, `i386`,
 1099     ...).
 1100 
 1101 **`add`**
 1102 :   `!add(VARNAME)[(INCREMENT)]` computes `VARNAME+INCREMENT` and
 1103     stores the result to `VARNAME`. The default value of the increment
 1104     is 1.
 1105 
 1106 **`append`**
 1107 :   `!append(VARNAME)[(TEXT)]` appends `TEXT` to `!VARNAME` and stores
 1108     the result to `VARNAME`.
 1109 
 1110 **`exec`**
 1111 :   `!exec(COMMAND)` executes a shell command with the default shell
 1112     (`sh` or `cmd` according to the OS).
 1113 
 1114 **`rawexec`**
 1115 :   `!rawexec` is *deprecated*. See exec.
 1116 
 1117 **`sh`**
 1118 :   `!sh(CMD)` executes `CMD` in a `sh` shell.
 1119 
 1120 **`bash`**
 1121 :   `!bash(CMD)` executes `CMD` in a `bash` shell.
 1122 
 1123 **`zsh`**
 1124 :   `!zsh(CMD)` executes `CMD` in a `zsh` shell.
 1125 
 1126 **`fish`**
 1127 :   `!fish(CMD)` executes `CMD` in a `fish` shell.
 1128 
 1129 **`cmd`**
 1130 :   `!cmd(CMD)` executes `CMD` in a Windows shell (cmd.exe).
 1131 
 1132 **`bat`**
 1133 :   `!bat` is *deprecated*. See cmd.
 1134 
 1135 **`python`**
 1136 :   `!python(CMD)` executes `CMD` with the default Python interpretor.
 1137 
 1138 **`python2`**
 1139 :   `!python2(CMD)` executes `CMD` with Python 2.
 1140 
 1141 **`python3`**
 1142 :   `!python3(CMD)` executes `CMD` with Python 3.
 1143 
 1144 **`lua`**
 1145 :   `!lua(CMD)` executes `CMD` with Lua.
 1146 
 1147 **`haskell`**
 1148 :   `!haskell(CMD)` executes `CMD` as a Haskell script with `runhaskell`.
 1149 
 1150 **`stack`**
 1151 :   `!stack(CMD)` executes `CMD` as a Haskell script with `stack`.
 1152 
 1153 **`Rscript`**
 1154 :   `!Rscript(CMD)` executes `CMD` as a R script with Rscript.
 1155 
 1156 **`powershell`**
 1157 :   `!cmd(CMD)` executes `CMD` in a Windows shell (Powershell).
 1158 
 1159 **`dot`**
 1160 :   `!dot(IMAGE)[(LEGEND)](GRAPH DESCRIPTION)` renders a dot image
 1161     with Graphviz.
 1162 
 1163 **`neato`**
 1164 :   `!neato(IMAGE)[(LEGEND)](GRAPH DESCRIPTION)` renders a neato image
 1165     with Graphviz.
 1166 
 1167 **`twopi`**
 1168 :   `!twopi(IMAGE)[(LEGEND)](GRAPH DESCRIPTION)` renders a twopi image
 1169     with Graphviz.
 1170 
 1171 **`circo`**
 1172 :   `!circo(IMAGE)[(LEGEND)](GRAPH DESCRIPTION)` renders a circo image
 1173     with Graphviz.
 1174 
 1175 **`fdp`**
 1176 :   `!fdp(IMAGE)[(LEGEND)](GRAPH DESCRIPTION)` renders a fdp image
 1177     with Graphviz.
 1178 
 1179 **`sfdp`**
 1180 :   `!sfdp(IMAGE)[(LEGEND)](GRAPH DESCRIPTION)` renders a sfdp image
 1181     with Graphviz.
 1182 
 1183 **`patchwork`**
 1184 :   `!patchwork(IMAGE)[(LEGEND)](GRAPH DESCRIPTION)` renders a patchwork
 1185     image with Graphviz.
 1186 
 1187 **`osage`**
 1188 :   `!osage(IMAGE)[(LEGEND)](GRAPH DESCRIPTION)` renders a osage image
 1189     with Graphviz.
 1190 
 1191 **`uml`**
 1192 :   `!uml(IMAGE)[(LEGEND)](GRAPH DESCRIPTION)` renders a uml image
 1193     with PlantUML.
 1194 
 1195 **`ditaa`**
 1196 :   `!ditaa(IMAGE)[(LEGEND)](GRAPH DESCRIPTION)` renders a ditaa image
 1197     with Ditaa.
 1198 
 1199 **`blockdiag`**
 1200 :   `!blockdiag(IMAGE)[(LEGEND)](GRAPH DESCRIPTION)` renders a blockdiag
 1201     image with BlockDiag.
 1202 
 1203 **`seqdiag`**
 1204 :   `!seqdiag(IMAGE)[(LEGEND)](GRAPH DESCRIPTION)` renders a seqdiag
 1205     image with BlockDiag.
 1206 
 1207 **`actdiag`**
 1208 :   `!actdiag(IMAGE)[(LEGEND)](GRAPH DESCRIPTION)` renders a actdiag
 1209     image with BlockDiag.
 1210 
 1211 **`nwdiag`**
 1212 :   `!nwdiag(IMAGE)[(LEGEND)](GRAPH DESCRIPTION)` renders a nwdiag
 1213     image with BlockDiag.
 1214 
 1215 **`rackdiag`**
 1216 :   `!rackdiag(IMAGE)[(LEGEND)](GRAPH DESCRIPTION)` renders a rackdiag
 1217     image with BlockDiag.
 1218 
 1219 **`packetdiag`**
 1220 :   `!packetdiag(IMAGE)[(LEGEND)](GRAPH DESCRIPTION)` renders a packetdiag
 1221     image with BlockDiag.
 1222 
 1223 **`asy`**
 1224 :   `!asy(IMAGE)[(LEGEND)](GRAPH DESCRIPTION)` renders a asy image
 1225     with Asymptote.
 1226 
 1227 **`Rplot`**
 1228 :   `!Rplot(IMAGE)[(LEGEND)](GRAPH DESCRIPTION)` renders a Rplot image
 1229     with R.
 1230 
 1231 **`literate`**, **`lit`**
 1232 :   `!lit[erate](FILENAME)[(LANG)][(CONTENT)]` appends `CONTENT` to
 1233     the file `FILENAME`. If `FILENAME` starts with `@` it's a macro,
 1234     not a file. The output is highlighted using the programming language
 1235     `LANGUAGE`. The list of possible languages is given by `pandoc --list-highlight-languages`.
 1236     Files are actually written when all the documents have been successfully
 1237     preprocessed. Macros are expanded when the files are written.
 1238     This macro provides basic literate programming features. If `LANG`
 1239     is not given, pp uses the previously defined language for the
 1240     same file or macro or a default language according to its name.
 1241     If `CONTENT`is not given, pp returns the current content of `FILENAME`.
 1242 
 1243 **`flushliterate`**, **`flushlit`**
 1244 :   `!flushlit[erate]` writes files built with `!lit` before reaching
 1245     the end of the document. This macro is automatically executed
 1246     before any script execution or file inclusion with `!src`.
 1247 
 1248 **`source`**, **`src`**
 1249 :   `!source(FILENAME)[(LANG)]` or `!src(FILENAME)[(LANG)]` formats
 1250     an existing source file in a colorized code block.
 1251 
 1252 **`codeblock`**
 1253 :   `!codeblock(LENGTH)[(CHAR)]` sets the default line separator for
 1254     code blocks. The default value is a 70 tilda row (`!codeclock(70)(~)`).
 1255 
 1256 **`indent`**
 1257 :   `!indent[(N)](BLOCK)` indents each line of a block with `N` spaces.
 1258     The default value of `N` is 4 spaces.
 1259 
 1260 **`csv`**
 1261 :   `!csv(FILENAME)[(HEADER)]` converts a CSV file to a Markdown or
 1262     reStructuredText table. `HEADER` defines the header of the table,
 1263     fields are separated by pipes (`|`). If `HEADER` is not defined,
 1264     the first line of the file is used as the header of the table.
 1265 
 1266 **`macrochars`**
 1267 :   `!macrochars(CHARS)` defines the chars used to call a macro. The
 1268     default value is `"!"`. Any non space character can start a macro
 1269     call (e.g. after `!macrochars(!\)` both `!foo` and `\foo` are
 1270     valid macro calls.
 1271 
 1272 **`macroargs`**
 1273 :   `!macroargs(CHARS)` defines the chars used to separate macro arguments.
 1274     The default value is `"(){}[]"` (e.g. after `!macroargs(()«»)`
 1275     both `!foo(...)` and `!foo«...»` are valid macro calls).
 1276 
 1277 **`macroblockargs`**
 1278 :   `!macroblockargs(CHARS)` defines the chars used to separate macro
 1279     block arguments. The default value is ``"~`"``.
 1280 
 1281 **`literatemacrochars`**
 1282 :   `!literatemacrochars(CHARS)` defines the chars used to identify
 1283     literate programming macros. The default value is `"@"`. Any non
 1284     space character can start a literate programming macro (e.g. after
 1285     `!literatemacrochars(@&)` both `@foo` and `&foo` are valid macro
 1286     calls.
 1287 
 1288 **`macros`**
 1289 :   `!macros` lists the builtin macros.
 1290 
 1291 **`usermacros`**
 1292 :   `!usermacros` lists the user macros.
 1293 
 1294 **`help`**
 1295 :   `!help` prints built-in macro help.
 1296 
 1297 **`userhelp`**
 1298 :   `!userhelp` prints user macro help.
 1299 
 1300 
 1301 
 1302 User macro documentation
 1303 ========================
 1304 
 1305 
 1306 
 1307 
 1308 
 1309 
 1310 RESOLVER
 1311 imported_macro
 1312 swap
 1313 A
 1314 B
 1315 C
 1316 f
 1317 g
 1318 one
 1319 un
 1320 two
 1321 answer
 1322 note
 1323 pi
 1324 x
 1325 y
 1326 accu
 1327 mymacro
 1328 test
 1329 result
 1330 foo
 1331 useless
 1332 bar
 1333 
 1334 
 1335 **`bar`**
 1336 :   bar's docstring
 1337 
 1338 **`foo`**
 1339 :   foo's docstring
 1340 
 1341