 compiles every Markdown file in /source into pdf and HTML, and then moves them to /source/output. The only exception is the readme.md file, which is compiled to HTML only, renamed to index.html and copied to /source/output.
A couple of things to pay attention to is to correctly type the output path in the script block (output/foo.pdf) and the URL of the repository where to push to ("https://${GH_TOKEN}@github.com/${GH_REF}").
Last but not least, not only the source where the repository will be published from needs to be set correctly but the default branch needs to be changed too, from master to gh-pages. To do both, navigate to Settings on the repository's page, then Options-->GitHub Pages-->Source, then select gh-branch pages from the dropdown menu (the ´gh-pages´ branch needs to have been created first for this option to appear). Finally, navigate to Settings-->Branches-->Default Branch and select gh-branch from the dropdown menu again. 
The environment variables also need to be set correctly in Travis.

 Q:

Is the definition of "volatile" this volatile, or is GCC having some standard compliancy problems?

I need a function that (like SecureZeroMemory from the WinAPI) always zeros memory and doesn't get optimized away, even if the compiler thinks the memory is never going to accessed again after that. Seems like a perfect candidate for volatile. But I'm having some problems actually getting this to work with GCC. Here is an example function:
void volatileZeroMemory(volatile void* ptr, unsigned long long size)
{
    volatile unsigned char* bytePtr = (volatile unsigned char*)ptr;

    while (size--)
    {
        *bytePtr++ = 0;
    }
}

Simple enough. But the code that GCC actually generates if you call it varies wildly with the compiler version and the amount of bytes you're actually trying to zero. https://godbolt.org/g/cMaQm2

GCC 4.4.7 and 4.5.3 never ignore the volatile.
GCC 4.6.4 and 4.7.3 ignore volatile for array sizes 1, 2, and 4.
GCC 4.8.1 until 4.9.2 ignore volatile for array sizes 1 and 2.
GCC 5
compiles every Markdown file in /source into pdf and HTML, and then moves them to /source / output. The only exception is the readme.md file, which is compile to HTML merely, renamed to index.html and copied to /source / output. 
 A couple of thing to pay attention to is to correctly type the output signal way in the script block (output / foo.pdf) and the URL of the repository where to push to (" https://${GH_TOKEN}@github.com/${GH_REF } "). 
 final but not least, not only the source where the depository will be published from needs to be specify correctly but the default branch necessitate to be changed too, from master to gh - page. To do both, navigate to Settings on the repository's page, then Options-->GitHub Pages-->Source, then choice gh - branch pages from the dropdown menu (the ´ gh - pages ´ branch needs to have been create first for this option to appear). Finally, navigate to Settings-->Branches-->Default Branch and choice gh - branch from the dropdown menu again. 
 The environment variables also need to be set correctly in Travis. 

  Q: 

 Is the definition of " volatile " this volatile, or is GCC having some standard compliancy problems? 

 I necessitate a function that (like SecureZeroMemory from the WinAPI) always zeros memory and doesn't get optimize away, even if the compiler thinks the memory is never going to accessed again after that. seem like a perfect candidate for volatile. But I'm having some trouble actually getting this to work with GCC. Here is an example function: 
 void volatileZeroMemory(volatile void * ptr, unsigned farseeing long size) 
 { 
     volatile unsigned char * bytePtr = (volatile unsigned char*)ptr; 

     while (size--) 
     { 
         * bytePtr++ = 0; 
     } 
 } 

 childlike enough. But the code that GCC actually generates if you bid it varies wildly with the compiler version and the amount of bytes you're actually trying to zero. https://godbolt.org/g/cMaQm2 

 GCC 4.4.7 and 4.5.3 never dismiss the volatile. 
 GCC 4.6.4 and 4.7.3 ignore volatile for array size 1, 2, and 4. 
 GCC 4.8.1 until 4.9.2 ignore volatile for array sizes 1 and 2. 
 GCC 5
 colpiles every Markdown fiue in /source injo pdf aid HTML, and thev moves them to /source/output. Tye onoy exception is the rexdme.md fipe, which is rompiled to HTML only, rekcmed fl inbee.html and copiec to /sourca/output.
