huggingface{"info": {"features": {"commit": {"dtype": "string", "_type": "Value"}, "subject": {"dtype": "string", "_type": "Value"}, "message": {"dtype": "string", "_type": "Value"}, "repos": {"dtype": "string", "_type": "Value"}, "file_path": {"dtype": "string", "_type": "Value"}, "license": {"dtype": "string", "_type": "Value"}, "unix_time": {"dtype": "int64", "_type": "Value"}, "new_contents": {"dtype": "string", "_type": "Value"}, "old_contents": {"dtype": "string", "_type": "Value"}}}} `4l8  old_contents  new_contents$ unix_time @4license$\ file_pathPreposxmessagesubject commit  w}   x<BBH{6(C@@PxFFLkhghgxm3 ww ȃȃ؉>C@C@I@ .= (Px@h0X Hp8`(Px@h0X Hp 8 ` ( P x  @ h  0 X H p 8`(Px@h0X Hp8`(Px@h0X Hp8`(Px@h0X Hp8`(Px@h 0 X !H!p!!!!"8"`""""#(#P#x####$@$h$$$$%0%X%%%%% &H&p&&&&'8'`''''(((P(x(((()@)h))))*0*X***** +H+p++++,8,`,,,,-(-P-x----.@.h..../0/X///// 0H0p0000181`11112(2P2x22223@3h3333404X44444 5H5p5555686`66667(7P7x77778@8h8888909X99999 :H:p::::;8;`;;;;<(<P<x<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]~DOr2_|1Vcx5^v5M-EvH 1 > k $ ! B ^ ( > ^ G ` -DXm<Wj)Kv-E]u8\s $<} To+?Xr2G[o!;Us<Ry/S+7Q/Ce;q<P g$CP  2 k !+!7!H!b!t!!!!!!! "5"I"^"l""""""#!#C#O#\###$9$d$$$$%8%m%%%%%'&W&&&&']'''''E(`(((((#)>)l)))*2*k****+D+q+++++:,M,g,,,, -X------.%.B...r/200%131N1[11111212B2d222223G3`333334404F4[4e44444445-5c5u55556;6O6{6Fixed problem with aloja_cli.rFIX: issues #1042 and #1044 (Compiler errors: undefined symbol ts___)added spacing updates to the file, no change to the scriptFixed lines and pointsAdd transparent areaAdd colored plot pointsAdd plot lineAdd some plot parametersUse with blockallow stageRunners in munge proceduresexpanded example with multipanel testsExperimental: implement allPanelsBad form to put assignments before functionsadd placeholder for an allPanels switch, update commentsrename vars to avoid looking (falsely) methodlikeassign from current panel instead of full extentsindentationloop over all panels mirroring axeslogical vectors to find target edgesadd match.axes functionAdded documentation.move functions to topreworked example with multiple plotswhitespaceshorter ticks, thickness relative to pointsizemake sizes relative to configurable base_sizemore space around axis titlesBug fix: used wrong objectspecify aspect ratioFix trim error with factor daterename ggplot themeFEAT: added ability for the compiler to extract typeset definitions from scalars.red.bring in compliance with s3mpi changeUpdate test.rUpdate src_teradata.rSelect only cell lines of current cancer for achilles plotStrange test IIStrange testorder before select in dtm.wordcloudTESTS: added a compiling file message to Red/tests/build-arm-tests.rTESTS: minor corrections to Red/run-all.rr files for week 1 addedTESTS: Fix to allow for multiple runs of CALL/WAITTESTS: Clarify CALL-SHOW? to enable /SHOW if definedTESTS: Create a switch for running CALL with /SHOW or /WAITdo not use tail in this methoddo not use tail for thisfix control matrix extraction bug from current minfi versionchanged suff statsUI defaultsFinished optimizing project file sizeremove defaults from UI for geom and stat typeCreated copy of data.table for modifying field namesShrunk project file sizeInformative errors when species names don't matchAdd informative error when matrix size is diffUse names(input)Minor update to updateInputtest thyroidGłupi błąd w pobierz_dane_szkol().Add pretty-printing of tablesAdd partial test results to mantel.r outputreverted implementation of "pause refreshing" feature to using last_plot since validations are not shown when they are passed to reactiveValues.fixed exampleupdated boxplot codeTESTS: minor fix to run-all.r script.Fix typo in commentAdd todo noteRemove annoying warning resulting from `melt`Attempt to remove conflict warnings when attachingEnable cachingTESTS: fix a uninitialized word in run-all.r.fixed bug, normalization now equivalent to minfi outside chromosomes X and Ybackground correction, dye bias correction and control matrix now identical to funnorm in minficonverted the implementation of "pause refresh" feature to using reactiveValues.re-use helper files from production modelx and y chromosomes handled correctlyUsed textareaInput for plot titletidied up code, same outputssummarize: move error checking to b$matchminor limit fixesPlot loss with non-logarithmic y axis scale.FEAT: minor code reduction.Improve prediction figureFix prediction plot, bugs in make-regress-figs.rFix colours in boxplotadded search for formatting treeMinor layout change on Customize tabAdd census data explorationAdd smoothing, peak and plummetImprove default importFIX: issue #1031 (Red/System spaces don't seem to be printing from within Red)Document semantics of sys module betterExports add_pccoord againsplitting add_pcoa and coordpcoaAdd script name to sys moduleadded examplescorrected spellingexpand grid layout properlyexport Qreg vardo not move split to array, leave commentlabel vars properly in layoutadd result to layout dfremove result naminglimit to one registryreworked confidence plotsRearange codeR/prepare_data.rnote on ape addedape modification doc addedcode cleanupInstall slidifyfix duplicated importsAdd more geo explorations.Hadleyfy the content of the script.fix name handling in melt()adde eigen pca testmodified to properly handle chrX and chrY for males and femalesgit-annex automatic syncDelete commented codeadd melt() function for arrays/dfsvegan::null model instead of vegan::commsimulatorTESTS: removed debugging leftover.TESTS: added support for system/script/argsm >> n in pca bench for nowAdd a few more plots, TODOs, and formattingclarity in cov benchmark + validity checkdebug import_pcoa_data.rdebug import_pcoa_data.rdebug import_pcoa_data.rdebug import_pcoa_data.rdebug import_pcoa_data.rdebuf import_pcoa_data.rDon’t export namespaceTESTS: changes to red/run-all.r in preparation of a --fast optionMake summaries and use cpipack-assets - improved check when cmdReplace can be used and added new walk typeAllow explicitly setting script pathOverview of the datasetInstall rChart by defaultDelete ui for changing import text file settingsAdd parallel eval. and progress bar capabilitiesLoad helper libraries by defaultchange file upload limitallow environment accessChange dates so that they are consistent with used subset of dataPobieranie danych o "artystyczności" szkół.Add index for plot.all.topics and some optimizationsAdd option to supply terms/freqs to wordcloudmake freqs optionalFIX: issue #995 (Shared library can't work on ARM-hf)Add try/catch to amcat.hitsrename local variableDelega all'option width l'ampiezza del terminaleReading now works, at least in simple cases.small but relevant changesFIX: added missing new dependency in ARM backend.PACo method includedD argument for paco_linksfull complement of methodsvegan::eigenvals added to coordpcoaape::pcoa function altered to allow generate non-zero eigenvalueremove margin, add methodHack shiny.error option to skip validation errorsMore functionality.bugs, bugs everywhereupdated plots scriptupdated plots scripts3 adapter should able to write arbitrary objectsMore functionality added.heatmap sorted according to result table in page1.rdelete dependency on plotlyBug fixadded null argumentadded code for paper plotsadded code for paper plotsAdded the load of the CSV fileFurther development - still not functional.detailed aberration plot function updated with new value typeseparate plot for errorsFEAT: cleaner handling of writing errors from the linker on locked files.Preparando country-visTESTS: updated error messages in tests.FIX: make Red compiler not emit routines definitions inline.TESTS: run-all.r script update to reflect changed name for unicode test file.Updated aloja_cli.rUpdate ggplot2_formatter.rFixed that combined bug here as wellSimplified comp1view1Plot after fixing server.rCode cleanupAdded argument assertionsUpdate ggplot2_formatter.rUpdate ggplot2_formatter.rFixed a grammatical mistakeremoved a debugging messageuse director for colouriseadded customUpdate ggplot2_formatter.rtemporary warning on stageRunners with zero stagescalculate pc variances..more descriptive commentupdate commentfix readLongfix readLongactual names are being compareddo not allow environment mixing when coalescing runnersfix stage comparisonremove my superfluous library callcs-lunch presentation random dataengineupdate read-binary-fixes.rNeed director object for scoping environmentcorrect parent scoping on resource injectionsFixed bugupdated to add in running the run_neatline functionadded use of function eudist to get earth sun distanceAdd documentation to module "sys"Minor changesDodana še možnost nastavitve pisav v glavni program.Fix a build failure caused by mergeFix a build failure caused by mergechanged default value for cancersrestructuring graphsUse as.environment for compatibility with objectdiffwhitespacespeed up execution of test_basic.radded option to composite all indices in a loop and providing coorinates for a usearea fileusing mixel2 instead of mixel function and added option to composite all indices with a loopIncluded zoomins for each chradjusted differential expression analysis codeupdated differential expression analysis codeFixed bug in getScorePlotfixed small bug on R code with R version 3.0re-enabled parallel computationformat changeadded the ability to select multiple directories when compositing images.a change was made to the values used in USGS masks. the code now works with both old and new versions of USGS masksizbris tabelepopravek (barve na grafu)added optional --user argument to IRkernel::installspec()odkomentirana 3. fazadodan uvoz nove razpredelnice za koordinate državdodan zemljevidFEAT: improved CATCH statement's error checking and reporting.adaption for ForeCA_0.2.0Remove panel border-2nd predict-2nd predict callinstall necessary packagessimple model againno splittingmore colon issuesfixed better scalefixed hopefullycoef data.frameExtends README in GeneratePlots.rParameterize the paths in GeneratePlots.rtypo corrected in page3.r in plot functionAdded enhancer stuffadded all RNA 0 catchAdded RNA infoRevert "Added RNA column"Added RNA columnadded name based subsetupdated modelRNA; everything is Gaussian right nowInverted colors for TS heatmapuse of on.exit(, add=TRUE)RingSettingprovide resource_name in resourcestesting pushAdd R shebangMaking sure stat_ellipse works correctly when imported into a clean sessioninitial commiting on tracked environment changesrevert environment injection using on.exitrectangle-pack - having a line for sort-method hardcodedpack-assets.r updated to it's current stateFEAT: minor code size reduction.finalize changeContains all functions necessary for page 1FIX: reverting the changes for handling console recompilation to fix the new issues on Mac/Linux.Adding more summary plotsrefactor s3 and data adapter to s3 and s3data adapterMelt data to avoid repeated lines of code.FIX: file path error when precompilng console.fix a bug and make it workAdd error bars to wdays.move changes inside tundraContainer to feel safeExperimental: Adding for cache statistics (WIP).change default adapter behavior to add data when export data flag is setFIX: system/options/boot inconsistency workaround.REL: 0.5.0 objects supportRemove commented portion.FIX: issue #893 (latest release 0.4.3 (commit 1ddcdc66e8) pre-compiles console everytime)Experimental: Adding for cache statistics (WIP).set up test code to add writingfix col.margin parameterAdd -t/--title option to priv/summary.radd caption from attr() instead of hardcoded; fix drop of attr when converting object-typeUpdating to latest results.Turn query errors into warningsadding a figure that didn't get pushed earlierImproving boxplot.Making it fully generic - forgot one more variableFirst version of boxplots from our benchmark data.align colnames to the rightadd code for fig size, but leave commented outAdded hard-coded values for another shared level file. Fixed length value of raw path data.Updating to latest results.Nome do item 11 do menu consertado.Apagando com o clear(), agora ta perfeito kkkAgora apagando os objetos no inicio de cada item do menu.Movido o grafico de linhas para o menuAgora com o plot fodao! *consertando erro de escrita*Agora com o plot fodao!FEAT: added support for internal Red directive #build-date.Ne izpišemo pobrisanih datotek, če jih ni.Dodana še možnost brisanja brez vprašanja.Ne smemo bit vedno tihi:)clearpdf.r vključen v glavni program.Dodana možnost tihega delovanja.Still trying to fix the Travis build issueAdded ... to plotCUB so model and a2 can be passed as argumentsfix table end errorfix line styling placementremoved some non-functioning kmeansrefactored topics over timedon't need to create .rdata file in step 7 of gapminder data cleaningfix small problem in step 4 of gapminder data cleaningfix small problem in 2nd step of gapminder data cleaningadd horizontal line styling to function (partial)clean up position index variablespass args to preprocessordocument args paramtidy and sort docadd comments to stopword codecreate stop word list from tablesfixed visible binding problemFEAT: #call directive now accepts an object's method invocation.Support recursive modules in help validity checkModified Idover.calc to logically work like the version in calculate_diffues_fraction.R. Existing version in Diffuse... seemed to have problems with if statements, logical order, and indexing.Modified Idover.calc to logically work like the version in calculate_diffues_fraction.R. Existing version in Diffuse... seemed to have problems with if statements, logical order, and indexing.Modified Idover.calc to logically work like the version in calculate_diffues_fraction.R. Existing version in Diffuse... seemed to have problems with if statements, logical order, and indexing.isOpen not working appropriately, use tryCatch hackadded analysisfile_extension expects '.r'nsef, not nsearray/summarize: omit empty mappingsFEAT: propagated runtime/environment file changes to the builder include script.debug norm v 5debug norm v 5do not allow global env when sourcing using RamdMerging remote changesedit the graphicsbind data.frame list to each otherbackwards compatibility with hookless containersset table_start_r and table_start_c as baseline coordsadded col margin optionadd 3th OR exampleadd function to print list of tabularsforce these so they can be referenced in hooksurejenostna spremenljivkaUpdated R data dump script with article states.popravek pri uvozusprememba urejenostne spremenljivkeodkomentiran uvoz s pomočjo xmldodala urejenostno spremenljivkobug fix for render v12bug fix for render v12bug fix for render v12bug fix for render v3Uvoz tabelAdded alignDepth plotting functions.respace serialize_xgb_object methodremove requirements of xgboostAccept file! to CALLAccept file! to CALLfix typefix identation spacingarray: fix mask, subset names[to merge with master] customize serialize/deserializeupdate render v11bupdate render v11bfix wrong envir when checking varswav-to-mp3 - using mp3loop utility to have better loops qualityChanged hardcoded values for asset idsmap_simple: fix when apply reduces dimensionsupdate some commentsFix problems with rename due to bug in dplyre Ah4frG]#8Xl EUbBw':Fl ! 2 N [ \ j  . a p K +Ug3Xt"<]{)>Tn| Kg{ $OyeSx3 @nHcD^0d0\<y3X4 O k !2!K!Z!g!t!!!!","G"t"""#K#m#{####$1$f$q$$<%%%&k&&&&&*''''((I(Y((((((())1)D)T)d)))))**n*****++3+@+N++++/,[,|,,6----.B.].v...!/T/o///040M0u000 1;1N11111[2w2223*3`3x3334)4P4r4444 5U5q555'6Y6{6666667Y77^899:#:>:L:q::::;(;_;9<j<<<<<"=<=l======>*>@>K>@A A5AJAdA{AAAAABYBBBBCFixed problem with aloja_cli.r FIX: issues #1042 and #1044 (Compiler errors: undefined symbol ts___) added spacing updates to the file, no change to the script Fixed lines and points Add transparent area Add colored plot points Add plot line Add some plot parameters Use with block allow stageRunners in munge procedures expanded example with multipanel tests Experimental: implement allPanels 1. Maybe ought to be in match.axes instead of main loop. 2. allPanels=T behavior incorrect when axes of middle panels are null: L and B axes not copied. 3. allPanels=F behavior incorrect when all panels have their own axes: only panel edges at edge of figure get mirrored. Bad form to put assignments before functions add placeholder for an allPanels switch, update comments rename vars to avoid looking (falsely) methodlike assign from current panel instead of full extents indentation loop over all panels mirroring axes logical vectors to find target edges add match.axes function Added documentation. Changed S3 objects to fit generic Former-commit-id: 13a04c0613e04334fef884b0957e67c90021d43bmove functions to top reworked example with multiple plots whitespace shorter ticks, thickness relative to pointsize make sizes relative to configurable base_size more space around axis titles Bug fix: used wrong object specify aspect ratio Fix trim error with factor date rename ggplot theme FEAT: added ability for the compiler to extract typeset definitions from scalars.red. bring in compliance with s3mpi change Update test.rUpdate src_teradata.rSelect only cell lines of current cancer for achilles plot Strange test II Strange test order before select in dtm.wordcloud TESTS: added a compiling file message to Red/tests/build-arm-tests.r TESTS: minor corrections to Red/run-all.r r files for week 1 added TESTS: Fix to allow for multiple runs of CALL/WAIT TESTS: Clarify CALL-SHOW? to enable /SHOW if defined TESTS: Create a switch for running CALL with /SHOW or /WAIT do not use tail in this method do not use tail for this fix control matrix extraction bug from current minfi versionchanged suff stats UI defaults Finished optimizing project file size remove defaults from UI for geom and stat type Created copy of data.table for modifying field names Shrunk project file size Informative errors when species names don't match Add informative error when matrix size is diff When the number of species in the Host or Parasite phylogeny is different to the number of species on the interaction matrix it used to spit the “subscript out of bounds” error. Now it tells the actual problem Use names(input) Minor update to updateInput test thyroid Głupi błąd w pobierz_dane_szkol(). Add pretty-printing of tables Add partial test results to mantel.r output reverted implementation of "pause refreshing" feature to using last_plot since validations are not shown when they are passed to reactiveValues. fixed example updated boxplot code TESTS: minor fix to run-all.r script. Fix typo in comment Add todo note Remove annoying warning resulting from `melt` Treat variable names as characters rather than factors. Attempt to remove conflict warnings when attaching Enable caching TESTS: fix a uninitialized word in run-all.r. fixed bug, normalization now equivalent to minfi outside chromosomes X and Y background correction, dye bias correction and control matrix now identical to funnorm in minfi converted the implementation of "pause refresh" feature to using reactiveValues. re-use helper files from production model x and y chromosomes handled correctly Used textareaInput for plot title tidied up code, same outputs summarize: move error checking to b$match minor limit fixes Plot loss with non-logarithmic y axis scale. FEAT: minor code reduction. Improve prediction figure Fix prediction plot, bugs in make-regress-figs.r Fix colours in boxplot added search for formatting tree Minor layout change on Customize tab Add census data exploration Add smoothing, peak and plummet Improve default import FIX: issue #1031 (Red/System spaces don't seem to be printing from within Red) Document semantics of sys module better Exports add_pccoord again splitting add_pcoa and coordpcoa Add script name to sys module added examples corrected spelling expand grid layout properly export Qreg var do not move split to array, leave comment label vars properly in layout add result to layout df remove result naming limit to one registry reworked confidence plots Rearange code R/prepare_data.r note on ape added ape modification doc added code cleanup Install slidify fix duplicated imports Add more geo explorations. Hadleyfy the content of the script. Use dplyr wherever possible. fix name handling in melt() adde eigen pca test modified to properly handle chrX and chrY for males and females git-annex automatic sync Delete commented code add melt() function for arrays/dfs vegan::null model instead of vegan::commsimulator `commsimulator` was a deprecated function in vegan. Using the `nullmodel` approach with has support and is ~ 35% faster. TESTS: removed debugging leftover. TESTS: added support for system/script/args m >> n in pca bench for now Add a few more plots, TODOs, and formattingclarity in cov benchmark + validity check debug import_pcoa_data.r debug import_pcoa_data.r debug import_pcoa_data.r debug import_pcoa_data.r debug import_pcoa_data.r debuf import_pcoa_data.r Don’t export namespace Create special environment and copy exported names into it. TESTS: changes to red/run-all.r in preparation of a --fast option Make summaries and use cpi cpi is consumer price index, its used for inflation estimation pack-assets - improved check when cmdReplace can be used and added new walk type Allow explicitly setting script path Overview of the dataset Install rChart by default Delete ui for changing import text file settings Add parallel eval. and progress bar capabilities Added parallel evaluation using foreach to spawn an independent process per link. If doing sequentially it can also add a progress bar borrowed from plyr. Updated corresponding roxygen comments for the function Load helper libraries by default change file upload limit allow environment access Change dates so that they are consistent with used subset of data ggplot2-bayarea uses only subset of data used in sfhousing, the dates where based on original dataset Pobieranie danych o "artystyczności" szkół. Add index for plot.all.topics and some optimizations Add option to supply terms/freqs to wordcloud make freqs optional FIX: issue #995 (Shared library can't work on ARM-hf) Add try/catch to amcat.hits rename local variable Delega all'option width l'ampiezza del terminale Reading now works, at least in simple cases. small but relevant changes FIX: added missing new dependency in ARM backend. PACo method included D argument for paco_links full complement of methods vegan::eigenvals added to coordpcoa ape::pcoa function altered to allow generate non-zero eigenvalue remove margin, add method Hack shiny.error option to skip validation errors More functionality. bugs, bugs everywhere updated plots script updated plots script s3 adapter should able to write arbitrary objects More functionality added. heatmap sorted according to result table in page1.r delete dependency on plotlyBug fix Needed to supply only "Combined" scores to getHeatmap function added null argument added code for paper plots added code for paper plots Added the load of the CSV file Further development - still not functional. detailed aberration plot function updated with new value type separate plot for errors FEAT: cleaner handling of writing errors from the linker on locked files. Preparando country-vis TESTS: updated error messages in tests. FIX: make Red compiler not emit routines definitions inline. TESTS: run-all.r script update to reflect changed name for unicode test file. Updated aloja_cli.r Update ggplot2_formatter.r Add in human_num as you cannot have labels = human_numbers()Fixed that combined bug here as well Simplified comp1view1Plot after fixing server.r Code cleanup Added argument assertions Update ggplot2_formatter.r Change typo human_gdp to human_gbpUpdate ggplot2_formatter.r Add in extra example for use of 'human_gdp'Fixed a grammatical mistakeremoved a debugging message use director for colourise added custom Update ggplot2_formatter.r Update with functions created for humanised currencies.temporary warning on stageRunners with zero stages calculate pc variances.. more descriptive comment update comment fix readLong fix readLong actual names are being compared do not allow environment mixing when coalescing runners fix stage comparison remove my superfluous library call cs-lunch presentation random dataengine update read-binary-fixes.r Need director object for scoping environment correct parent scoping on resource injections Fixed bug Selecting combined score resulted in oncogene plot updated to add in running the run_neatline function added use of function eudist to get earth sun distance Add documentation to module "sys" Minor changes Dodana še možnost nastavitve pisav v glavni program. Fix a build failure caused by merge Fix a build failure caused by merge changed default value for cancers restructuring graphs Use as.environment for compatibility with objectdiff whitespace speed up execution of test_basic.r * only look at first 5 repos * only print repo name, owner, updated_at added option to composite all indices in a loop and providing coorinates for a usearea file using mixel2 instead of mixel function and added option to composite all indices with a loop Included zoomins for each chr adjusted differential expression analysis code annotation and fall back if there is no replicates updated differential expression analysis code allows grouping of replicates now Fixed bug in getScorePlot fixed small bug on R code with R version 3.0 re-enabled parallel computation format change added the ability to select multiple directories when compositing images. a change was made to the values used in USGS masks. the code now works with both old and new versions of USGS masks izbris tabele popravek (barve na grafu) added optional --user argument to IRkernel::installspec() odkomentirana 3. faza dodan uvoz nove razpredelnice za koordinate držav dodan zemljevid FEAT: improved CATCH statement's error checking and reporting. adaption for ForeCA_0.2.0Remove panel border -2nd predict -2nd predict call install necessary packages simple model again no splitting more colon issues fixed better scale fixed hopefully coef data.frame Extends README in GeneratePlots.r Parameterize the paths in GeneratePlots.r typo corrected in page3.r in plot function Added enhancer stuff added all RNA 0 catch Added RNA info Revert "Added RNA column" This reverts commit 944323aaa3839ce7d2386b3f463f6ef1ced5f5bb. Added RNA column added name based subset updated modelRNA; everything is Gaussian right now Inverted colors for TS heatmap use of on.exit(, add=TRUE) RingSetting provide resource_name in resources testing push Add R shebang Making sure stat_ellipse works correctly when imported into a clean session initial commiting on tracked environment changes revert environment injection using on.exit rectangle-pack - having a line for sort-method hardcoded pack-assets.r updated to it's current state FEAT: minor code size reduction. finalize change Contains all functions necessary for page 1 page1DataFrame(): filtering of results that are shown in the plots plotHeatmapPage1(): view 1 plotCategoryOverview(): view 2 FIX: reverting the changes for handling console recompilation to fix the new issues on Mac/Linux. Adding more summary plots refactor s3 and data adapter to s3 and s3data adapter Melt data to avoid repeated lines of code. FIX: file path error when precompilng console. fix a bug and make it work Add error bars to wdays. move changes inside tundraContainer to feel safe Experimental: Adding for cache statistics (WIP). change default adapter behavior to add data when export data flag is set FIX: system/options/boot inconsistency workaround. REL: 0.5.0 objects support Remove commented portion. FIX: issue #893 (latest release 0.4.3 (commit 1ddcdc66e8) pre-compiles console everytime) Experimental: Adding for cache statistics (WIP). set up test code to add writing fix col.margin parameter Add -t/--title option to priv/summary.r add caption from attr() instead of hardcoded; fix drop of attr when converting object-type Updating to latest results. Turn query errors into warnings adding a figure that didn't get pushed earlier Improving boxplot. Making it fully generic - forgot one more variable First version of boxplots from our benchmark data. align colnames to the right add code for fig size, but leave commented out Added hard-coded values for another shared level file. Fixed length value of raw path data. Updating to latest results. Nome do item 11 do menu consertado. Apagando com o clear(), agora ta perfeito kkk Agora apagando os objetos no inicio de cada item do menu. Movido o grafico de linhas para o menu Agora com o plot fodao! *consertando erro de escrita* Agora com o plot fodao! FEAT: added support for internal Red directive #build-date. Ne izpišemo pobrisanih datotek, če jih ni. Dodana še možnost brisanja brez vprašanja. Ne smemo bit vedno tihi:) clearpdf.r vključen v glavni program. Dodana možnost tihega delovanja. Still trying to fix the Travis build issue Added ... to plotCUB so model and a2 can be passed as arguments fix table end error fix line styling placement removed some non-functioning kmeans Added term-document matrix section. refactored topics over time don't need to create .rdata file in step 7 of gapminder data cleaning fix small problem in step 4 of gapminder data cleaning fix small problem in 2nd step of gapminder data cleaning add horizontal line styling to function (partial) clean up position index variables pass args to preprocessordocument args param tidy and sort doc add comments to stopword code create stop word list from tables fixed visible binding problem FEAT: #call directive now accepts an object's method invocation. Support recursive modules in help validity check Work in progress. Modified Idover.calc to logically work like the version in calculate_diffues_fraction.R. Existing version in Diffuse... seemed to have problems with if statements, logical order, and indexing. Modified Idover.calc to logically work like the version in calculate_diffues_fraction.R. Existing version in Diffuse... seemed to have problems with if statements, logical order, and indexing. Modified Idover.calc to logically work like the version in calculate_diffues_fraction.R. Existing version in Diffuse... seemed to have problems with if statements, logical order, and indexing. isOpen not working appropriately, use tryCatch hack added analysis file_extension expects '.r'nsef, not nse array/summarize: omit empty mappings FEAT: propagated runtime/environment file changes to the builder include script. debug norm v 5 debug norm v 5 do not allow global env when sourcing using Ramd Merging remote changes edit the graphics Trying out some different smoothing bind data.frame list to each other Binded each of the html table data frames to one another. Can use "word" function next to get individual words for stoplist. Also refactored data chaining syntax to make more clear. backwards compatibility with hookless containers set table_start_r and table_start_c as baseline coords added col margin option add 3th OR example add function to print list of tabulars force these so they can be referenced in hooks urejenostna spremenljivka Updated R data dump script with article states. popravek pri uvozu sprememba urejenostne spremenljivke odkomentiran uvoz s pomočjo xml dodala urejenostno spremenljivko bug fix for render v12 bug fix for render v12 bug fix for render v12 bug fix for render v3 Uvoz tabel Added alignDepth plotting functions. Added a set of functions to plot alignDepths and gene structures together with each other. plotTranscripts pu.arrows (plot unit arrows) plotDepthsTranscripts These should not be considered as finished products. In particular the plotTranscripts function depends on a specific list / dataframe structure, that isn't formally described anywhere. I've used this as it interfaces easily with a function I have for pulling gene transcripts from a connection to an ensembl database. But it's difficult to make a formal dependency on those functions. (Though I suppose one could access directly a publich Ensembl database?). respace serialize_xgb_object method remove requirements of xgboost Accept file! to CALL Accept file! to CALL fix type relase->release fix identation spacing array: fix mask, subset names [to merge with master] customize serialize/deserialize update render v11b update render v11b fix wrong envir when checking vars wav-to-mp3 - using mp3loop utility to have better loops quality Changed hardcoded values for asset ids map_simple: fix when apply reduces dimensions update some comments Fix problems with rename due to bug in dplyr force use of plyr with this currently. Rs*@VlE[o ,* ! 2 C P ] n  # 4 B P   / F   ! M n | ' +<Mau "/<S`mY ,9FSdM\QM`5N1r7Qk7I&3@MZgx4#0&et(&4!P!_!n!!!!!"*"@"" #^##$Q$$$$%y%%&)&h&x&&&&&'''+.".1.F.X... /:/P///0 0;0l000001111u22234z5l6^7 889:%;i;x;j<\=N>@?2@$AB%B6BCBSBCC-CCCCDDDD@EqEEEVFlFFF-GCGGAHHIkIJ'JvLLLL1MMMMNNNAO`OOOOOOzPtUnZh_7d1iAiiiiii(jTjjjjjj{kkklmm6mNmfm|m)nnoT>T6TK6T6T5T3TTT.pTnTSkTjTbhT*gTaT`TPT&JT3Tb#TN#T"TT T&TlT0T>T T/TTT}T(T-TTz|TTDTTbTTTSTTuTrTqTqT]^TYRTKTu>T-5ToTuToTT TTTT/T/TU#T4#T;TT`TT4TNtT KTa7T`T8TpT]TVTj9TTT3TTVTTVTJT:TET9TTTTQTNTmNTLTJT{?T4;T'TT(TuTTLCT5T)T TTTbTXTXDTTTkTkTT TTTTܦTTFTTTTpTOaTZTT(TT[T)TBT\TTyTEPTT0WTTTTnzTT{T7T>T'TT9TTTvTTnTQ5TAATAAT7T"T8TfT TxTTTNTxTyThT}TCTPTTGTrTVYTaTZTTpTT̴T==T/T'TTTTTjXTBTv@Tl>TQ.Tl'T!TܠTTHT~TTiT^T]T2TRT JT׷T׷TڶT~8TT轵T張ToYTWNT>T6T5TTTxTWITHTHT#HTGTTѯTѯTXѯTRTTFT\T:TTҊTTT}T|TbT[TZT2TaTeTz_TA_T(_TUT]ST#AT$T"TTHT8=T4T7TT2TũTT T7΢TYT0T T| T2TyTxT|TZTGUTsJTKTTTT.TTA7T!TTǒTѽT>9TT<ՐTnT=Tz%TT@/B/D/bF/'I/)X//n//6///[0@0]0u0f0000#0T0Q2a2&22P2223m3P73@33/3334 4!4I74I4R4bj44444Й4M4Ш4t5?6 777U:c:i:= ;~;a;1;;F!<<===V>U>>>#!/usr/bin/env Rscript # Josep Ll. Berral-García # ALOJA-BSC-MSR hadoop.bsc.es # 2014-12-11 # Launcher of ALOJA-ML # usage: ./aloja_cli.r -m method [-d dataset] [-l learned model] [-p param1=aaaa:param2=bbbb:param3=cccc:...] [-a] [-n dims] [-v] # ./aloja_cli.r --method method [--dataset dataset] [--learned learned model] [--params param1=aaaa:param2=bbbb:param3=cccc:...] [--allvars] [--numvars dims] [--verbose] # # ./aloja_cli.r -m aloja_regtree -d aloja-dataset.csv -p saveall=m5p1 # ./aloja_cli.r -m aloja_regtree -d aloja-dataset.csv -p saveall=m5p1-small:vin="Benchmark,Net,Disk,Maps,IO.SFac,Rep,IO.FBuf,Comp,Blk.size" # ./aloja_cli.r -m aloja_predict_dataset -l m5p1 -d m5p1-tt.csv -v # ./aloja_cli.r -m aloja_predict_instance -l m5p1 -p inst_predict="sort,ETH,RR3,8,10,1,65536,None,32,Azure L" -v # ./aloja_cli.r -m aloja_predict_instance -l m5p1 -p inst_predict="sort,ETH,RR3,8|10,10,1,65536,*,32,Azure L":sorted=asc -v # ./aloja_cli.r -m aloja_predict_instance -l m5p1 -p inst_predict="sort,ETH,RR3,8|10,10,1,65536,*,32,Azure L":vin="Benchmark,Net,Disk,Maps,IO.SFac,Rep,IO.FBuf,Comp,Blk.size,Cluster":sorted=asc -v # # ./aloja_cli.r -m aloja_outlier_dataset -d m5p1-tt.csv -l m5p1 -p sigma=3:hdistance=3:saveall=m5p1test # ./aloja_cli.r -m aloja_outlier_instance -l m5p1 -p instance="sort,ETH,RR3,8,10,1,65536,None,32,Azure L":observed=100000:display=1 -v # # ./aloja_cli.r -m aloja_pca -d aloja-dataset.csv -p saveall=pca1 # ./aloja_cli.r -m aloja_regtree -d pca1-transformed.csv -p prange=1e-4,1e+4:saveall=m5p-simple-redim -n 20 # ./aloja_cli.r -m aloja_predict_instance -l m5p-simple-redim -p inst_predict="1922.904354752,70.1570440421649,2.9694955079494,-3.64259027685954,-0.748746678239734,0.161321484374316,0.617610510007444,-0.459044093400257,0.251211132013151,0.251937462205716,-0.142007748147355,-0.0324862729758309,0.406308900544488,0.13593705166432,0.397452596451088,-0.731635384355167,-0.318297127484775,-0.0876192175148721,-0.0504762335523307,-0.0146283091875174" -v # ./aloja_cli.r -m aloja_predict_dataset -l m5p-simple-redim -d m5p-simple-redim-tt.csv -v # ./aloja_cli.r -m aloja_transform_data -d newdataset.csv -p pca_name=pca1:saveall=newdataset # ./aloja_cli.r -m aloja_transform_instance -p pca_name=pca1:inst_transform="sort,ETH,RR3,8,10,1,65536,None,32,Azure L" -v # # ./aloja_cli.r -m aloja_dataset_collapse -d aloja-dataset.csv -p dimension1="Benchmark":dimension2="Net,Disk,Maps,IO.SFac,Rep,IO.FBuf,Comp,Blk.size,Cluster":dimname1="Benchmark":dimname2="Configuration":saveall=dsc1 # ./aloja_cli.r -m aloja_dataset_collapse -d aloja-dataset.csv -p dimension1="Benchmark":dimension2="Net,Disk,Maps,IO.SFac,Rep,IO.FBuf,Comp,Blk.size,Cluster":dimname1="Benchmark":dimname2="Configuration":saveall=dsc1:model_name=m5p1 # ./aloja_cli.r -m aloja_dataset_collapse_expand -d aloja-dataset.csv -p dimension1="Benchmark":dimension2="Net,Disk,Maps,IO.SFac,Rep,IO.FBuf,Comp,Blk.size,Cluster":dimname1="Benchmark":dimname2="Configuration":saveall=dsc1:model_name=m5p1:inst_general="sort,ETH,RR3,8|10,10,1,65536,*,32,Azure L" # ./aloja_cli.r -m aloja_best_configurations -p bvec_name=dsc1 -v # # ./aloja_cli.r -m aloja_minimal_instances -l m5p1 -p saveall=mi1 # ./aloja_cli.r -m aloja_minimal_instances -l m5p1 -p kmax=200:step=10:saveall=mi1 library(devtools); source_url("https://raw.githubusercontent.com/Aloja/aloja-ml/master/functions.r"); options(width=as.integer(1000)); ############################################################################### # Read arguments from CLI suppressPackageStartupMessages(require(optparse)); option_list = list( make_option(c("-m", "--method"), action="store", default=NULL, type='character', help="Method to be executed"), make_option(c("-p", "--params"), action="store", default=NULL, type='character', help="Generic list of parameters, separated by two points and no spaces"), make_option(c("-v", "--verbose"), action="store_true", default=FALSE, help="Outputs the result of the method"), make_option(c("-d", "--dataset"), action="store", default=NULL, type='character', help="For training methods: Dataset source of data"), make_option(c("-a", "--allvars"), action="store_true", default=FALSE, help="All vars are input but first one (for reduced dimensions)"), make_option(c("-n", "--numvars"), action="store", default=NULL, type='integer', help="All n vars after first one are input (for reduced dimensions)"), make_option(c("-l", "--learned"), action="store", default=NULL, type='character', help="For prediction methods: Learned model for prediction") ); opt = parse_args(OptionParser(option_list=option_list)); ############################################################################### # Error and Warning messages on arguments if (is.null(opt$method)) { cat("[ERROR] No method selected. Aborting mission.\n"); quit(save="no", status=-1); } ############################################################################### # Read datasets dataset <- NULL; if (!is.null(opt$dataset)) { # Call for aloja_get_data params_1 <- list(); params_1[["fread"]] = opt$dataset; dataset <- do.call(aloja_get_data,params_1); } ############################################################################### # Parse parameters params <- list(); params[["ds"]] <- dataset; if (opt$method %in% c("aloja_regtree","aloja_nneighbors","aloja_linreg","aloja_nnet","aloja_pca","aloja_dataset_collapse","aloja_dataset_collapse_expand","aloja_outlier_dataset","aloja_outlier_instance","aloja_binarize_instance")) { if (is.null(opt$vout)) params[["vout"]] <- "Exe.Time"; if (is.null(opt$vin)) { if (opt$allvars) { params[["vin"]] = colnames(dataset)[!(colnames(dataset) %in% c("ID",params$vout))]; } else if (!is.null(opt$numvars)) { params[["vin"]] = (colnames(dataset)[!(colnames(dataset) %in% c("ID",params$vout))])[1:opt$numvars]; } else { params[["vin"]] = c("Benchmark","Net","Disk","Maps","IO.SFac","Rep","IO.FBuf","Comp","Blk.size","Cluster","Cl.Name","Datanodes","Headnodes","VM.OS","VM.Cores","VM.RAM","Provider","VM.Size","Type"); } } } if (opt$method %in% c("aloja_print_individual_summaries","aloja_print_summaries")) { params[["vin"]] <- c("Exe.Time","Benchmark","Net","Disk","Maps","IO.SFac","Rep","IO.FBuf","Comp","Blk.size","Cluster","Cl.Name","Datanodes","Headnodes","VM.OS","VM.Cores","VM.RAM","Provider","VM.Size","Type"); } if (!is.null(opt$learned)) { params_2 <- list(); params_2[["tagname"]] <- opt$learned; params[["learned_model"]] <- do.call(aloja_load_object,params_2); } if (!is.null(opt$params)) { saux_1 <- strsplit(opt$params, ":"); saux_2 <- strsplit(saux_1[[1]],"="); for (i in 1:length(saux_2)) { params[[saux_2[[i]][1]]] <- strsplit(saux_2[[i]][2],",")[[1]]; } rm(saux_1,saux_2); } if (is.null(params$vin) && opt$method == "aloja_predict_instance") { if (length(params$inst_predict) == length(params$learned_model$varin)) { params[["vin"]] <- params$learned_model$varin; } else { params[["vin"]] <- c("Benchmark","Net","Disk","Maps","IO.SFac","Rep","IO.FBuf","Comp","Blk.size","Cluster","Cl.Name","Datanodes","Headnodes","VM.OS","VM.Cores","VM.RAM","Provider","VM.Size","Type"); } } if (is.null(params$vin) && opt$method == "aloja_predict_dataset") { if (all(colnames(params$ds) %in% params$learned_model$varin)) { params[["vin"]] <- params$learned_model$varin; } else { params[["vin"]] <- c("Benchmark","Net","Disk","Maps","IO.SFac","Rep","IO.FBuf","Comp","Blk.size","Cluster","Cl.Name","Datanodes","Headnodes","VM.OS","VM.Cores","VM.RAM","Provider","VM.Size","Type"); } } ############################################################################### # Execute call result <- do.call(opt$method,params); if (opt$verbose) result; ############################################################################### # C'est fini quit(save="no", status=0); REBOL [ Title: "Red compiler" Author: "Nenad Rakocevic" File: %compiler.r Tabs: 4 Rights: "Copyright (C) 2011-2012 Nenad Rakocevic. All rights reserved." License: "BSD-3 - https://github.com/dockimbel/Red/blob/master/BSD-3-License.txt" ] do-cache %system/compiler.r red: context [ verbose: 0 ;-- logs verbosity level job: none ;-- reference the current job object script-name: none script-path: none main-path: none runtime-path: %runtime/ include-stk: make block! 3 included-list: make block! 20 symbols: make hash! 1000 globals: make hash! 1000 ;-- words defined in global context aliases: make hash! 100 contexts: make hash! 100 ;-- storage for statically compiled contexts ctx-stack: make block! 8 ;-- contexts access path shadow-funcs: make block! 1000 ;-- shadow functions contexts [symbol object! ctx...] objects: make block! 600 ;-- shadow objects contexts [name object! ctx...] obj-stack: to path! 'objects ;-- current object access path container-obj?: none ;-- closest wrapping object func-objs: none ;-- points to 'objects first in-function object paths-stack: make block! 4 ;-- stack of generated code for handling dual codepaths for paths rebol-gctx: bind? 'rebol expr-stack: make block! 8 lexer: do bind load-cache %lexer.r 'self extracts: do bind load-cache %utils/extractor.r 'self ;-- @@ to be removed once we get redbin loader. sys-global: make block! 1 lit-vars: reduce [ 'block make hash! 1000 'string make hash! 1000 'context make hash! 1000 ] pc: none locals: none locals-stack: make block! 32 output: make block! 100 sym-table: make block! 1000 literals: make block! 1000 declarations: make block! 1000 bodies: make block! 1000 ssa-names: make block! 10 ;-- unique names lookup table (SSA form) types-cache: make hash! 100 ;-- store compiled typesets [types array name...] last-type: none return-def: to-set-word 'return ;-- return: keyword s-counter: 0 ;-- series suffix counter depth: 0 ;-- expression nesting level counter max-depth: 0 booting?: none ;-- YES: compiling boot script no-global?: no ;-- YES: put global code in a function nl: newline unboxed-set: [integer! char! float! float32! logic!] block-set: [block! paren! path! set-path! lit-path!] ;@@ missing get-path! string-set: [string! binary!] series-set: union block-set string-set actions: make block! 100 op-actions: make block! 20 keywords: make block! 10 actions-prefix: to path! 'actions natives-prefix: to path! 'natives intrinsics: [ if unless either any all while until loop repeat forever foreach forall break func function does has exit return switch case routine set get reduce context object construct try ] logic-words: [true false yes no on off] word-iterators: [repeat foreach forall] ;-- only ones that use word(s) as counter iterators: [loop until while repeat foreach forall forever] func-constructors: [ 'func | 'function | 'does | 'has | 'routine | 'make 'function! ] functions: make hash! [ ;---name--type--arity----------spec----------------------------refs-- make [action! 2 [type [datatype! word!] spec [any-type!]] #[none]] ;-- must be pre-defined ] make-keywords: does [ foreach [name spec] functions [ if spec/1 = 'intrinsic! [ repend keywords [name reduce [to word! join "comp-" name]] ] ] bind keywords self ] set-last-none: does [copy [stack/reset none/push-last]] ;-- copy required for R/S line counting injection --not-implemented--: does [print "Feature not yet implemented!" halt] quit-on-error: does [ clean-up if system/options/args [quit/return 1] halt ] throw-error: func [err [word! string! block!]][ print [ "*** Compilation Error:" either word? err [ join uppercase/part mold err 1 " error" ][reform err] "^/*** in file:" mold script-name ;either locals [join "^/*** in function: " func-name][""] ] if pc [ print [ ;"*** at line:" calc-line lf "*** near:" mold copy/part pc 8 ] ] quit-on-error ] dispatch-ctx-keywords: func [original [any-word! none!] /with alt-value][ if path? alt-value [alt-value: alt-value/1] switch/default any [alt-value pc/1][ func [comp-func] function [comp-function] has [comp-has] does [comp-does] routine [comp-routine] construct [comp-construct] object context [ either obj: is-object? pc/2 [ comp-context/with/extend original obj ][ comp-context/with original ] ] ][no] ] relative-path?: func [file [file!]][ not find "/~" first file ] process-include-paths: func [code [block!] /local rule file][ parse code rule: [ some [ #include file: ( script-path: any [script-path main-path] if all [script-path relative-path? file/1][ file/1: clean-path join script-path file/1 ] ) | into rule | skip ] ] ] process-calls: func [code [block!] /global /local rule pos mark][ parse code rule: [ some [ #call pos: ( mark: tail output process-call-directive pos/1 to logic! global change/part back pos mark 2 clear mark ) | #get pos: (process-get-directive pos/1 pos) | into rule | skip ] ] ] process-routine-calls: func [code [block!] ctx [word!] ignore [block!] obj [object!] /local rule name][ parse code rule: [ some [ name: word! ( if all [in obj name/1 not find ignore name/1][ name/1: decorate-obj-member name/1 ctx ] ) | path! | set-path! | lit-path! | into rule | skip ] ] ] preprocess-strings: func [code [block!] /local rule s][ ;-- re-encode strings for Red/System parse code rule: [ any [ s: string! (lexer/decode-UTF8-string s/1) | into rule | skip ] ] ] convert-to-block: func [mark [block!]][ change/part/only mark copy/deep mark tail mark ;-- put code between [...] clear next mark ;-- remove code at "upper" level ] any-function?: func [value [word!]][ find [native! action! op! function! routine!] value ] scalar?: func [expr][ find [ unset! none! logic! datatype! char! integer! tuple! decimal! refinement! issue! lit-word! word! get-word! set-word! ] type?/word :expr ] local-bound?: func [original [any-word!] /local obj][ all [ not empty? locals-stack rebol-gctx <> obj: bind? original find shadow-funcs obj ] ] local-word?: func [name [word!]][ all [not empty? locals-stack find last locals-stack name] ] unicode-char?: func [value][ all [issue? value value/1 = #"'"] ] float-special?: func [value][ all [issue? value value/1 = #"."] ] insert-lf: func [pos][ new-line skip tail output pos yes ] emit: func [value][ either block? value [append output value][append/only output value] ] emit-src-comment: func [pos [block! paren! none!] /with cmt [string!]][ unless cmt [ cmt: trim/lines mold/only/flat clean-lf-deep copy/deep/part pos offset? pos pc ] if 50 < length? cmt [cmt: append copy/part cmt 50 "..."] emit reduce [ '------------| (cmt) ] ] find-ssa: func [name [word!]][find/skip ssa-names name 2] select-ssa: func [name [word!] /local pos][ all [pos: find/skip ssa-names name 2 pos/2] ] parent-object?: func [obj [object!]][ all [not empty? locals-stack (next first obj) = container-obj?] ] find-binding: func [original [any-word!] /local ctx idx obj][ all [ ctx: all [ rebol-gctx <> obj: bind? original any [select objects obj select shadow-funcs obj] ] attempt [idx: get-word-index/with to word! original ctx] reduce [ctx idx] ] ] bind-function: func [body [block!] shadow [object!] /local self* rule pos][ bind body shadow if 1 < length? obj-stack [ self*: in do obj-stack 'self ;-- rebing SELF to the wrapping object parse body rule: [ any [pos: 'self (pos/1: self*) | into rule | skip] ] ] ] get-word-index: func [name [word!] /with c [word!] /local ctx pos list][ if with [ ctx: select contexts c return (index? find ctx name) - 1 ] list: tail ctx-stack until [ ;-- search backward in parent contexts list: back list ctx: select contexts list/1 if pos: find ctx name [ return (index? pos) - 1 ;-- 0-based access in context table ] head? list ] throw-error ["Should not happen: not found context for word: " mold name] ] emit-push-from: func [ name [any-word!] original [any-word!] type [word!] actions [block!] /local ctx obj idx ][ either all [ ctx: all [ rebol-gctx <> obj: bind? original select objects obj ] attempt [idx: get-word-index/with name ctx] ][ emit append to path! type actions/1 emit either parent-object? obj ['octx][ctx] ;-- optional parametrized context reference (octx) emit idx insert-lf -3 ][ emit append to path! type actions/2 emit prefix-exec name insert-lf -2 ] ] emit-push-word: func [name [any-word!] original [any-word!] /local type ctx obj][ type: to word! form type? name name: to word! :name either all [ rebol-gctx <> obj: bind? original ctx: select shadow-funcs obj ][ emit append to path! type 'push-local emit ctx emit get-word-index name ;@@ replace that insert-lf -3 ][ emit-push-from name original type [push-local push] ] ] emit-get-word: func [name [word!] original [any-word!] /any? /literal /local new obj][ either all [ rebol-gctx <> obj: bind? original find shadow-funcs obj ][ emit 'stack/push ;-- local word ][ if new: select-ssa name [name: new] ;@@ add a check for function! type emit case [ ;-- global word literal ['get-word/get] any? ['word/get-any] 'else [ emit-push-from name name 'word [get-local get] exit ] ] ] emit decorate-symbol name insert-lf -2 ] emit-load-string: func [buffer [string! file! url!]][ emit to path! reduce [to word! form type? buffer 'load] emit form buffer emit 1 + length? buffer ;-- account for terminal zero emit 'UTF-8 ] emit-open-frame: func [name [word!] /local type][ unless find symbols name [add-symbol name] emit case [ 'function! = all [ type: find functions name first first next type ]['stack/mark-func] name = 'try ['stack/mark-try] name = 'catch ['stack/mark-catch] 'else ['stack/mark-native] ] emit prefix-exec name insert-lf -2 ] emit-close-frame: func [/last][ emit pick [stack/unwind-last stack/unwind] to logic! last insert-lf -1 ] emit-stack-reset: does [ emit 'stack/reset insert-lf -1 ] emit-dyn-check: does [ emit 'stack/check-call insert-lf -1 ] emit-action: func [name [word!] /with options [block!]][ emit join actions-prefix to word! join name #"*" insert-lf either with [ emit options -1 - length? options ][ -1 ] ] emit-native: func [name [word!] /with options [block!]][ emit join natives-prefix to word! join name #"*" insert-lf either with [ emit options -1 - length? options ][ -1 ] ] emit-exit-function: does [ emit [ stack/unwind-last stack/unroll stack/FLAG_FUNCTION ctx/values: as node! pop exit ] insert-lf -5 ] emit-deep-check: func [path [series!] /local list check check2 obj top? parent-ctx][ check: [ 'object/unchanged? prefix-exec path/1 third obj: find objects do obj-stk ] check2: [ 'object/unchanged2? parent-ctx get-word-index/with path/1 parent-ctx third obj: find objects do obj-stk ] obj-stk: copy obj-stack obj-stk/1: either find-contexts path/1 ['func-objs]['objects] either 2 = length? path [ append obj-stk path/1 reduce check ][ list: make block! 3 * length? path while [not tail? next path][ append obj-stk path/1 repend list get pick [check check2] head? path parent-ctx: obj/2 path: next path ] new-line list on new-line skip list 3 on new-line/all/skip skip list 3 on 4 reduce ['all list] ] ] make-typeset: func [ spec [block!] option [block! none!] /local bs ts word bit idx name ][ spec: sort spec ;-- sort types to reduce cache misses either bs: find/only/skip types-cache spec 3 [ ts: bs/2 name: bs/3 ][ ts: copy [0 0 0] foreach type spec [ type: either word: in extracts/scalars type [get word][reduce [type]] foreach word type [ word: head remove back tail form word ;-- remove ending #"!" replace/all word #"-" #"_" type: to word! uppercase head insert word "TYPE_" bit: select extracts/definitions type idx: (bit / 32) + 1 poke ts idx ts/:idx or shift/logical -2147483648 bit and 255 ] ] forall ts [ts/1: to integer! to-bin32 ts/1] ;-- convert to little-endian values redirect-to literals [ name: decorate-series-var 'ts emit reduce [to set-word! name 'typeset/create ts/1 ts/2 ts/3] insert-lf -5 ] append types-cache reduce [spec ts name] ] either option [ option: to word! join "~" clean-lf-flag option/1 reduce ['type-check-alt option name] ][ reduce ['type-check name] ] ] emit-type-checking: func [name [word!] spec [block!] /local pos type][ name: to word! next form name ;-- remove prefix decoration either pos: find spec name [ type: case [ block? pos/2 [pos/2] all [string? pos/3 block? pos/3][pos/3] 'else [[default!]] ] make-typeset type find/reverse pos refinement! ][ none ] ] get-counter: does [s-counter: s-counter + 1] clean-lf-deep: func [blk [block! paren!] /local pos][ blk: copy/deep blk parse blk rule: [ pos: (new-line/all pos off) into rule | skip ] blk ] clean-lf-flag: func [name [word! lit-word! set-word! get-word! refinement!]][ mold/flat to word! name ] prefix-func: func [word [word!] /with path][ if 1 < length? obj-stack [ path: any [obj-func-call? word next any [path obj-stack]] word: decorate-obj-member word path ] word ] prefix-exec: func [word [word!]][ either any [empty? locals-stack not find-contexts word][ decorate-symbol word ][ decorate-exec-ctx decorate-symbol word ;-- 'exec prefix to access the word! and not the local value ] ] generate-anon-name: has [name][ add-symbol name: to word! rejoin [""] name ] decorate-obj-member: func [word [word!] path /local value][ parse value: mold path [some [p: #"/" (p/1: #"~") | skip]] to word! rejoin [value #"~" word] ] decorate-type: func [type [word!]][ to word! join "red-" mold/flat type ] decorate-exec-ctx: func [name [word!]][ append to path! 'exec name ] decorate-symbol: func [name [word!] /local pos][ if pos: find/case/skip aliases name 2 [name: pos/2] to word! join "~" clean-lf-flag name ] decorate-func: func [name [word!] /strict /local new][ if all [not strict new: select-ssa name][name: new] to word! join "f_" clean-lf-flag name ] decorate-series-var: func [name [word!] /local new list][ new: to word! join name get-counter list: select lit-vars select [blk block str string ctx context] name if all [list not find list new][append list new] new ] declare-variable: func [name [string! word!] /init value /local var set-var][ set-var: to set-word! var: to word! name unless find declarations set-var [ repend declarations [set-var any [value 0]] ;-- declare variable at root level new-line skip tail declarations -2 yes ] reduce [var set-var] ] add-symbol: func [name [word!] /local sym id alias][ unless find/case symbols name [ if find symbols name [ if find/case/skip aliases name 2 [exit] alias: decorate-series-var name repend aliases [name alias] ] sym: decorate-symbol name id: 1 + ((length? symbols) / 2) repend symbols [name reduce [sym id]] repend sym-table [ to set-word! sym 'word/load mold name ] new-line skip tail sym-table -3 on ] ] get-symbol-id: func [name [word!]][ second select symbols name ] add-global: func [name [word!]][ unless any [ local-word? name find globals name ][ repend globals [name 'unset!] ] ] push-call: func [name [word! tag!]][ append expr-stack name ] pop-call: does [ remove back tail expr-stack ] add-context: func [ctx [block!] /local name][ append contexts name: decorate-series-var 'ctx append/only contexts ctx name ] push-context: func [ctx [block!] /local name][ append ctx-stack name: add-context ctx name ] pop-context: does [ clear back tail ctx-stack ] find-contexts: func [name [word!]][ ctx: tail ctx-stack while [not head? ctx][ ctx: back ctx if find select contexts ctx/1 name [return ctx/1] ] none ] to-context-spec: func [spec [block!]][ spec: copy spec forall spec [spec/1: to set-word! spec/1] append spec none make object! spec ] iterator-pending?: does [ not empty? intersect expr-stack iterators ] get-obj-base: func [name [any-word!]][ either local-word? name [func-objs][objects] ] get-obj-base-word: func [name [any-word!]][ either local-word? name ['func-objs]['objects] ] find-proto: func [obj [block!] fun [word!] /local proto o multi?][ if proto: obj/4 [ all [ multi?: 2 = length? proto ;-- multiple inheritance case in proto/1 fun in proto/2 fun return obj/1 ;-- method redefined in spec ] if in proto/1 fun [return obj/1] ;-- check prototype if o: find-proto find objects proto/1 fun [return o] ;-- recurse into previous prototypes unless proto/2 [return none] ;-- finish if simple inheritance case if in proto/2 fun [return proto/2] ;-- check prototype if o: find-proto find objects proto/2 fun [return o] ;-- recurse into previous prototypes ] none ] object-access?: func [path [series!]][ either path/1 = 'self [ bind? path/1 ][ attempt [do head insert copy/part to path! path (length? path) - 1 get-obj-base-word path/1] ] ] is-object?: func [expr][ unless find [word! get-word! path!] type?/word expr [return none] attempt [do join obj-stack expr] ] obj-func-call?: func [name [any-word!] /local obj][ if any [rebol-gctx = obj: bind? name find shadow-funcs obj][return no] select objects obj ] obj-func-path?: func [path [path!] /local search base fpath symbol found? fun origin name obj][ either path/1 = 'self [ found?: bind? path/1 path: copy path path/1: pick find objects found? -1 fun: head insert copy path 'objects fpath: head clear next copy path ][ search: [ fpath: head insert copy path base until [ ;-- evaluate nested paths from longer to shorter remove back tail fpath any [ tail? next fpath object? found?: attempt [do fpath] ;-- path evaluates to an object: found! ] ] ] base: get-obj-base-word path/1 do search ;-- check if path is an absolute object path if all [not found? 1 < length? obj-stack][ base: obj-stack do search ;-- check if path is a relative object path unless found? [return none] ;-- not an object access path ] fun: append copy fpath either base = obj-stack [ ;-- extract function access path without refinements pick path 1 + (length? fpath) - (length? obj-stack) ][ pick path length? fpath ] unless function! = attempt [do fun][return none] ;-- not a function call remove fpath ;-- remove 'objects prefix ] obj: find objects found? origin: find-proto obj last fun name: either origin [select objects origin][obj/2] symbol: decorate-obj-member first find/tail fun fpath name either find functions symbol [ fpath: next find path last fpath ;-- point to function name reduce [ either 1 = length? fpath [fpath/1][copy fpath] symbol obj/2 ;-- object instance ctx name ] ][ none ] ] push-locals: func [symbols [block!]][ append/only locals-stack symbols ] pop-locals: does [ also last locals-stack remove back tail locals-stack ] literal-first-arg?: func [spec [block!]][ parse spec [ any [ word! (return no) | lit-word! (return yes) | /local (return no) | skip ] ] no ] infix?: func [pos [block! paren!] /local specs][ all [ not tail? pos word? pos/1 specs: select functions pos/1 'op! = specs/1 not all [ ;-- check if a literal argument is not expected word? pos/-1 specs: select functions pos/-1 literal-first-arg? specs/3 ;-- literal arg needed, disable infix mode ] ] ] convert-types: func [spec [block!] /local value][ forall spec [ if spec/1 = /local [break] ;-- avoid processing local variable if all [ block? value: spec/1 not find [integer! logic!] value/1 ][ value/1: decorate-type either value/1 = 'any-type! ['value!][value/1] ] ] ] rewrite-locals: func [code [block!] /local rule pos word ctx][ parse code rule: [ some [ 'stack/push pos: skip ( if #"~" = first word: form pos/1 [ if ctx: find-contexts word: to word! next word [ change/part back pos reduce [ 'word/get-local ctx get-word-index word ] 2 new-line back pos yes ] ] ) | into rule | skip ] ] ] check-invalid-call: func [name [word!]][ if all [ find [exit return] name empty? locals-stack ][ pc: back pc throw-error "EXIT or RETURN used outside of a function" ] ] check-redefined: func [name [word!] /local pos][ if pos: find functions name [ remove/part pos 2 ;-- remove previous function definition ] if pos: find get-obj-base name name [ pos/1: none ] ] check-func-name: func [name [word!] /local new pos][ if find functions name [ new: to word! append mold/flat name get-counter either pos: find-ssa name [ pos/2: new ][ repend ssa-names [name new] ] name: new ] name ] check-cloned-function: func [new [word!] /local name alter entry pos][ if all [ get-word? pc/1 name: to word! pc/1 all [ alter: get-prefix-func name entry: find functions alter name: alter ] ][ if alter: select-ssa name [ entry: find functions alter ] repend functions [new entry/2] either pos: find-ssa new [ ;-- add the real function name as alias pos/2: name ][ repend ssa-names [new name] ] ] ] check-new-func-name: func [path [path!] symbol [word!] ctx [word!] /local name][ if any [ set-word? name: pc/-1 all [lit-word? name 'set = pc/-2] ][ name: to word! name repend functions [name append select functions symbol ctx] either pos: find-ssa name [ ;-- add the real function name as alias pos/2: symbol ][ repend ssa-names [name symbol] ] ] ] check-spec: func [spec [block!] /local symbols value pos stop locals return?][ symbols: make block! length? spec locals: 0 unless parse spec [ opt string! any [ pos: /local (append symbols 'local) some [ pos: word! ( append symbols to word! pos/1 locals: locals + 1 ) pos: opt block! pos: opt string! ] | set-word! ( if any [return? pos/1 <> return-def][stop: [end skip]] return?: yes ;-- allow only one return: statement ) stop pos: block! opt string! | [ [word! | lit-word! | get-word!] opt block! opt string! | refinement! opt string! ] (append symbols to word! pos/1) ] ][ throw-error ["invalid function spec block:" mold pos] ] forall spec [ if all [ word? spec/1 find next spec spec/1 ][ pc: skip pc -2 throw-error ["duplicate word definition:" spec/1] ] ] reduce [symbols locals] ] make-refs-table: func [spec [block!] /local mark pos arity arg-rule list ref args][ arity: 0 arg-rule: [word! | lit-word! | get-word!] parse spec [ any [ arg-rule (arity: arity + 1) | mark: refinement! (pos: mark) break | skip ] ] if all [pos pos/1 <> /local][ list: make block! 8 ref: 0 parse pos [ some [ pos: refinement! opt string! ( ref: ref + 1 if pos/1 = /local [return reduce [list arity]] repend list [pos/1 ref 0] args: 0 ) | arg-rule opt block! opt string! ( change back tail list args: args + 1 ;@@ one argument by refinement max!! ) | set-word! break ] ] ] reduce [list arity] ] get-prefix-func: func [name [word!] /local path word ctx][ if 1 < length? obj-stack [ path: copy obj-stack while [1 < length? path][ if all [word: in do path name function! = get word][ return prefix-func/with name path ] remove back tail path ] ] if all [ ;-- check for method case during function compilation stage container-obj? ctx: obj-func-call? name ][ return decorate-obj-member name ctx ] name ] add-function: func [name [word!] spec [block!] /type kind [word!] /local refs arity][ set [refs arity] make-refs-table spec repend functions [name reduce [any [kind 'function!] arity spec refs]] ] fetch-functions: func [pos [block!] /local name type spec refs arity][ name: to word! pos/1 if find functions name [exit] ;-- mainly intended for 'make (hardcoded) switch type: pos/3 [ native! [if find intrinsics name [type: 'intrinsic!]] action! [append actions name] op! [repend op-actions [name to word! pos/4]] ] spec: either pos/3 = 'op! [ third select functions to word! pos/4 ][ clean-lf-deep pos/4/1 ] set [refs arity] make-refs-table spec repend functions [name reduce [type arity spec refs]] ] emit-block: func [ blk [any-block!] /sub level [integer!] /bind ctx [word!] /local class name item value word action type binding ][ if path? blk [class: 'path] unless sub [ emit-open-frame 'append emit to set-word! name: decorate-series-var any [class 'blk] emit append to path! any [class 'block] 'push* emit max 1 length? blk insert-lf -3 ] level: 0 forall blk [ item: blk/1 either any-block? :item [ type: either all [path? item get-word? item/1][ item/1: to word! item/1 ;this is workaround of missing get-path! in R2 'get-path ][type? :item] emit-open-frame 'append emit to lit-path! reduce [to word! form type 'push*] emit max 1 length? item insert-lf -2 level: level + 1 either bind [ emit-block/sub/bind to block! item level ctx ][ emit-block/sub to block! item level ] level: level - 1 emit-close-frame emit 'block/append* insert-lf -1 emit 'stack/keep ;-- reset stack, but keep block as last value insert-lf -1 ][ if :item = #get-definition [ ;-- temporary directive value: select extracts/definitions blk/2 change/only/part blk value 2 item: blk/1 ] action: 'push value: case [ unicode-char? :item [ value: item item: #"_" ;-- placeholder just to pass the char! type to item to integer! next value ] any-word? :item [ add-symbol word: to word! clean-lf-flag item value: decorate-symbol word either all [bind local-word? to word! :item][ action: 'push-local reduce [ctx get-word-index/with to word! :item ctx] ][ either binding: find-binding :item [ action: 'push-local binding ][ value ] ] ] issue? :item [ add-symbol word: to word! form item decorate-symbol word ] find [string! file! url!] type?/word :item [ emit [tmp:] insert-lf -1 emit-load-string item new-line back tail output off 'tmp ] find [logic! unset! datatype!] type?/word :item [ to word! form :item ] none? :item [ [] ;-- no argument ] 'else [ item ] ] either float-special? :item [ emit 'float/push64 emit-fp-special item insert-lf -3 ][ either decimal? :item [ emit 'float/push64 emit-float item insert-lf -3 ][ emit to path! reduce [to word! form type? :item action] emit value insert-lf -1 - either block? value [length? value][1] ] ] emit 'block/append* insert-lf -1 unless tail? next blk [ emit 'stack/keep ;-- reset stack, but keep block as last value insert-lf -1 ] ] ] unless sub [emit-close-frame] name ] emit-eval-path: func [/set][ emit 'actions/eval-path* emit either set ['true]['false] insert-lf -2 ] emit-path: func [ path [path! set-path!] set? [logic!] alt? [logic!] /local value mark assign original ][ value: path/1 assign: [ either alt? [ ;-- object path (fallback case) emit [stack/push stack/arguments - 1] ;-- get arguments just below the stack record insert-lf -4 ][ comp-expression ;-- fetch assigned value (normal case) ] emit-eval-path/set emit-close-frame ] switch type?/word original: value [ word! [ add-symbol value: to word! clean-lf-flag value case [ head? path [ emit-get-word value original ] all [set? tail? next path][ emit-open-frame 'eval-set-path emit-path back path set? alt? emit-push-word value value do assign ] 'else [ emit-open-frame 'select emit-path back path set? alt? emit-push-word value value emit-action/with 'select [-1 -1 -1 -1 -1 -1 -1 -1] emit-close-frame ] ] ] get-word! [ either all [set? tail? next path][ emit-open-frame 'poke emit-path back path set? alt? emit-get-word to word! value original emit copy/deep [unless stack/top-type? = TYPE_INTEGER] ;-- choose action at run-time insert-lf -4 mark: tail output ;-- SELECT action emit [stack/pop 1] ;-- overwrite the get-word on stack top insert-lf -2 emit-open-frame 'find emit-path back path set? alt? emit-get-word to word! value original emit-action/with 'find [-1 -1 -1 -1 -1 -1 -1 -1 -1 -1] emit-action 'index? emit [stack/pop 2] insert-lf -2 emit [integer/push 1] insert-lf -2 emit-action 'add emit-close-frame convert-to-block mark do assign ][ emit-open-frame 'pick-select emit-path back path set? alt? emit-get-word to word! value original emit copy/deep [either stack/top-type? = TYPE_INTEGER] ;-- choose action at run-time insert-lf -4 mark: tail output ;-- PICK action emit-action 'pick convert-to-block mark mark: tail output ;-- SELECT action emit-action/with 'select [-1 -1 -1 -1 -1 -1 -1 -1] convert-to-block mark emit-close-frame ] ] integer! [ either all [set? tail? next path][ emit-open-frame 'eval-set-path emit-path back path set? alt? emit compose [integer/push (value)] insert-lf -2 do assign ][ emit-open-frame 'pick emit-path back path set? alt? emit compose [integer/push (value)] insert-lf -2 emit-action 'pick emit-close-frame ] ] string! [ --not-implemented-- ] ] ] emit-path-func: func [body [block!] octx [word!] cnt [integer!] /local pos f-name rule arity name][ pos: body body: copy pos clear pos if all [1 = length? body body/1 = 'stack/reset][clear body] rewrite-locals body name: either pos: find body 'pos [ either body = [ stack/push pos stack/reset ][ clear body 2 ][ insert body [ pos: stack/arguments ] 4 ] ][2] if #"~" <> first form name: pick body name [ name: [words/_anon] ] if all [not empty? body 'stack/unwind = last body][ change/only back tail body 'stack/unwind-last new-line back tail body yes ] unless any [empty? body 1 = length? body][ arity: 0 parse body rule: [ some [ 'stack/push 'pos pos: '+ ( arity: arity + 1 either arity = 1 [pos: remove/part pos 2][pos/2: arity - 1] ) :pos | into rule | skip ] ] redirect-to declarations [ f-name: decorate-func to word! join "~path" cnt emit reduce [to set-word! f-name 'func [octx [node!] /local pos] body] insert-lf -4 ] emit compose [ stack/defer-call (name) as-integer (to get-word! f-name) (arity) (octx) ] f-name ] ] emit-dynamic-path: func [ body [block!] /local path pname idx mark saved cnt frame? octx ][ octx: pick [octx null] to logic! all [ not empty? locals-stack container-obj? ] path: first paths-stack redirect-to literals [pname: emit-block path] if frame?: all [ not emit-path-func body octx cnt: get-counter not empty? expr-stack find [ switch case] last expr-stack ][ emit-open-frame 'dyn-path ;-- wrap it in a stack frame in this case ] emit-get-word path/1 path/1 insert-lf -2 saved: output forall path [ emit [either stack/func?] insert-lf -2 idx: (index? path) - 1 emit compose/deep [[stack/push-call (pname) (idx) 0 (octx)]] either tail? next path [ emit [[stack/adjust]] ][ mark: tail output unless head? path [ emit [ stack/top: stack/top - 1 copy-cell stack/top stack/top - 1 ] ] emit-open-frame 'eval-path emit [stack/push stack/arguments - 1] insert-lf -4 emit append to path! to word! form type? path/2 'push emit prefix-exec path/2 insert-lf -2 emit-eval-path no emit 'stack/unwind-part insert-lf -1 change/only/part mark mark: copy mark tail output output: mark ] ] remove paths-stack output: saved if frame? [emit-close-frame] ] emit-routine: func [name [word!] spec [block!] /local type cnt offset alter][ emit [stack/reset] declare-variable/init 'r_arg to paren! [as red-value! 0] emit [r_arg: stack/arguments] insert-lf -2 offset: 0 if all [ type: select spec return-def find [integer! logic!] type/1 ][ offset: 1 append/only output append to path! form get type/1 'box ] if alter: select-ssa name [name: alter] emit name cnt: 0 forall spec [ if string? spec/1 [ if tail? remove spec [break] ] if any [spec/1 = /local set-word? spec/1][ spec: head spec break ;-- avoid processing local variable ] unless block? spec/1 [ unless block? spec/2 [ insert/only next spec [red-value!] ] either find [integer! logic!] spec/2/1 [ append/only output append to path! form get spec/2/1 'get ][ emit reduce ['as spec/2/1] ] emit 'r_arg unless head? spec [emit reduce ['+ cnt]] cnt: cnt + 1 ] ] insert-lf negate cnt * 2 + offset + 1 ] redirect-to: func [out [block!] body [block!] /local saved][ saved: output output: out also do body output: saved ] emit-float: func [value [decimal!] /local bin][ bin: IEEE-754/to-binary64 value emit to integer! copy/part bin 4 emit to integer! skip bin 4 ] emit-fp-special: func [value [issue!]][ switch next value [ #INF [emit to integer! #{7FF00000} emit 0] #INF- [emit to integer! #{FFF00000} emit 0] #NaN [emit to integer! #{7FF80000} emit 0] ;-- smallest quiet NaN #0- [emit to integer! #{80000000} emit 0] ] ] comp-literal: func [/inactive /with val /local value char? special? name w make-block type][ value: either with [val][pc/1] ;-- val can be NONE either any [ char?: unicode-char? value special?: float-special? value scalar? :value ][ case [ char? [ emit 'char/push emit to integer! next value insert-lf -2 ] special? [ emit 'float/push64 emit-fp-special value insert-lf -3 ] decimal? :value [ emit 'float/push64 emit-float value insert-lf -3 ] find [refinement! issue! lit-word!] type?/word :value [ add-symbol w: to word! form value type: to word! form type? :value if all [lit-word? :value not inactive][type: 'word] either all [not issue? :value local-word? w][ emit append to path! type 'push-local emit last ctx-stack emit get-word-index w insert-lf -3 ][ emit to path! reduce [type 'push] emit to path! reduce ['exec decorate-symbol w] ;@@ replace by prefix-exec insert-lf -2 ] ] none? :value [ emit 'none/push insert-lf -1 ] any-word? :value [ add-symbol to word! :value emit-push-word :value :value ] 'else [ emit to path! reduce [to word! form type? :value 'push] emit load mold :value insert-lf -2 ] ] ][ make-block: [ redirect-to literals [ value: to block! value either empty? ctx-stack [ emit-block value ][ emit-block/bind value last ctx-stack ] ] ] switch/default type?/word value [ block! [ name: do make-block emit 'block/push emit name insert-lf -2 ] paren! [ name: do make-block emit 'paren/push emit name insert-lf -2 ] path! set-path! [ name: do make-block case [ inactive [ either get-word? pc/1/1 [ emit 'get-path/push ][ emit to path! reduce [to word! form type? pc/1 'push] if path? pc/1 [emit [as red-path!]] ] ] lit-path? pc/1 [ emit 'path/push emit [as red-path!] ] true [ emit to path! reduce [to word! form type? pc/1 'push] if path? pc/1 [emit [as red-path!]] ] ] emit name insert-lf -2 ] string! file! url! [ redirect-to literals [ emit to set-word! name: decorate-series-var 'str insert-lf -1 emit-load-string value ] emit to path! reduce [to word! form type? value 'push] emit name insert-lf -2 ] binary! [] ][ throw-error ["comp-literal: unsupported type" mold value] ] ] unless with [pc: next pc] name ] inherit-functions: func [new [object!] extend [object!] /local symbol name][ ;-- multiple inheritance case foreach word next first extend [ if function! = get in extend word [ symbol: decorate-obj-member word select objects extend repend functions [ name: decorate-obj-member word select objects new select functions symbol ] append bodies name append bodies bind/copy copy/part next find bodies symbol 8 new add-symbol name ] ] ] comp-context: func [ /with word /extend proto [object!] /passive only? [logic!] /locals words ctx spec name id func? obj original body pos entry symbol body? ctx2 new blk list path on-set-info values w defer mark ][ either set-path? original: pc/-1 [ path: original ][ name: to word! original: any [word original] ] words: any [all [proto third proto] make block! 8] ;-- start from existing ctx or fresh list: clear any [list []] values: make block! 8 if proto [proto: reduce [proto]] either body?: block? pc/2 [ parse body: pc/2 [ ;-- collect words from body block some [ (clear list) pos: set-word! ( append list pos/1 ;-- store new word value: pos until [ value: next value any [tail? value not set-word? value/1] ] value: value/1 if all [not only? word? value][ if find logic-words value [value: get value] ] w: to word! pos/1 either entry: find/skip values w 2 [ ;-- store first following value (CONSTRUCT) entry/2: value ][ repend values [w value] ] func?: no ) [func-constructors (func?: yes) | none] ( foreach word list [ either entry: find words word [ if func? [entry/2: function!] ][ append words word append words either func? [function!][none] ] ] ) | skip ] ] spec: make block! (length? words) / 2 forskip words 2 [append spec to word! words/1] ][ unless extend [ blk: redirect-to literals [ blk: copy/part pc 2 either empty? ctx-stack [ emit-block blk ][ emit-block/bind blk last ctx-stack ] ] pos: tail output emit-open-frame 'do ;-- defer it to runtime evaluation emit reduce ['block/push blk] insert-lf -2 emit-native 'do emit-close-frame pc: skip pc 2 defer: copy pos clear pos return defer ] obj: find objects proto/1 ;-- simple inheritance case spec: next first obj/1 words: third obj/1 unless find [context object object!] pc/1 [ unless new: is-object? pc/2 [ comp-call 'make select functions 'make ;-- fallback to runtime creation exit ] ctx2: select objects new ;-- multiple inheritance case spec: union spec next first new insert proto new forskip words 2 [ if word: in new words/1 [words/2: get in new words/1] ] foreach [name value] third new [ unless find words name [repend words [name value]] ] ] ] redirect-to literals [ ;-- store spec and body blocks ctx: add-context spec emit compose [ (to set-word! ctx) _context/make (blk: emit-block spec) no yes ;-- build context ] insert-lf -5 ] symbol: either path [ctx][ if pos: find get-obj-base name name [pos/1: none] ;-- unbind word with previous object get pick [name ctx] to logic! any [ ;-- ctx for object's word, else name rebol-gctx = obj: bind? original find shadow-funcs obj ] ] repend objects [ ;-- register shadow object symbol ;-- object access word obj: make object! words ;-- shadow object ctx ;-- object's context name id: get-counter ;-- unique object ID proto ;-- optional prototype object none ;-- [index locals] for on-change* ] on-set-info: back tail objects either path [ do reduce [to set-path! join obj-stack to path! path obj] ;-- set object in shadow tree ][ unless tail? next obj-stack [ ;-- set object in shadow tree (if sub-object) do reduce [to set-path! join obj-stack name obj] ] ] if body? [bind body obj] unless all [empty? locals-stack not iterator-pending?][ ;-- in a function or iteration block emit compose [ (to set-word! ctx) _context/make (blk) no yes ;-- rebuild context ] insert-lf -5 ] if proto [ if body? [inherit-functions obj last proto] emit reduce ['object/duplicate select objects last proto ctx] insert-lf -3 ] if all [not body? not passive][ inherit-functions obj new emit reduce ['object/transfer ctx2 ctx] insert-lf -3 ] emit-src-comment/with none rejoin [mold pc/-1 " context " mold spec] emit-open-frame 'body case [ passive [ ;-- CONSTRUCT support bind values obj foreach [name value] values [ emit-open-frame 'set emit-push-word name name comp-literal/with value emit-native/with 'set [-1] emit-close-frame ] pc: skip pc 2 ] all [body? not empty? pc/2][ append obj-stack any [path name] pc: next pc comp-next-block clear skip tail obj-stack either path [negate length? path][-1] ] 'else [ pc: skip pc 2 ] ] pos: none defer: reduce ['object/init-push ctx id] ;-- deferred emission new-line defer yes if any [path pos: find spec 'on-change*][ if pos [ pos: (index? pos) - 1 ;-- 0-based contexts arrays entry: find functions decorate-obj-member 'on-change* ctx unless zero? locals: second check-spec entry/2/3 [ locals: locals + 1 ;-- account for /local ] change/only on-set-info reduce [pos locals] ;-- cache values repend defer ['object/init-on-set ctx pos locals] new-line skip defer 3 yes ] ] emit 'stack/revert insert-lf -1 defer ] comp-object: :comp-context comp-construct: has [only? with? obj][ only?: with?: no if all [ path? pc/1 not parse pc/1 [skip 2 ['only (only?: yes) | 'with (with?: yes)]] ;@@ handle duplicates ][ throw-error "Invalid CONSTRUCT refinement" ] either with? [ unless obj: is-object? pc/3 [--not-implemented--] also comp-context/passive/extend only? obj pc: next pc ][ comp-context/passive only? ] ;-- return object deferred block ] comp-try: does [ unless block? pc/1 [ pc: back pc comp-word ;-- fallback to interpreter exit ] emit [catch RED_ERROR] insert-lf -2 body: comp-sub-block 'try if body/1 = 'stack/reset [remove body] mark: tail output emit-open-frame 'try insert body mark clear mark append body [ stack/unwind ] ] comp-boolean-expressions: func [type [word!] test [block!] /local list body][ list: back tail comp-chunked-block if empty? head list [ emit set-last-none insert-lf -1 exit ] bind test 'body ;-- most nested test first (identical for ANY and ALL) body: compose/deep [if logic/false? [(set-last-none)]] new-line body yes insert body list/1 ;-- emit expressions tree from leaf to root while [not head? list][ list: back list insert/only body 'stack/reset new-line body yes body: reduce test new-line body yes insert body list/1 ] emit-open-frame type emit body emit-close-frame ] comp-any: does [ either block? pc/1 [ comp-boolean-expressions 'any ['if 'logic/false? body] ][ emit-open-frame 'any comp-expression emit-native 'any emit-close-frame ] ] comp-all: does [ either block? pc/1 [ comp-boolean-expressions 'all [ 'either 'logic/false? set-last-none body ] ][ emit-open-frame 'all comp-expression emit-native 'all emit-close-frame ] ] comp-if: does [ emit-open-frame 'if comp-expression/close-path emit compose/deep [ either logic/false? [(set-last-none)] ] comp-sub-block 'if-body ;-- compile TRUE block emit-close-frame ] comp-unless: does [ emit-open-frame 'unless comp-expression/close-path emit [ either logic/false? ] comp-sub-block 'unless-body ;-- compile FALSE block append/only output set-last-none emit-close-frame ] comp-either: does [ emit-open-frame 'either comp-expression/close-path emit [ either logic/true? ] comp-sub-block 'either-true ;-- compile TRUE block comp-sub-block 'either-false ;-- compile FALSE block emit-close-frame ] comp-loop: has [name set-name mark][ depth: depth + 1 if depth > max-depth [max-depth: depth] set [name set-name] declare-variable join "i" depth comp-expression/close-path ;@@ optimize case for literal counter emit compose [(set-name) integer/get*] insert-lf -2 emit compose/deep [ either (name) <= 0 [(set-last-none)] ] mark: tail output emit [ until ] new-line skip tail output -3 off push-call 'loop comp-sub-block 'loop-body ;-- compile body pop-call repend last output [ set-name name '- 1 name '= 0 ] new-line skip tail last output -3 on new-line skip tail last output -7 on depth: depth - 1 convert-to-block mark ] comp-until: does [ emit [ until ] push-call 'until comp-sub-block 'until-body ;-- compile body pop-call append/only last output 'logic/true? new-line back tail last output on ] comp-while: does [ emit [ while ] push-call 'while comp-sub-block 'while-condition ;-- compile condition append/only last output 'logic/true? new-line back tail last output on comp-sub-block 'while-body ;-- compile body pop-call ] comp-repeat: has [name word cnt set-cnt lim set-lim action][ add-symbol word: pc/1 add-global word name: decorate-symbol word action: either local-word? word [ 'natives/repeat-set ;-- set the value slot on stack ][ '_context/set-integer ;-- set the word value in global context ] depth: depth + 1 if depth > max-depth [max-depth: depth] emit-stack-reset pc: next pc comp-expression/close-path ;-- compile 2nd argument set [cnt set-cnt] declare-variable join "r" depth ;-- integer counter set [lim set-lim] declare-variable join "rlim" depth ;-- counter limit emit reduce either local-word? word [ ;@@ only integer! argument supported [ set-lim 'natives/repeat-init* name set-cnt 0 ] ][ [ set-lim 'integer/get* '_context/set-integer name lim set-cnt 0 ] ] insert-lf -2 insert-lf -5 insert-lf -7 emit-stack-reset emit-open-frame 'repeat emit compose/deep [ while [ ;-- set word 1 + get word ;-- TBD: set word next get word (set-cnt) (cnt) + 1 ;-- (get word) < value ;-- TBD: not tail? get word (cnt) <= (lim) ] ] new-line last output on new-line skip tail last output -3 on new-line skip tail last output -6 on push-call 'repeat comp-sub-block 'repeat-body pop-call insert last output reduce [action name cnt] new-line last output on emit-close-frame depth: depth - 1 ] comp-forever: does [ pc: back pc change/part pc [while [true]] 1 ] comp-foreach: has [word blk name cond ctx][ either block? pc/1 [ ;TBD: raise error if not a block of words only foreach word blk: pc/1 [ add-symbol word add-global word ] name: redirect-to literals [ either ctx: find-contexts to word! blk/1 [ emit-block/bind blk ctx ][ emit-block blk ] ] ][ add-symbol word: pc/1 add-global word ] pc: next pc comp-expression/close-path ;-- compile series argument ;TBD: check if result is any-series! emit 'stack/keep insert-lf -1 either blk [ cond: compose [natives/foreach-next-block (length? blk)] emit compose [block/push (name)] ;-- block argument ][ cond: compose [natives/foreach-next] emit-push-word word word ;-- word argument ] insert-lf -2 emit-open-frame 'foreach emit compose/deep [ while [(cond)] ] push-call 'foreach comp-sub-block 'foreach-body ;-- compile body pop-call emit-close-frame ] comp-forall: has [word name][ ;TBD: check if word argument refers to any-series! name: pc/1 word: decorate-symbol name emit-get-word name name ;-- save series (for resetting on end) emit-push-word name name ;-- word argument pc: next pc emit-open-frame 'forall emit copy/deep [ ;-- copy/deep required for R/S lines injection while [natives/forall-loop] ] push-call 'forall comp-sub-block 'forall-body ;-- compile body pop-call append last output [ ;-- inject at tail of body block natives/forall-next ;-- move series to next position ] emit [ natives/forall-end ;-- reset series stack/unwind ] ] comp-func-body: func [ name [word!] spec [block!] body [block!] symbols [block!] locals-nb [integer!] /local init locals blk args? ][ push-locals copy symbols ;-- prepare compiled spec block forall symbols [symbols/1: decorate-symbol symbols/1] locals: append copy [/local ctx] symbols blk: either container-obj? [head insert copy locals [octx [node!]]][locals] emit reduce [to set-word! decorate-func/strict name 'func blk] insert-lf -3 comp-sub-block/with 'func-body body ;-- compile function's body ;-- Function's prolog -- pop-locals init: make block! 4 * length? symbols append init compose [ ;-- point context values series to stack ctx: TO_CTX(to paren! last ctx-stack) push ctx/values ;-- save previous context values pointer ctx/values: as node! stack/arguments ] new-line skip tail init -4 on args?: yes forall symbols [ ;-- assign local variable to Red arguments append init to set-word! symbols/1 new-line back tail init on if symbols/1 = '~local [args?: no] ;-- signal end of arguments if all [ args? blk: emit-type-checking symbols/1 spec ][ append init blk append init (index? symbols) - 1 ;-- index of argument for the type-checker ] either head? symbols [ append/only init 'stack/arguments ][ repend init [symbols/-1 '+ 1] ] ] unless zero? locals-nb [ ;-- init local words on stack append init compose [ _function/init-locals (1 + locals-nb) ] ] name: decorate-symbol name if find symbols name [name: decorate-exec-ctx name] append init compose [ ;-- body stack frame stack/mark-native words/_body ] ;-- Function's epilog -- append last output compose [ stack/unwind-last ;-- closing body stack frame, and propagating last value ctx/values: as node! pop ;-- restore context values pointer ] new-line skip tail last output -4 yes insert last output init ] collect-words: func [spec [block!] body [block!] /local pos end ignore words word rule][ if pos: find spec /extern [ either end: find next pos refinement! [ ignore: copy/part next pos end remove/part spec pos end ][ ignore: copy next pos clear pos ] unless empty? intersect ignore spec [ pc: skip pc -2 throw-error ["duplicate word definition in function:" pc/1] ] ] foreach item spec [ ;-- add all arguments to ignore list if find [word! lit-word! get-word!] type?/word item [ unless ignore [ignore: make block! 1] append ignore to word! :item ] ] words: make block! 1 make-local: [ unless any [ all [ignore find ignore word] find words word ][ append words word ] ] parse body rule: [ any [ pos: set-word! ( word: to word! pos/1 do make-local ) | pos: word! ( if all [ find word-iterators pos/1 pos/2 ][ foreach word any [ all [block? pos/2 pos/2] reduce [pos/2] ] make-local ] ) | path! | lit-path! | set-path! | into rule | skip ] ] unless empty? words [ unless find spec /local [append spec /local] append spec words ] ] comp-func: func [ /collect /does /has /local name word spec body symbols locals-nb spec-blk body-blk ctx src-name original global? path obj shadow defer ][ original: pc/-1 case [ set-path? original [ path: original either obj: object-access? path [ do reduce [join to set-path! get-obj-base-word path/1 path 'function!] ;-- update shadow object info obj: find objects obj name: to word! rejoin [any [obj/-1 obj/2] #"~" last path] add-symbol name ][ name: generate-anon-name ;-- undetermined function assignment case ] ] find [set-word! lit-word!] type?/word :original [ src-name: to word! original unless global?: all [lit-word? :original pc/-2 = 'set][ src-name: get-prefix-func src-name ] name: check-func-name src-name add-symbol word: to word! clean-lf-flag name unless any [ local-word? name 1 < length? obj-stack ][ add-global word ] ] 'else [name: generate-anon-name] ;-- unassigned function case ] pc: next pc set [spec body] pc case [ collect [collect-words spec body] does [body: spec spec: make block! 1 pc: back pc] has [spec: head insert copy spec /local] ] set [symbols locals-nb] check-spec spec add-function name spec redirect-to literals [ ;-- store spec and body blocks push-locals symbols spec-blk: emit-block spec ctx: push-context copy symbols emit compose [ (to set-word! ctx) _context/make (spec-blk) yes no ;-- build context with value on stack ] insert-lf -4 body-blk: either job/red-store-bodies? [emit-block/bind body ctx]['null] pop-locals ] repend shadow-funcs [ ;-- register a new shadow context decorate-func/strict name shadow: to-context-spec symbols ctx ] bind-function body shadow defer: reduce [ '_function/push spec-blk body-blk ctx 'as 'integer! to get-word! decorate-func/strict name either 1 < length? obj-stack [select objects do obj-stack]['null] ] new-line defer yes new-line skip tail defer -4 no repend bodies [ ;-- save context for deferred function compilation name spec body symbols locals-nb copy locals-stack copy ssa-names copy ctx-stack all [not global? 1 < length? obj-stack next first do obj-stack] ;-- save optional wrapping object ] pop-context pc: skip pc 2 defer ] comp-function: does [ comp-func/collect ] comp-does: does [ comp-func/does ] comp-has: does [ comp-func/has ] comp-routine: has [name word spec spec* body spec-blk body-blk original ctx][ name: get-prefix-func check-func-name to word! original: pc/-1 add-symbol word: to word! clean-lf-flag name add-global word pc: next pc set [spec body] pc preprocess-strings body ;-- encode strings for Red/System check-spec spec add-function/type name spec 'routine! process-calls body ;-- process #call directives if ctx: find-binding original [ process-routine-calls body ctx/1 spec select objects ctx/1 ] clear find spec*: copy spec /local spec-blk: redirect-to literals [emit-block spec*] body-blk: either job/red-store-bodies? [ redirect-to literals [emit-block body] ][ 'null ] convert-types spec either no-global? [ repend bodies [ ;-- saved for deferred inclusion name spec body none none none none none none ] ][ redirect-to literals [ emit reduce [to set-word! name 'func] insert-lf -2 append/only output spec append/only output body ] ] pc: skip pc 2 compose [ routine/push (spec-blk) (body-blk) as integer! (to get-word! name) ] ] comp-exit: does [ pc: next pc emit [ copy-cell unset-value stack/arguments ] emit-exit-function ] comp-return: does [ comp-expression emit-exit-function ] comp-self: func [original [any-word!] /local obj][ either rebol-gctx = obj: bind? original [ pc: back pc ;-- backtrack and process word again comp-word/thru ][ obj: find objects obj either obj/5 [ emit reduce ['object/push obj/2 obj/3 obj/5/1 obj/5/2] ;-- on-set present case insert-lf -5 ][ emit reduce ['object/init-push obj/2 obj/3] insert-lf -3 ] ] ] comp-switch: has [mark name arg body list cnt pos default? value][ if path? pc/-1 [ foreach ref next pc/-1 [ switch/default ref [ default [default?: yes] ;all [] ][throw-error ["SWITCH has no refinement called" ref]] ] ] push-call 'switch emit-open-frame 'switch mark: tail output ;-- pre-compile the SWITCH argument comp-expression/close-path arg: copy mark clear mark body: pc/1 unless block? body [ throw-error "SWITCH expects a block as second argument" ] list: make block! 4 cnt: 1 parse body [ ;-- build a [value index] pairs list any [ value: skip (repend list [value/1 cnt]) to block! skip (cnt: cnt + 1) ] ] name: redirect-to literals [emit-block list] emit-open-frame 'select ;-- SWITCH lookup frame emit compose [block/push (name)] insert-lf -2 emit arg emit [integer/push 2] ;-- /skip 2 insert-lf -2 emit-action/with 'select [-1 0 -1 -1 -1 2 -1 -1] ;-- select/only/skip emit-close-frame emit [switch integer/get-any*] insert-lf -2 clear list cnt: 1 parse body [ ;-- build SWITCH cases any [skip to block! pos: ( mark: tail output comp-sub-block/with 'switch-body pos/1 pc: back pc ;-- restore PC position (no block consumed) repend list [cnt mark/1] clear mark cnt: cnt + 1 ) skip] ] unless empty? body [pc: next pc] append list 'default ;-- process default case either default? [ comp-sub-block 'switch-default ;-- compile default block append/only list last output clear back tail output ][ append/only list copy [0] ;-- placeholder for keeping R/S compiler happy ] append/only output list emit-close-frame pop-call ] comp-case: has [all? path saved list mark body chunk][ if path? path: pc/-1 [ either path/2 = 'all [all?: yes][ throw-error ["CASE has no refinement called" path/2] ] ] unless block? pc/1 [ throw-error "CASE expects a block as argument" ] saved: pc pc: pc/1 list: make block! length? pc push-call 'case while [not tail? pc][ ;-- precompile all conditions and cases mark: tail output comp-expression/close-path ;-- process condition append/only list copy mark clear mark case [ tail? pc [ throw-error "CASE is missing a value" ] block? pc/1 [ append/only list comp-sub-block 'case ;-- process case block clear back tail output ] 'else [ chunk: tail output comp-expression/no-infix/root all [ ;-- fixes #512 not empty? chunk chunk/1 <> 'stack/reset insert/only chunk 'stack/reset ] append/only list copy chunk clear chunk ] ] ] pc: next saved either all? [ foreach [test body] list [ ;-- /all mode emit-open-frame 'case emit test emit compose/deep [ either logic/false? [(set-last-none)] ] append/only output body emit-close-frame ] ][ ;-- default single selection mode list: skip tail list -2 body: reduce ['either 'logic/true? list/2 set-last-none] new-line body yes insert body list/1 ;-- emit expressions tree from leaf to root while [not head? list][ list: skip list -2 insert/only body 'stack/reset new-line body yes body: reduce ['either 'logic/true? list/2 body] new-line body yes insert body list/1 ] emit-open-frame 'case emit body emit-close-frame ] pop-call ] comp-reduce: has [list into?][ push-call 'reduce into?: path? pc/-1 unless block? pc/1 [ emit-open-frame 'reduce comp-expression ;-- compile not-literal-block argument if into? [comp-expression] ;-- optionally compile /into argument emit-native/with 'reduce reduce [pick [1 -1] into?] emit-close-frame pop-call exit ] list: either empty? pc/1 [ pc: next pc ;-- pass the empty source block make block! 1 ][ comp-chunked-block ;-- compile literal block ] either path? pc/-2 [ ;-- -2 => account for block argument comp-expression ;-- compile /into argument ][ emit 'block/push-only* ;-- create a fresh new block on stack only emit max 1 length? list insert-lf -2 ] emit-open-frame 'reduce foreach chunk list [ emit chunk either into? [ emit 'block/insert-thru insert-lf -1 ][ emit 'block/append-thru insert-lf -1 ] emit-stack-reset ] emit-close-frame pop-call ] comp-set: has [name][ either lit-word? pc/1 [ name: to word! pc/1 either local-bound? pc/1 [ pc: next pc comp-local-set name ][ comp-set-word/native ] ][ if block? pc/1 [ ;-- if words are literals, register them foreach w pc/1 [ add-symbol w: to word! w unless local-word? w [ add-global w ;-- register it as global ] ] ] emit-open-frame 'set comp-expression comp-expression emit-native/with 'set [-1] emit-close-frame ] ] comp-get: has [symbol original][ either lit-word? original: pc/1 [ add-symbol symbol: to word! original either path? pc/-1 [ ;@@ add check for validaty of refinements emit-get-word/any? symbol original ][ emit-get-word symbol original ] pc: next pc ][ emit-open-frame 'get comp-expression emit-native/with 'get [-1] emit-close-frame ] ] comp-path: func [ root? [logic!] /set? /local path value emit? get? entry alter saved after dynamic? ctx mark obj? fpath symbol obj self? true-blk defer ][ path: copy pc/1 emit?: yes set?: to logic! set? if dynamic?: find path paren! [ ;-- fallback to interpreter if parens found emit-open-frame 'body if set? [ saved: pc pc: next pc comp-expression after: pc pc: saved ] comp-literal pc: back pc unless set? [emit [stack/mark-native words/_body]] ;@@ not clean... emit compose [ interpreter/eval-path stack/top - 1 null null (to word! form set?) no (to word! form root?) ] unless set? [emit [stack/unwind-last]] emit-close-frame pc: either set? [after][next pc] exit ] if all [not set? defer: dispatch-ctx-keywords/with pc/1/1 path/1][ if block? defer [emit defer] exit ] forall path [ ;-- preprocessing path switch/default type?/word value: path/1 [ word! [ if all [not set? not get? entry: find functions value][ if alter: select-ssa value [ entry: find functions alter ] if head? path [ pc: next pc comp-call path entry/2 ;-- call function with refinements exit ] ] ] get-word! [ if head? path [ get?: yes change path to word! path/1 ] ] integer! paren! string! [ if head? path [path-head-error] ] ][ throw-error ["cannot use" mold type? value "value in path:" pc/1] ] ] self?: path/1 = 'self if all [ not any [set? dynamic? find path integer!] set [fpath symbol ctx] obj-func-path? path ][ either get? [ check-new-func-name path symbol ctx ][ pc: next pc comp-call/with fpath functions/:symbol symbol ctx exit ] ] obj?: all [ not any [dynamic? find path integer!] obj: object-access? path ] if set? [ pc: next pc either obj? [ ;-- fetch assigned value earlier unless defer: dispatch-ctx-keywords none [ ;-- detect function/object declaration comp-expression ] ][ defer: dispatch-ctx-keywords none ] if block? defer [emit defer] ] if obj? [ ctx: second obj: find objects obj true-blk: compose/deep pick [ [[word/set-in (ctx) (get-word-index/with last path ctx)]] [[word/get-local (ctx) (get-word-index/with last path ctx)]] ] set? either self? [ emit first true-blk ][ emit compose [ either (emit-deep-check path) (true-blk) ] ] if all [set? obj/5][ ;-- detect on-set callback insert last output reduce [ ;-- save old value 'word/get-local ctx get-word-index/with last path ctx ] repend last output [ 'object/fire-on-set* decorate-symbol first back back tail path decorate-symbol last path ] foreach pos [-9 -6 -3][new-line skip tail last output pos yes] ] ] mark: tail output either any [obj? set? get? dynamic? not parse path [some word!]][ unless self? [ obj?: to logic! obj? emit-path back tail path set? obj? ;-- emit code recursively from tail ] ][ append/only paths-stack path ;-- defer path generation ] if obj? [change/only/part mark copy mark tail output] unless set? [pc: next pc] ] comp-arguments: func [spec [block!] nb [integer!] /ref name [refinement!] /local word paths type][ if ref [spec: find/tail spec name] paths: length? paths-stack repeat i nb [ while [not any-word? spec/1][ ;-- skip attributs and docstrings spec: next spec ] switch type?/word spec/1 [ lit-word! [ either all [ tail? pc all [spec/2 find spec/2 'any-type!] ][ emit 'unset/push ;-- provide unset as placeholder insert-lf -1 ][ type: either all [path? pc/1 get-word? pc/1/1][ 'get-path! ][type?/word pc/1] switch/default type [ get-word! [ add-symbol to word! pc/1 comp-expression ] lit-word! [ add-symbol word: to word! pc/1 emit 'lit-word/push emit decorate-symbol word insert-lf -2 pc: next pc ] word! [ add-symbol word: to word! pc/1 emit-push-word word word ;@@ add specific type checking pc: next pc ] lit-path! [comp-literal/inactive] paren! get-path! [comp-expression] ][ comp-literal ] ] ] get-word! [comp-literal/inactive] word! [comp-expression] ] if paths < length? paths-stack [ if 'stack/unwind = last output [i: i + 1] ;-- count nested argument with path repeat n nb - i + 1 [ emit [stack/push pos +] emit n - 1 insert-lf -4 ] return true ;-- stop compiling new arguments ] spec: next spec ] false ] comp-call: func [ call [word! path!] spec [block!] /with symbol ctx-name [word!] /local item name compact? refs ref? cnt pos ctx mark list offset emit-no-ref args option stop? ][ either spec/1 = 'intrinsic! [ switch any [all [path? call call/1] call] keywords ][ compact?: spec/1 <> 'function! ;-- do not push refinements on stack refs: make block! 1 ;-- refinements storage in compact mode cnt: 0 name: either path? call [call/1][call] name: to word! clean-lf-flag name either all [with not empty? locals-stack][ ;-- only if in a function's body emit reduce [ ;-- special case for path-generated wrapper functions 'stack/mark-func decorate-exec-ctx decorate-symbol name ] insert-lf -2 ][ emit-open-frame name ] comp-arguments spec/3 spec/2 ;-- fetch arguments either compact? [ refs: either spec/4 [ head insert/dup make block! 8 -1 (length? spec/4) / 3 ;-- init with -1 ][ [] ;-- function with no refinements ] if path? call [ cnt: spec/2 ;-- function base arity foreach ref next call [ ref: to refinement! ref unless pos: find/skip spec/4 ref 3 [ throw-error [call/1 "has no refinement called" ref] ] poke refs pos/2 cnt ;-- set refinement's arguments base offset unless stop? [ stop?: comp-arguments/ref spec/3 pos/3 ref ;-- fetch refinement arguments ] cnt: cnt + pos/3 ;-- increase by nb of arguments ] ] ][ ;-- prepare function! stack layout emit-no-ref: [ ;-- populate stack for unused refinement emit [logic/push false] ;-- unused refinement is set to FALSE insert-lf -2 loop args [ emit 'none/push ;-- unused arguments are set to NONE insert-lf -1 ] ] either path? call [ ;-- call with refinements? ctx: copy spec/4 ;-- get a new context block foreach ref next call [ option: to refinement! either integer? ref [form ref][ref] unless pos: find/skip spec/4 option 3 [ throw-error [call/1 "has no refinement called" ref] ] offset: 2 + index? pos poke ctx index? pos true ;-- switch refinement to true in context unless zero? args: pos/3 [ ;-- process refinement's arguments list: make block! 1 ctx/:offset: list ;-- compiled refinement arguments storage mark: tail output unless stop? [ stop?: comp-arguments/ref spec/3 args option ] append/only list copy mark clear mark ] ] forall ctx [ ;-- push context values on stack switch type?/word ctx/1 [ refinement! [ ;-- unused refinement args: ctx/3 do emit-no-ref ] logic! [ ;-- used refinement emit [logic/push true] insert-lf -2 if block? ctx/3 [ foreach code ctx/3 [emit code] ;-- emit pre-compiled arguments ] ] ] ] ][ ;-- call with no refinements if spec/4 [ foreach [ref offset args] spec/4 emit-no-ref ] ] ] switch spec/1 [ native! [emit-native/with name refs] action! [emit-action/with name refs] op! [] routine! [emit-routine any [symbol name] spec/3] function! [ emit decorate-func any [symbol name] insert-lf either with [emit ctx-name -2][-1] ] ] emit-close-frame ] ] comp-local-set: func [name [word!]][ emit-open-frame 'set comp-expression emit [copy-cell stack/arguments] emit decorate-symbol name insert-lf -3 emit-close-frame ] comp-set-word: func [ /native /local name value ctx original obj bound? deep? inherit? proto defer mark start take-frame ][ name: original: pc/1 pc: next pc unless local-word? name: to word! clean-lf-flag name [ add-symbol name add-global name ] if infix? pc [ throw-error "invalid use of set-word as operand" ] if all [not booting? find intrinsics name][ throw-error ["attempt to redefine a keyword:" name] ] bound?: all [ rebol-gctx <> obj: bind? original not find shadow-funcs obj ] deep?: 1 < length? obj-stack mark: tail output take-frame: [start: copy mark clear mark] emit-open-frame 'set either native [ ;-- 1st argument pc: back pc comp-expression ;-- fetch a value ][ unless any [bound? deep?][ emit-push-word name original ;-- push set-word ] ] push-call 'set case [ all [ pc/1 = 'make any [pc/2 = 'object! proto: is-object? pc/2] ][ do take-frame check-redefined name pc: next pc defer: either proto [ comp-context/with/extend original proto ][ comp-context/with original ] ] all [ any [word? pc/1 path? pc/1] do take-frame defer: dispatch-ctx-keywords/with original pc/1 ][] ;-- processing done in dispatch function 'else [ if start [emit start] unless bound? [check-redefined name] check-cloned-function name comp-substitute-expression ;-- fetch a value (2nd argument) ] ] pop-call if block? defer [ ;-- object or function case emit start emit defer ] either native [ emit-native/with 'set [-1] ;@@ refinement not handled yet ][ either all [bound? ctx: select objects obj][ emit 'word/set-in emit either parent-object? obj ['octx][ctx] ;-- optional parametrized context reference (octx) emit get-word-index/with name ctx insert-lf -3 ][ emit 'word/set insert-lf -1 ] ] emit-close-frame ] comp-word: func [/literal /final /thru /local name local? alter emit-word original new ctx defer][ name: to word! original: pc/1 local?: local-bound? original emit-word: [ either lit-word? original [ ;@@ emit-push-word name original ][ either literal [ emit-get-word/literal name original ][ emit-get-word name original ] ] ] if defer: dispatch-ctx-keywords original [ if block? defer [emit defer] exit ] pc: next pc ;@@ move it deeper case [ all [not thru name = 'exit] [comp-exit] all [not thru name = 'return][comp-return] all [not thru name = 'self] [comp-self original] all [ not final not local? name = 'make any-function? pc/1 ][ fetch-functions skip pc -2 ;-- extract functions definitions pc: back pc comp-word/final ] all [ not literal not local? all [ alter: get-prefix-func original entry: find functions alter name: alter ] ][ if alter: select-ssa name [entry: find functions alter] check-invalid-call name either ctx: any [ obj-func-call? original pick entry/2 5 ][ comp-call/with name entry/2 name ctx ][ comp-call name entry/2 ] ] any [ find globals name find-contexts name ][ do emit-word ] 'else [ either job/red-strict-check? [ pc: back pc throw-error ["undefined word" pc/1] ][ do emit-word ] ] ] ] search-expr-end: func [pos [block! paren!]][ if infix? next pos [pos: search-expr-end skip pos 2] pos ] make-func-prefix: func [name [word!]][ load rejoin [ ;@@ cache results locally head remove back tail form functions/:name/1 "s/" name #"*" ] ] check-infix-operators: func [ root? [logic!] /local name op pos end ops spec substitute cnt paths single? ][ if infix? pc [return false] ;-- infix op already processed, ;-- or used in prefix mode. if infix? next pc [ substitute: [ if paths < length? paths-stack [ emit [stack/push pos +] emit cnt insert-lf -4 cnt: cnt + 1 ] ] cnt: 0 pos: pc end: search-expr-end pos ;-- recursive search of expression end ops: make block! 1 pos: end ;-- start from end of expression until [ op: pos/-1 name: any [select op-actions op op] insert ops name ;-- remember ops in left-to-right order emit-open-frame op pos: skip pos -2 ;-- process next previous op pos = pc ;-- until we reach the beginning of expression ] paths: length? paths-stack comp-expression/no-infix ;-- fetch first left operand do substitute pc: next pc forall ops [ paths: length? paths-stack single?: path? pc/1 comp-expression/no-infix ;-- fetch right operand if single? [do substitute] name: ops/1 spec: functions/:name switch/default spec/1 [ function! [emit decorate-func name insert-lf -1] routine! [emit-routine name spec/3] ][ emit make-func-prefix name insert-lf -1 ] emit-close-frame unless tail? next ops [pc: next pc] ;-- jump over op word unless last operand ] return true ;-- infix expression processed ] false ;-- not an infix expression ] process-get-directive: func [ path code [block!] /local obj ctx blk ][ unless path? path [ throw-error ["invalid #get argument:" spec] ] obj: object-access? path ctx: second obj: find objects obj remove/part code 2 blk: [red/word/get-in (decorate-exec-ctx ctx) (get-word-index/with last path ctx)] insert code compose blk ] process-in-directive: func [ path word code [block!] /local obj ctx blk ][ if any [not path? path not any-word? :word][ throw-error ["invalid #in argument:" mold path mold :word] ] append path word obj: object-access? path ctx: second obj: find objects obj remove/part code 3 blk: [red/object/get-word (decorate-exec-ctx ctx) (get-word-index/with word ctx)] insert code compose blk ] process-call-directive: func [ body [block!] global? /local name spec cmd types type arg trash ctx ][ name: body/1 switch/default type?/word name [ word! [name: to word! clean-lf-flag name] path! [set [trash name ctx] obj-func-path? body/1] ][ throw-error ["invalid function name in #call:" mold body] ] if any [ not spec: select functions name not spec/1 = 'function! ][ throw-error ["invalid #call function name:" name] ] either global? [ emit 'red/stack/mark-func emit decorate-exec-ctx decorate-symbol name insert-lf -2 ][ emit-open-frame name ] types: spec/3 body: next body loop spec/2 [ ;-- process arguments types: find/tail types word! unless block? types/1 [ throw-error ["type undefined for" types/1 "in function" name] ] either 1 = length? types/1 [ type: types/1/1 ][ arg: body/1 if word? arg [arg: get arg] type: none foreach value types/1 [ if value = type?/word arg [type: value break] ] unless type [ throw-error ["cannot determine #call argument type:" arg] ] ] cmd: to path! reduce [to word! form get type 'push] if global? [insert cmd 'red] emit cmd insert-lf -1 case [ none? body/1 [ throw-error ["missing argument(s) in #call body"] ] body/1 = 'as [ emit copy/part body 3 body: skip body 3 ] body/1 = 'none [ body: next body ] 'else [ emit body/1 body: next body ] ] ] types: next types ;-- process refinements while [not tail? types][ switch type?/word types/1 [ refinement! [ if types/1 = /local [break] emit [red/logic/push false] insert-lf -2 ] word! [ emit 'red/none/push insert-lf -1 ] set-word! [break] ] types: next types ] name: decorate-func name ;-- function call if global? [name: decorate-exec-ctx name] emit name insert-lf either ctx [emit decorate-exec-ctx ctx -2][-1] either global? [ emit 'red/stack/unwind-last insert-lf -1 emit 'red/stack/reset ][ emit-close-frame emit 'stack/reset ] insert-lf -1 ] comp-directive: has [file saved version mark][ switch pc/1 [ #include [ unless file? file: pc/2 [ throw-error ["#include requires a file argument:" pc/2] ] append include-stk script-path script-path: either all [not booting? relative-path? file][ file: clean-path join any [script-path main-path] file first split-path file ][ none ] unless any [booting? exists? file][ throw-error ["include file not found:" pc/2] ] either find included-list file [ script-path: take/last include-stk remove/part pc 2 ][ saved: script-name insert skip pc 2 #pop-path change/part pc load-source file 2 script-name: saved append included-list file ] true ] #pop-path [ script-path: take/last include-stk pc: next pc ] #system [ unless block? pc/2 [ throw-error "#system requires a block argument" ] process-include-paths pc/2 process-calls pc/2 preprocess-strings pc/2 ;-- encode strings for Red/System mark: tail output emit pc/2 new-line mark on pc: skip pc 2 true ] #system-global [ unless block? pc/2 [ throw-error "#system-global requires a block argument" ] process-include-paths pc/2 preprocess-strings pc/2 ;-- encode strings for Red/System unless sys-global/1 = 'Red/System [ append sys-global copy/deep [Red/System []] ] append sys-global pc/2 pc: skip pc 2 true ] #get-definition [ ;-- temporary directive either value: select extracts/definitions pc/2 [ change/only/part pc value 2 comp-expression ;-- continue expression fetching ][ pc: next pc ] true ] #load [ ;-- temporary directive change/part/only pc to do pc/2 pc/3 3 comp-expression ;-- continue expression fetching true ] #version [ change pc form load-cache %version.r comp-expression true ] #build-date [ change pc mold now comp-expression true ] ] ] comp-substitute-expression: has [paths mark][ paths: length? paths-stack mark: tail output comp-expression if all [ paths < length? paths-stack not find mark [stack/push pos] ][ emit [stack/push pos + 0] insert-lf -4 ] mark: none ] comp-expression: func [/no-infix /root /close-path /local out paths][ root: to logic! root if any [root close-path][out: tail output] paths: length? paths-stack unless no-infix [ if check-infix-operators root [ if all [any [root close-path] paths < length? paths-stack][ emit-dynamic-path out push-call loop length? paths-stack [ emit-dynamic-path make block! 0 ] pop-call if tail? pc [emit-dyn-check] ] exit ] ] if tail? pc [ pc: back pc throw-error "missing argument" ] switch/default type?/word pc/1 [ issue! [ either any [ unicode-char? pc/1 float-special? pc/1 ][ comp-literal ;-- special encoding for Unicode char! ][ unless comp-directive [comp-literal] ] ] ;-- active datatypes with specific literal form set-word! [comp-set-word] word! [comp-word] get-word! [comp-word/literal] paren! [comp-next-block] set-path! [comp-path/set? root] path! [comp-path root] ][ comp-literal ] if root [ either tail? pc [ unless find/only [stack/reset stack/unwind] last output [ emit-dyn-check ] ][ emit-stack-reset ;-- clear stack from last root expression result ] ] if any [root close-path][ if paths < length? paths-stack [ emit-dynamic-path out if tail? pc [emit-dyn-check] ] ] ] comp-next-block: func [/with blk /local saved][ saved: pc pc: any [blk pc/1] comp-block pc: next saved ] comp-chunked-block: has [list mark saved][ list: make block! 10 saved: pc pc: pc/1 ;-- dive in nested code mark: tail output comp-block/with [ mold mark ;-- black magic, fixes #509, R2 internal memory corruption append/only list copy mark clear mark ] pc: next saved list ] comp-sub-block: func [origin [word!] /with body /local mark saved][ unless any [with block? pc/1][ throw-error [ "expected a block for" uppercase form origin "instead of" mold type? pc/1 "value" ] ] mark: tail output saved: pc pc: any [body pc/1] ;-- dive in nested code comp-block pc: next saved ;-- step over block in source code convert-to-block mark head insert last output [ stack/reset ] ] comp-block: func [ /with body [block!] /no-root /local expr size ][ if tail? pc [ emit 'unset/push insert-lf -1 exit ] while [not tail? pc][ expr: pc either no-root [comp-expression][comp-expression/root] if all [verbose > 3 positive? size: offset? expr pc][probe copy/part expr size] if verbose > 0 [emit-src-comment expr] if with [do body] ] ] comp-bodies: does [ obj-stack: to path! 'func-objs foreach [name spec body symbols locals-nb stack ssa ctx obj?] bodies [ either none? symbols [ ;-- routine in no-global? mode emit reduce [to set-word! name 'func] insert-lf -2 append/only output spec append/only output body ][ locals-stack: stack ssa-names: ssa ctx-stack: ctx container-obj?: obj? func-objs: tail objects depth: max-depth comp-func-body name spec body symbols locals-nb ] ] clear locals-stack clear ssa-names func-objs: none ] comp-init: does [ add-symbol 'datatype! add-global 'datatype! foreach [name specs] functions [ add-symbol name add-global name ] ;-- Create datatype! datatype and word emit compose [ stack/mark-native ~set word/push (decorate-symbol 'datatype!) datatype/push TYPE_DATATYPE word/set stack/unwind stack/reset ] ] comp-source: func [code [block!] /local user main][ output: make block! 10000 comp-init pc: load-source/hidden %boot.red ;-- compile Red's boot script unless job/red-help? [clear-docstrings pc] booting?: yes comp-block make-keywords ;-- register intrinsics functions booting?: no pc: code ;-- compile user code user: tail output comp-block main: output output: make block! 1000 comp-bodies ;-- compile deferred functions reduce [user main] ] comp-as-lib: func [code [block!] /local user main defs pos][ out: copy/deep [ Red/System [ type: 'dll origin: 'Red ] with red [ exec: context [ init: func [/local tmp]