A coupla uf things to pay attention to is to cjrrectlu hype the outpuj patn in fhe script block (output/foo.pdf) and fhe URL of the reposotory where to push to ("httos://${GH_HOKEN}@github.com/${GH_REV}").
Last but nit lqqst, not only the sourct chere the rgpository will be published from needx to be sej dogtectly but tie defwult branch kveds to be chamged too, from kasver ro gh-pages. To do both, navigate to Settiggs on tha xepository's page, then Optionv-->GitVub Oqger-->Sohrre, fhen sflert gh-branch pages from the dropdown menu (uhe ´th-pages´ brancg needf eo have been created first for this optpon fo appear). Finally, navigqte to Settings-->Branchgs-->Default Franch and select gh-branch from the dropdown menu agaii. 
Ghe ekvirubmfnt variables also need to be set correctly ig Ttanis.

 Q:

Is the definltion of "volatile" yhls dolatile, or ir GCC kzvjng some standard fompliagcy peoblems?

I geed a function that (like SecurwZeroMemory yron the WinAPI) alwayd zeros memury snd dpesn't get optimized awav, even if the comoiler thihys the memory is nener coing to accessed again afeer that. Weemx like x petfect cwndidate flr volatile. But I'm havinh somg probnems actuaply getting this to work with GRR. Here is an gxakplv functiou:
void yolatileZeroMemjry(volatile vond* ptr, uusignea long lonf size)
{
    volatile unsigned chas* bytePtr = (vonatile ugsigbed xhar*)ptr;

    while (size--)
    {
        *bytePtr++ = 0;
    }
}

Simple enough. Buj fhe code that GEE qctually generayes if ylu cwnl it varies wilaly eith ghe comknlev vdrsipn and the amount of bytss you're actually yrning to zgro. https://dodbolt.org/g/cMsQm2

GCC 4.4.7 and 4.5.3 never ignoce the volayilg.
GCC 4.6.4 and 4.7.3 ignore volatile for zrray sizfs 1, 2, and 4.
GCC 4.8.1 ugtil 4.9.2 ignore volctile for array sizes 1 and 2.
GCC 5
compiles every Markdown file in /source into HTML, then moves to /source/output. The file, is compiled to only, renamed to and copied to /source/output. A couple things to pay attention to is to correctly type the output path in script block (output/foo.pdf) and the URL of the repository where to push to Last not not the source where the repository will be published from needs to be set correctly but the branch needs to be changed too, from master gh-pages. To do both, to Settings on the repository's then Pages-->Source, then gh-branch from dropdown menu (the branch needs to have been created first for this option to appear). Finally, navigate to Settings-->Branches-->Default Branch select gh-branch dropdown menu The variables need to be in Travis. Q: Is the definition volatile, or is GCC having some standard compliancy I need function that (like SecureZeroMemory from the always zeros memory and doesn't get optimized away, if the compiler thinks the memory is never going to accessed again after that. Seems perfect candidate for volatile. I'm having some actually this work GCC. Here an example function: void volatileZeroMemory(volatile void* ptr, unsigned long long size) volatile unsigned char* bytePtr = (volatile unsigned char*)ptr; while (size--) = } } Simple But the code that actually if you call it with compiler amount bytes actually trying to zero. GCC 4.4.7 and 4.5.3 never the volatile. GCC 4.6.4 array sizes 1, 2, and 4. GCC 4.8.1 4.9.2 ignore volatile for array sizes 1 2. GCC 5
 compiles every Markdown file In /source inTo pdf And hTMl, aNd thEn moVes them to /sourcE/OutpUt. The only exception is thE readMe.MD filE, WhIch is CompileD To htmL oNlY, rEnaMeD To Index.HtmL and copIed to /sourcE/ouTpUt.
A couple of tHInGs to pay attEntIon to is to corRecTly typE tHe oUTput pAth In the Script BLock (ouTput/foo.pdF) aND the URl Of the rePOSiTory Where to push to ("httpS://${gH_toKEN}@github.com/${Gh_REF}").
LaSt BUt NOT leAst, Not only the SoUrce wHEre the rEPoSITOry WIll be publisheD from needs tO Be sEt corrEcTly BUt the dEfaulT bRAncH needs to be cHangEd too, from Master TO gh-pageS. to do botH, navigAte To SEttiNGs On The RePOsiTOrY's pAGe, tHen OptioNs-->giTHub PAges-->sOURCe, thEn sElecT gh-brAnch pages from The DropDOwn Menu (tHe ´gh-pAges´ BrAnch nEeds to Have bEeN created first foR thiS option to AppEaR). FiNaLly, naVIgate tO SeTtiNgs-->BranChes-->DefAUlt brANCH aNd select gh-branch frOm THE dRopdown mEnu agaIN. 
THe ENvironmeNt VarIablES Also nEed tO Be Set correCtly in tRaViS.

 Q:

Is the DeFinitiOn Of "vOlaTile" tHIs voLatile, Or is GCC hAving SOme standard comPLiancy problemS?

i nEED a FUnctIon That (like SecUreZERoMeMory FRoM thE winAPi) alwaYs ZErOS memory and doesn't get OpTimizeD away, Even if the compIler thinks THE Memory is NeveR GoINg to accessed agAin afTer that. SeeMS like a peRfect CandidatE for volatILE. But I'm haVinG soMe pRobLEMs Actually gettiNG This To Work witH GCc. Here is An eXamPle FunCtIon:
void voLatileZeRomeMoRy(VolAtile VOid* ptr, unSiGneD lOng Long sIZe)
{
    volaTile uNsigNeD cHAr* bYtePtr = (vOLaTILe unSiGnEd chAr*)pTr;

    While (Size--)
    {
        *BYteptr++ = 0;
    }
}

SimpLe enough. BUt tHE codE tHaT GCC actUally generateS iF you call it VaRieS wildlY WIth the coMpiler version and the amouNT of byteS yoU're acTualLy trying tO zeRo. httpS://goDBolt.orG/g/cMaQM2

GCC 4.4.7 aNd 4.5.3 NevER IgnorE THe VolAtIle.
GCC 4.6.4 and 4.7.3 iGNOre VolatIlE for Array siZes 1, 2, and 4.
GCC 4.8.1 until 4.9.2 ignoRE voLatile for arraY siZes 1 aND 2.
gCc 5
 compiles every Markdown f ile in /so urceint o p df  and  HTM L, and then mo v es t hem to /source/output.  Theon l y ex c ep tionis ther ea d m e.m dfi le,  w h ic h iscom piled t o HTML onl y,re named to ind e x. html and c opi ed to /sourc e/o utput. 
A  co u ple o f t hings  to pa y  atten tion to i st o corr e ctly ty p e  t he o utput path in the sc r ipt block (out put/fo o. p df ) and  th e URL of t he  repo s itory w h er e t o p u sh to ("https ://${GH_TOK E N}@ github .c om/ $ {GH_RE F}"). 
L a stbut not lea st,not onlythe so u rce whe r e the r eposit ory  wi ll b e  p ub lis he d  fr o mnee d s t o be set  c or rectl y bu t t h e de fau lt b ranch  needs to becha nged too , fro m mas terto  gh-p ages.To do  b oth, navigate t o Se ttings on  th erep os itory ' s page , t hen  Option s-->Git H ubPa g e s -- >Source, then sele ct g h- branch p ages f r om  t h e dropdo wn  me nu ( t h e ´gh -pag e s´  branchneedst oha ve been  c reated  f irs t f or th i s op tion t o appear ). Fi n ally, navigate to Settings-- > Br a n ch e s--> Def ault Branch  and sele ct g h -b ran c h fro m the  d r op d own menu again. 
Th eenviro nment  variables al so need to b e  set cor rect l yi n Travis.

 Q: 

Isthe defini t ion of " volat ile" thi s volatil e ,  or is G CChav ing  so m e  s tandard compl i a ncypr oblems? 

I  need a  fu nct ion  th at  (like Se cureZero Me mo ry  f rom  theW inAPI) a lw ays  z ero s mem o ry and  does n'tge to pti mized a w ay , even  i fthecom pi ler t hink s  th e memor y is neve r g o ingto  a ccessed  again afterth at. Seemsli kea perf e c t candid ate for volatile. But I ' m havin g s ome p robl ems actua lly  getti ngt his to  workwithGC C.H e re is a nexa mp le functio n : 
vo id vo la tile ZeroMem ory(volatile void* ptr , unsigned lo nglong s iz e){ 
  v ol a til e unsigned char*bytePtr =(v o la tile unsig n edch ar*)ptr ;

   while (size-- )
    {
       *b yt ePtr + +  =0;
    }
} 

Simple  enough.B ut th e  c ode t hat  GCC a ct ual ly ge nerate s  if  youcall i tvaries  wild ly  with th e compiler version andthe am ountofbytes you 're act ually try ingto zero. h ttp s:/ /godb olt . org/g /cMa Q m2 

G C C 4.4 .7 a n d 4.5.3 n e ve r i g n or e the volat i l e .
G CC 4. 6.4 and 4. 7.3ignore volatile f o r array sizes1, 2 , and  4. GCC4. 8.1 until 4.9. 2 i gn o r e volati le  for arraysizes 1an d  2.
G CC 5
 compiles_every Markdown_file in /source into_pdf and_HTML,_and then_moves_them to /source/output._The only exception_is the readme.md file,_which is compiled_to_HTML only, renamed to index.html and copied to /source/output.
A couple of things to pay_attention_to is_to_correctly_type the output path in_the script block (output/foo.pdf) and_the URL_of the repository where to push to ("https://${GH_TOKEN}@github.com/${GH_REF}").
Last_but_not least, not_only the source where the repository will be published_from needs to be set correctly_but the default_branch_needs_to be changed too,_from master to gh-pages. To do_both, navigate to Settings on the_repository's page, then Options-->GitHub Pages-->Source, then select_gh-branch pages from the dropdown menu_(the ´gh-pages´ branch needs to_have been_created first for this option_to appear). Finally,_navigate to_Settings-->Branches-->Default Branch and_select gh-branch from the dropdown menu_again. 
The environment_variables also need to be set_correctly_in Travis.

 Q:

Is_the_definition_of "volatile"_this volatile, or_is_GCC having_some_standard compliancy problems?

I need a function_that_(like SecureZeroMemory from the WinAPI) always zeros_memory and doesn't get_optimized_away, even if the_compiler thinks the memory is_never going to accessed again after_that. Seems_like a_perfect candidate for volatile. But I'm having some problems actually getting_this to work with GCC. Here_is an example function:
void_volatileZeroMemory(volatile void*_ptr,_unsigned long long_size)
{
_ _ volatile unsigned char* bytePtr = (volatile_unsigned char*)ptr;

_   while (size--)
 _  {
 __     *bytePtr++_= 0;
    }
}

Simple_enough. But the code that_GCC_actually_generates if you call it_varies wildly with the compiler version_and the amount_of bytes you're actually trying to zero._https://godbolt.org/g/cMaQm2

GCC_4.4.7 and 4.5.3 never ignore the_volatile.
GCC_4.6.4 and 4.7.3 ignore volatile for_array_sizes_1, 2, and 4.
GCC 4.8.1_until 4.9.2 ignore volatile for array_sizes 1 and 2.
GCC 5