erlydtl_compiler.erl 68 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455
  1. %%%-------------------------------------------------------------------
  2. %%% File: erlydtl_compiler.erl
  3. %%% @author Roberto Saccon <rsaccon@gmail.com> [http://rsaccon.com]
  4. %%% @author Evan Miller <emmiller@gmail.com>
  5. %%% @author Andreas Stenius <kaos@astekk.se>
  6. %%% @copyright 2008 Roberto Saccon, Evan Miller
  7. %%% @doc
  8. %%% ErlyDTL template compiler
  9. %%% @end
  10. %%%
  11. %%% The MIT License
  12. %%%
  13. %%% Copyright (c) 2007 Roberto Saccon, Evan Miller
  14. %%%
  15. %%% Permission is hereby granted, free of charge, to any person obtaining a copy
  16. %%% of this software and associated documentation files (the "Software"), to deal
  17. %%% in the Software without restriction, including without limitation the rights
  18. %%% to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  19. %%% copies of the Software, and to permit persons to whom the Software is
  20. %%% furnished to do so, subject to the following conditions:
  21. %%%
  22. %%% The above copyright notice and this permission notice shall be included in
  23. %%% all copies or substantial portions of the Software.
  24. %%%
  25. %%% THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  26. %%% IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  27. %%% FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  28. %%% AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  29. %%% LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  30. %%% OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  31. %%% THE SOFTWARE.
  32. %%%
  33. %%% @since 2007-12-16 by Roberto Saccon, Evan Miller
  34. %%%-------------------------------------------------------------------
  35. -module(erlydtl_compiler).
  36. -author('rsaccon@gmail.com').
  37. -author('emmiller@gmail.com').
  38. -author('Andreas Stenius <kaos@astekk.se>').
  39. %% --------------------------------------------------------------------
  40. %% Definitions
  41. %% --------------------------------------------------------------------
  42. -export([compile/2, compile/3, compile_dir/2, compile_dir/3, parse/1]).
  43. %% exported for use by extension modules
  44. -export([
  45. merge_info/2,
  46. format/3,
  47. value_ast/5,
  48. resolve_scoped_variable_ast/2
  49. ]).
  50. -include("erlydtl_ext.hrl").
  51. compile(Binary, Module) when is_binary(Binary) ->
  52. compile(Binary, Module, []);
  53. compile(File, Module) ->
  54. compile(File, Module, []).
  55. compile(Binary, Module, Options) when is_binary(Binary) ->
  56. File = "",
  57. CheckSum = "",
  58. Context = init_dtl_context(File, Module, Options),
  59. case parse(Binary, Context) of
  60. {ok, DjangoParseTree} ->
  61. case compile_to_binary(File, DjangoParseTree, Context, CheckSum) of
  62. {ok, Module1, _, _} ->
  63. {ok, Module1};
  64. Err ->
  65. Err
  66. end;
  67. Err ->
  68. Err
  69. end;
  70. compile(File, Module, Options) ->
  71. Context = init_dtl_context(File, Module, Options),
  72. case parse(File, Context) of
  73. ok ->
  74. ok;
  75. {ok, DjangoParseTree, CheckSum} ->
  76. case compile_to_binary(File, DjangoParseTree, Context, CheckSum) of
  77. {ok, Module1, Bin, Warnings} ->
  78. write_binary(Module1, Bin, Options, Warnings);
  79. Err ->
  80. Err
  81. end;
  82. Err ->
  83. Err
  84. end.
  85. compile_dir(Dir, Module) ->
  86. compile_dir(Dir, Module, []).
  87. compile_dir(Dir, Module, Options) ->
  88. Context = init_dtl_context_dir(Dir, Module, Options),
  89. %% Find all files in Dir (recursively), matching the regex (no
  90. %% files ending in "~").
  91. Files = filelib:fold_files(Dir, ".+[^~]$", true, fun(F1,Acc1) -> [F1 | Acc1] end, []),
  92. {ParserResults, ParserErrors} = lists:foldl(fun
  93. (File, {ResultAcc, ErrorAcc}) ->
  94. case filename:basename(File) of
  95. "."++_ ->
  96. {ResultAcc, ErrorAcc};
  97. _ ->
  98. FilePath = filename:absname(File),
  99. case filelib:is_dir(FilePath) of
  100. true ->
  101. {ResultAcc, ErrorAcc};
  102. false ->
  103. case parse(FilePath, Context) of
  104. ok -> {ResultAcc, ErrorAcc};
  105. {ok, DjangoParseTree, CheckSum} ->
  106. {[{File, DjangoParseTree, CheckSum}|ResultAcc], ErrorAcc};
  107. Err -> {ResultAcc, [Err|ErrorAcc]}
  108. end
  109. end
  110. end
  111. end, {[], []}, Files),
  112. case ParserErrors of
  113. [] ->
  114. case compile_multiple_to_binary(Dir, ParserResults, Context) of
  115. {ok, Module1, Bin, Warnings} ->
  116. write_binary(Module1, Bin, Options, Warnings);
  117. Err ->
  118. Err
  119. end;
  120. [Error|_] ->
  121. Error
  122. end.
  123. %%====================================================================
  124. %% Internal functions
  125. %%====================================================================
  126. write_binary(Module1, Bin, Options, Warnings) ->
  127. Verbose = proplists:get_value(verbose, Options, false),
  128. case proplists:get_value(out_dir, Options) of
  129. undefined ->
  130. print(Verbose, "Template module: ~w not saved (no out_dir option)\n", [Module1]),
  131. ok;
  132. OutDir ->
  133. BeamFile = filename:join([OutDir, atom_to_list(Module1) ++ ".beam"]),
  134. print(Verbose, "Template module: ~w -> ~s~s\n",
  135. [Module1, BeamFile,
  136. case Warnings of
  137. [] -> "";
  138. _ -> io_lib:format("\n Warnings: ~p", [Warnings])
  139. end]),
  140. case file:write_file(BeamFile, Bin) of
  141. ok ->
  142. ok;
  143. {error, Reason} ->
  144. {error, lists:flatten(
  145. io_lib:format("Beam generation of '~s' failed: ~p",
  146. [BeamFile, file:format_error(Reason)]))}
  147. end
  148. end.
  149. compile_multiple_to_binary(Dir, ParserResults, Context) ->
  150. MatchAst = options_match_ast(Context),
  151. {Functions, {AstInfo, _}} = lists:mapfoldl(fun({File, DjangoParseTree, CheckSum}, {AstInfo, TreeWalker}) ->
  152. FilePath = full_path(File, Context#dtl_context.doc_root),
  153. {{BodyAst, BodyInfo}, TreeWalker1} = with_dependency({FilePath, CheckSum}, body_ast(DjangoParseTree, Context, TreeWalker)),
  154. FunctionName = filename:rootname(filename:basename(File)),
  155. Function1 = erl_syntax:function(erl_syntax:atom(FunctionName),
  156. [erl_syntax:clause([erl_syntax:variable("_Variables")], none,
  157. [erl_syntax:application(none, erl_syntax:atom(FunctionName),
  158. [erl_syntax:variable("_Variables"), erl_syntax:list([])])])]),
  159. Function2 = erl_syntax:function(erl_syntax:atom(FunctionName),
  160. [erl_syntax:clause([erl_syntax:variable("_Variables"), erl_syntax:variable("RenderOptions")], none,
  161. MatchAst ++ [BodyAst])]),
  162. {{FunctionName, Function1, Function2}, {merge_info(AstInfo, BodyInfo), TreeWalker1}}
  163. end, {#ast_info{}, init_treewalker(Context)}, ParserResults),
  164. Forms = custom_forms(Dir, Context#dtl_context.module, Functions, AstInfo),
  165. compile_forms_and_reload(Dir, Forms, Context).
  166. compile_to_binary(File, DjangoParseTree, Context, CheckSum) ->
  167. try body_ast(DjangoParseTree, Context, init_treewalker(Context)) of
  168. {{BodyAst, BodyInfo}, BodyTreeWalker} ->
  169. try custom_tags_ast(BodyInfo#ast_info.custom_tags, Context, BodyTreeWalker) of
  170. {{CustomTagsAst, CustomTagsInfo}, _} ->
  171. Forms = forms(File, Context#dtl_context.module, {BodyAst, BodyInfo},
  172. {CustomTagsAst, CustomTagsInfo}, CheckSum, Context, BodyTreeWalker),
  173. compile_forms_and_reload(File, Forms, Context)
  174. catch
  175. throw:Error -> Error
  176. end
  177. catch
  178. throw:Error -> Error
  179. end.
  180. compile_forms_and_reload(File, Forms, Context) ->
  181. case proplists:get_value(debug_compiler, Context#dtl_context.compiler_options) of
  182. true ->
  183. io:format("template source:~n~s~n",
  184. [try
  185. erl_prettypr:format(erl_syntax:form_list(Forms))
  186. catch
  187. error:Err ->
  188. io_lib:format("Pretty printing failed: ~p~nContext: ~n~p~nForms: ~n~p~n",
  189. [Err, Context, Forms])
  190. end
  191. ]);
  192. _ -> nop
  193. end,
  194. case compile:forms(Forms, Context#dtl_context.compiler_options) of
  195. {ok, Module1, Bin} ->
  196. load_code(Module1, Bin, []);
  197. {ok, Module1, Bin, Warnings} ->
  198. load_code(Module1, Bin, Warnings);
  199. error ->
  200. {error, lists:concat(["compilation failed: ", File])};
  201. OtherError ->
  202. OtherError
  203. end.
  204. load_code(Module, Bin, Warnings) ->
  205. code:purge(Module),
  206. case code:load_binary(Module, atom_to_list(Module) ++ ".erl", Bin) of
  207. {module, _} -> {ok, Module, Bin, Warnings};
  208. _ -> {error, lists:concat(["code reload failed: ", Module])}
  209. end.
  210. init_context(IsCompilingDir, ParseTrail, DefDir, Module, Options) ->
  211. Ctx = #dtl_context{},
  212. Context = #dtl_context{
  213. parse_trail = ParseTrail,
  214. module = Module,
  215. doc_root = proplists:get_value(doc_root, Options, DefDir),
  216. filter_modules = proplists:get_value(custom_filters_modules, Options, Ctx#dtl_context.filter_modules) ++ [erlydtl_filters],
  217. custom_tags_dir = proplists:get_value(custom_tags_dir, Options, filename:join([erlydtl_deps:get_base_dir(), "priv", "custom_tags"])),
  218. custom_tags_modules = proplists:get_value(custom_tags_modules, Options, Ctx#dtl_context.custom_tags_modules),
  219. blocktrans_fun = proplists:get_value(blocktrans_fun, Options, Ctx#dtl_context.blocktrans_fun),
  220. blocktrans_locales = proplists:get_value(blocktrans_locales, Options, Ctx#dtl_context.blocktrans_locales),
  221. vars = proplists:get_value(vars, Options, Ctx#dtl_context.vars),
  222. reader = proplists:get_value(reader, Options, Ctx#dtl_context.reader),
  223. compiler_options = proplists:get_value(compiler_options, Options, Ctx#dtl_context.compiler_options),
  224. binary_strings = proplists:get_value(binary_strings, Options, Ctx#dtl_context.binary_strings),
  225. force_recompile = proplists:get_value(force_recompile, Options, Ctx#dtl_context.force_recompile),
  226. locale = proplists:get_value(locale, Options, Ctx#dtl_context.locale),
  227. verbose = proplists:get_value(verbose, Options, Ctx#dtl_context.verbose),
  228. is_compiling_dir = IsCompilingDir,
  229. extension_module = proplists:get_value(extension_module, Options, Ctx#dtl_context.extension_module)
  230. },
  231. case call_extension(Context, init_context, [Context]) of
  232. {ok, C} when is_record(C, dtl_context) -> C;
  233. undefined -> Context
  234. end.
  235. init_dtl_context(File, Module, Options) when is_list(Module) ->
  236. init_dtl_context(File, list_to_atom(Module), Options);
  237. init_dtl_context(File, Module, Options) ->
  238. init_context(false, [File], filename:dirname(File), Module, Options).
  239. init_dtl_context_dir(Dir, Module, Options) when is_list(Module) ->
  240. init_dtl_context_dir(Dir, list_to_atom(Module), Options);
  241. init_dtl_context_dir(Dir, Module, Options) ->
  242. init_context(true, [], Dir, Module, Options).
  243. init_treewalker(Context) ->
  244. TreeWalker = #treewalker{},
  245. case call_extension(Context, init_treewalker, [TreeWalker]) of
  246. {ok, TW} when is_record(TW, treewalker) -> TW;
  247. undefined -> TreeWalker
  248. end.
  249. is_up_to_date(_, #dtl_context{force_recompile = true}) ->
  250. false;
  251. is_up_to_date(CheckSum, Context) ->
  252. Module = Context#dtl_context.module,
  253. {M, F} = Context#dtl_context.reader,
  254. case catch Module:source() of
  255. {_, CheckSum} ->
  256. case catch Module:dependencies() of
  257. L when is_list(L) ->
  258. RecompileList = lists:foldl(fun
  259. ({XFile, XCheckSum}, Acc) ->
  260. case catch M:F(XFile) of
  261. {ok, Data} ->
  262. case binary_to_list(erlang:md5(Data)) of
  263. XCheckSum ->
  264. Acc;
  265. _ ->
  266. [recompile | Acc]
  267. end;
  268. _ ->
  269. [recompile | Acc]
  270. end
  271. end, [], L),
  272. case RecompileList of
  273. [] -> true;
  274. _ -> false
  275. end;
  276. _ ->
  277. false
  278. end;
  279. _ ->
  280. false
  281. end.
  282. parse(Data) ->
  283. parse(Data, #dtl_context{}).
  284. parse(Data, Context) when is_binary(Data) ->
  285. check_scan(erlydtl_scanner:scan(binary_to_list(Data)), Context);
  286. parse(File, Context) ->
  287. {M, F} = Context#dtl_context.reader,
  288. case catch M:F(File) of
  289. {ok, Data} ->
  290. CheckSum = binary_to_list(erlang:md5(Data)),
  291. case parse(CheckSum, Data, Context) of
  292. {error, Msg} when is_list(Msg) ->
  293. {error, File ++ ": " ++ Msg};
  294. {error, Msg} ->
  295. {error, {File, [Msg]}};
  296. Result ->
  297. Result
  298. end;
  299. _ ->
  300. {error, {File, [{0, Context#dtl_context.module, "Failed to read file"}]}}
  301. end.
  302. parse(CheckSum, Data, Context) ->
  303. case is_up_to_date(CheckSum, Context) of
  304. true ->
  305. ok;
  306. _ ->
  307. case parse(Data, Context) of
  308. {ok, Val} ->
  309. {ok, Val, CheckSum};
  310. Err ->
  311. Err
  312. end
  313. end.
  314. call_extension(#dtl_context{ extension_module=undefined }, _Fun, _Args) ->
  315. undefined;
  316. call_extension(#dtl_context{ extension_module=Mod }, Fun, Args)
  317. when is_atom(Mod), is_atom(Fun), is_list(Args) ->
  318. M = case code:is_loaded(Mod) of
  319. false ->
  320. case code:load_file(Mod) of
  321. {module, Mod} ->
  322. Mod;
  323. _ ->
  324. undefined
  325. end;
  326. _ -> Mod
  327. end,
  328. if M /= undefined ->
  329. case erlang:function_exported(M, Fun, length(Args)) of
  330. true ->
  331. apply(M, Fun, Args);
  332. false ->
  333. undefined
  334. end;
  335. true ->
  336. undefined
  337. end.
  338. check_scan({ok, Tokens}, Context) ->
  339. Tokens1 = case call_extension(Context, post_scan, [Tokens]) of
  340. undefined -> Tokens;
  341. {ok, T} -> T
  342. end,
  343. check_parse(erlydtl_parser:parse(Tokens1), [], Context);
  344. check_scan({error, Err, State}, Context) ->
  345. case call_extension(Context, scan, [State]) of
  346. undefined ->
  347. {error, Err};
  348. {ok, NewState} ->
  349. %% io:format("call_extension from:~p~nto: ~p~n", [State, NewState]),
  350. check_scan(erlydtl_scanner:resume(NewState), Context);
  351. ExtRes ->
  352. ExtRes
  353. end.
  354. check_parse({ok, _}=Ok, [], _Context) -> Ok;
  355. check_parse({ok, _, _}=Ok, [], _Context) -> Ok;
  356. check_parse({ok, Parsed}, Acc, _Context) -> {ok, Acc ++ Parsed};
  357. check_parse({ok, Parsed, C}, Acc, _Context) -> {ok, Acc ++ Parsed, C};
  358. check_parse({error, _}=Err, _, _Context) -> Err;
  359. check_parse({error, Err, State}, Acc, Context) ->
  360. %% io:format("parse error: ~p~nstate: ~p~n",[Err, State]),
  361. {State1, Parsed} = reset_parse_state(State),
  362. case call_extension(Context, parse, [State1]) of
  363. undefined ->
  364. {error, Err};
  365. {ok, ExtParsed} ->
  366. {ok, Acc ++ Parsed ++ ExtParsed};
  367. {error, ExtErr, ExtState} ->
  368. case reset_parse_state(ExtState) of
  369. {_, []} ->
  370. %% todo: see if this is indeed a sensible ext error,
  371. %% or if we should rather present the original Err message
  372. {error, ExtErr};
  373. {State2, ExtParsed} ->
  374. check_parse(erlydtl_parser:resume(State2), Acc ++ Parsed ++ ExtParsed, Context)
  375. end;
  376. ExtRes ->
  377. ExtRes
  378. end.
  379. %% backtrack up to the Rootsymbol, and keep the current top-level value stack
  380. reset_parse_state([Ts, Tzr, _, [0 | []], [Parsed | []]]) ->
  381. {[Ts, Tzr, 0, [], []], Parsed};
  382. reset_parse_state([Ts, Tzr, _, [S | Ss], [T | Stack]]) ->
  383. reset_parse_state([[T | Ts], Tzr, S, Ss, Stack]);
  384. reset_parse_state([_, _, 0, [], []]=State) ->
  385. {State, []}.
  386. custom_tags_ast(CustomTags, Context, TreeWalker) ->
  387. {{CustomTagsClauses, CustomTagsInfo}, TreeWalker1} = custom_tags_clauses_ast(CustomTags, Context, TreeWalker),
  388. %% This doesn't work since erl_syntax:revert/1 chokes on the airity_qualifier in the -compile attribute..
  389. %% bug report sent to the erlang-bugs mailing list.
  390. %% {{erl_syntax:form_list(
  391. %% [erl_syntax:attribute(
  392. %% erl_syntax:atom(compile),
  393. %% [erl_syntax:tuple(
  394. %% [erl_syntax:atom(nowarn_unused_function),
  395. %% erl_syntax:arity_qualifier(
  396. %% erl_syntax:atom(render_tag),
  397. %% erl_syntax:integer(3))])]),
  398. %% erl_syntax:function(erl_syntax:atom(render_tag), CustomTagsClauses)]),
  399. {{erl_syntax:function(erl_syntax:atom(render_tag), CustomTagsClauses),
  400. CustomTagsInfo},
  401. TreeWalker1}.
  402. custom_tags_clauses_ast(CustomTags, Context, TreeWalker) ->
  403. custom_tags_clauses_ast1(CustomTags, [], [], #ast_info{}, Context, TreeWalker).
  404. custom_tags_clauses_ast1([], _ExcludeTags, ClauseAcc, InfoAcc, _Context, TreeWalker) ->
  405. {{lists:reverse(
  406. [erl_syntax:clause(
  407. [erl_syntax:variable("_TagName"), erl_syntax:underscore(), erl_syntax:underscore()],
  408. none,
  409. [erl_syntax:list([])])
  410. |ClauseAcc]),
  411. InfoAcc},
  412. TreeWalker};
  413. custom_tags_clauses_ast1([Tag|CustomTags], ExcludeTags, ClauseAcc, InfoAcc, Context, TreeWalker) ->
  414. case lists:member(Tag, ExcludeTags) of
  415. true ->
  416. custom_tags_clauses_ast1(CustomTags, ExcludeTags, ClauseAcc, InfoAcc, Context, TreeWalker);
  417. false ->
  418. CustomTagFile = full_path(Tag, Context#dtl_context.custom_tags_dir),
  419. case filelib:is_file(CustomTagFile) of
  420. true ->
  421. case parse(CustomTagFile, Context) of
  422. {ok, DjangoParseTree, CheckSum} ->
  423. {{BodyAst, BodyAstInfo}, TreeWalker1} = with_dependency(
  424. {CustomTagFile, CheckSum}, body_ast(DjangoParseTree, Context, TreeWalker)),
  425. MatchAst = options_match_ast(Context, TreeWalker),
  426. Clause = erl_syntax:clause(
  427. [key_to_string(Tag), erl_syntax:variable("_Variables"), erl_syntax:variable("RenderOptions")],
  428. none, MatchAst ++ [BodyAst]),
  429. custom_tags_clauses_ast1(CustomTags, [Tag|ExcludeTags],
  430. [Clause|ClauseAcc], merge_info(BodyAstInfo, InfoAcc),
  431. Context, TreeWalker1);
  432. Error ->
  433. throw(Error)
  434. end;
  435. false ->
  436. custom_tags_clauses_ast1(CustomTags, [Tag | ExcludeTags],
  437. ClauseAcc, InfoAcc, Context, TreeWalker)
  438. end
  439. end.
  440. dependencies_function(Dependencies) ->
  441. erl_syntax:function(
  442. erl_syntax:atom(dependencies), [erl_syntax:clause([], none,
  443. [erl_syntax:list(lists:map(fun
  444. ({XFile, XCheckSum}) ->
  445. erl_syntax:tuple([erl_syntax:string(XFile), erl_syntax:string(XCheckSum)])
  446. end, Dependencies))])]).
  447. translatable_strings_function(TranslatableStrings) ->
  448. erl_syntax:function(
  449. erl_syntax:atom(translatable_strings), [erl_syntax:clause([], none,
  450. [erl_syntax:list(lists:map(fun(String) ->
  451. erl_syntax:string(String)
  452. end,
  453. TranslatableStrings))])]).
  454. translated_blocks_function(TranslatedBlocks) ->
  455. erl_syntax:function(
  456. erl_syntax:atom(translated_blocks), [erl_syntax:clause([], none,
  457. [erl_syntax:list(lists:map(fun(String) ->
  458. erl_syntax:string(String)
  459. end,
  460. TranslatedBlocks))])]).
  461. variables_function(Variables) ->
  462. erl_syntax:function(
  463. erl_syntax:atom(variables), [erl_syntax:clause([], none,
  464. [erl_syntax:list([erl_syntax:atom(S) || S <- lists:usort(Variables)])])]).
  465. custom_forms(Dir, Module, Functions, AstInfo) ->
  466. ModuleAst = erl_syntax:attribute(erl_syntax:atom(module), [erl_syntax:atom(Module)]),
  467. ExportAst = erl_syntax:attribute(erl_syntax:atom(export),
  468. [erl_syntax:list([
  469. erl_syntax:arity_qualifier(erl_syntax:atom(source_dir), erl_syntax:integer(0)),
  470. erl_syntax:arity_qualifier(erl_syntax:atom(dependencies), erl_syntax:integer(0)),
  471. erl_syntax:arity_qualifier(erl_syntax:atom(translatable_strings), erl_syntax:integer(0))
  472. |
  473. lists:foldl(fun({FunctionName, _, _}, Acc) ->
  474. [erl_syntax:arity_qualifier(erl_syntax:atom(FunctionName), erl_syntax:integer(1)),
  475. erl_syntax:arity_qualifier(erl_syntax:atom(FunctionName), erl_syntax:integer(2))|Acc]
  476. end, [], Functions)]
  477. )]),
  478. SourceFunctionAst = erl_syntax:function(
  479. erl_syntax:atom(source_dir), [erl_syntax:clause([], none, [erl_syntax:string(Dir)])]),
  480. DependenciesFunctionAst = dependencies_function(AstInfo#ast_info.dependencies),
  481. TranslatableStringsFunctionAst = translatable_strings_function(AstInfo#ast_info.translatable_strings),
  482. FunctionAsts = lists:foldl(fun({_, Function1, Function2}, Acc) -> [Function1, Function2 | Acc] end, [], Functions),
  483. [erl_syntax:revert(X) || X <- [ModuleAst, ExportAst, SourceFunctionAst, DependenciesFunctionAst, TranslatableStringsFunctionAst
  484. | FunctionAsts] ++ AstInfo#ast_info.pre_render_asts].
  485. forms(File, Module, {BodyAst, BodyInfo}, {CustomTagsFunctionAst, CustomTagsInfo}, CheckSum, Context, TreeWalker) ->
  486. MergedInfo = merge_info(BodyInfo, CustomTagsInfo),
  487. Render0FunctionAst = erl_syntax:function(erl_syntax:atom(render),
  488. [erl_syntax:clause([], none, [erl_syntax:application(none,
  489. erl_syntax:atom(render), [erl_syntax:list([])])])]),
  490. Render1FunctionAst = erl_syntax:function(erl_syntax:atom(render),
  491. [erl_syntax:clause([erl_syntax:variable("_Variables")], none,
  492. [erl_syntax:application(none,
  493. erl_syntax:atom(render),
  494. [erl_syntax:variable("_Variables"), erl_syntax:list([])])])]),
  495. Function2 = erl_syntax:application(none, erl_syntax:atom(render_internal),
  496. [erl_syntax:variable("_Variables"), erl_syntax:variable("RenderOptions")]),
  497. ClauseOk = erl_syntax:clause([erl_syntax:variable("Val")], none,
  498. [erl_syntax:tuple([erl_syntax:atom(ok), erl_syntax:variable("Val")])]),
  499. ClauseCatch = erl_syntax:clause([erl_syntax:variable("Err")], none,
  500. [erl_syntax:tuple([erl_syntax:atom(error), erl_syntax:variable("Err")])]),
  501. Render2FunctionAst = erl_syntax:function(erl_syntax:atom(render),
  502. [erl_syntax:clause([erl_syntax:variable("_Variables"),
  503. erl_syntax:variable("RenderOptions")], none,
  504. [erl_syntax:try_expr([Function2], [ClauseOk], [ClauseCatch])])]),
  505. SourceFunctionTuple = erl_syntax:tuple(
  506. [erl_syntax:string(File), erl_syntax:string(CheckSum)]),
  507. SourceFunctionAst = erl_syntax:function(
  508. erl_syntax:atom(source),
  509. [erl_syntax:clause([], none, [SourceFunctionTuple])]),
  510. DependenciesFunctionAst = dependencies_function(MergedInfo#ast_info.dependencies),
  511. TranslatableStringsAst = translatable_strings_function(MergedInfo#ast_info.translatable_strings),
  512. TranslatedBlocksAst = translated_blocks_function(MergedInfo#ast_info.translated_blocks),
  513. VariablesAst = variables_function(MergedInfo#ast_info.var_names),
  514. MatchAst = options_match_ast(Context, TreeWalker),
  515. BodyAstTmp = MatchAst ++ [
  516. erl_syntax:application(
  517. erl_syntax:atom(erlydtl_runtime),
  518. erl_syntax:atom(stringify_final),
  519. [BodyAst, erl_syntax:atom(Context#dtl_context.binary_strings)])
  520. ],
  521. RenderInternalFunctionAst = erl_syntax:function(
  522. erl_syntax:atom(render_internal),
  523. [erl_syntax:clause([
  524. erl_syntax:variable("_Variables"),
  525. erl_syntax:variable("RenderOptions")],
  526. none, BodyAstTmp)]
  527. ),
  528. ModuleAst = erl_syntax:attribute(erl_syntax:atom(module), [erl_syntax:atom(Module)]),
  529. ExportAst = erl_syntax:attribute(erl_syntax:atom(export),
  530. [erl_syntax:list([erl_syntax:arity_qualifier(erl_syntax:atom(render), erl_syntax:integer(0)),
  531. erl_syntax:arity_qualifier(erl_syntax:atom(render), erl_syntax:integer(1)),
  532. erl_syntax:arity_qualifier(erl_syntax:atom(render), erl_syntax:integer(2)),
  533. erl_syntax:arity_qualifier(erl_syntax:atom(source), erl_syntax:integer(0)),
  534. erl_syntax:arity_qualifier(erl_syntax:atom(dependencies), erl_syntax:integer(0)),
  535. erl_syntax:arity_qualifier(erl_syntax:atom(translatable_strings), erl_syntax:integer(0)),
  536. erl_syntax:arity_qualifier(erl_syntax:atom(translated_blocks), erl_syntax:integer(0)),
  537. erl_syntax:arity_qualifier(erl_syntax:atom(variables), erl_syntax:integer(0))
  538. ])]),
  539. erl_syntax:revert_forms(
  540. erl_syntax:form_list(
  541. [ModuleAst, ExportAst, Render0FunctionAst, Render1FunctionAst, Render2FunctionAst,
  542. SourceFunctionAst, DependenciesFunctionAst, TranslatableStringsAst,
  543. TranslatedBlocksAst, VariablesAst, RenderInternalFunctionAst,
  544. CustomTagsFunctionAst
  545. |BodyInfo#ast_info.pre_render_asts])).
  546. options_match_ast(Context) -> options_match_ast(Context, undefined).
  547. options_match_ast(Context, TreeWalker) ->
  548. [
  549. erl_syntax:match_expr(
  550. erl_syntax:variable("_TranslationFun"),
  551. erl_syntax:application(
  552. erl_syntax:atom(proplists),
  553. erl_syntax:atom(get_value),
  554. [erl_syntax:atom(translation_fun), erl_syntax:variable("RenderOptions"), erl_syntax:atom(none)])),
  555. erl_syntax:match_expr(
  556. erl_syntax:variable("_CurrentLocale"),
  557. erl_syntax:application(
  558. erl_syntax:atom(proplists),
  559. erl_syntax:atom(get_value),
  560. [erl_syntax:atom(locale), erl_syntax:variable("RenderOptions"), erl_syntax:atom(none)]))
  561. | case call_extension(Context, setup_render_ast, [Context, TreeWalker]) of
  562. undefined -> [];
  563. Ast when is_list(Ast) -> Ast
  564. end
  565. ].
  566. % child templates should only consist of blocks at the top level
  567. body_ast([{'extends', {string_literal, _Pos, String}} | ThisParseTree], Context, TreeWalker) ->
  568. File = full_path(unescape_string_literal(String), Context#dtl_context.doc_root),
  569. case lists:member(File, Context#dtl_context.parse_trail) of
  570. true ->
  571. throw({error, "Circular file inclusion!"});
  572. _ ->
  573. case parse(File, Context) of
  574. {ok, ParentParseTree, CheckSum} ->
  575. BlockDict = lists:foldl(
  576. fun
  577. ({block, {identifier, _, Name}, Contents}, Dict) ->
  578. dict:store(Name, Contents, Dict);
  579. (_, Dict) ->
  580. Dict
  581. end, dict:new(), ThisParseTree),
  582. with_dependency({File, CheckSum}, body_ast(ParentParseTree, Context#dtl_context{
  583. block_dict = dict:merge(fun(_Key, _ParentVal, ChildVal) -> ChildVal end,
  584. BlockDict, Context#dtl_context.block_dict),
  585. parse_trail = [File | Context#dtl_context.parse_trail]}, TreeWalker));
  586. Err ->
  587. throw(Err)
  588. end
  589. end;
  590. body_ast(DjangoParseTree, Context, TreeWalker) ->
  591. {AstInfoList, TreeWalker2} = lists:mapfoldl(
  592. fun
  593. ({'autoescape', {identifier, _, OnOrOff}, Contents}, TreeWalkerAcc) ->
  594. body_ast(Contents, Context#dtl_context{auto_escape = OnOrOff},
  595. TreeWalkerAcc);
  596. ({'block', {identifier, _, Name}, Contents}, TreeWalkerAcc) ->
  597. Block = case dict:find(Name, Context#dtl_context.block_dict) of
  598. {ok, ChildBlock} -> ChildBlock;
  599. _ -> Contents
  600. end,
  601. body_ast(Block, Context, TreeWalkerAcc);
  602. ({'blocktrans', Args, Contents}, TreeWalkerAcc) ->
  603. blocktrans_ast(Args, Contents, Context, TreeWalkerAcc);
  604. ({'call', {identifier, _, Name}}, TreeWalkerAcc) ->
  605. call_ast(Name, TreeWalkerAcc);
  606. ({'call', {identifier, _, Name}, With}, TreeWalkerAcc) ->
  607. call_with_ast(Name, With, Context, TreeWalkerAcc);
  608. ({'comment', _Contents}, TreeWalkerAcc) ->
  609. empty_ast(TreeWalkerAcc);
  610. ({'cycle', Names}, TreeWalkerAcc) ->
  611. cycle_ast(Names, Context, TreeWalkerAcc);
  612. ({'cycle_compat', Names}, TreeWalkerAcc) ->
  613. cycle_compat_ast(Names, Context, TreeWalkerAcc);
  614. ({'date', 'now', {string_literal, _Pos, FormatString}}, TreeWalkerAcc) ->
  615. now_ast(FormatString, Context, TreeWalkerAcc);
  616. ({'filter', FilterList, Contents}, TreeWalkerAcc) ->
  617. filter_tag_ast(FilterList, Contents, Context, TreeWalkerAcc);
  618. ({'firstof', Vars}, TreeWalkerAcc) ->
  619. firstof_ast(Vars, Context, TreeWalkerAcc);
  620. ({'for', {'in', IteratorList, Variable, Reversed}, Contents}, TreeWalkerAcc) ->
  621. {EmptyAstInfo, TreeWalker1} = empty_ast(TreeWalkerAcc),
  622. for_loop_ast(IteratorList, Variable, Reversed, Contents, EmptyAstInfo, Context, TreeWalker1);
  623. ({'for', {'in', IteratorList, Variable, Reversed}, Contents, EmptyPartContents}, TreeWalkerAcc) ->
  624. {EmptyAstInfo, TreeWalker1} = body_ast(EmptyPartContents, Context, TreeWalkerAcc),
  625. for_loop_ast(IteratorList, Variable, Reversed, Contents, EmptyAstInfo, Context, TreeWalker1);
  626. ({'if', Expression, Contents, Elif}, TreeWalkerAcc) ->
  627. {IfAstInfo, TreeWalker1} = body_ast(Contents, Context, TreeWalkerAcc),
  628. {ElifAstInfo, TreeWalker2} = body_ast(Elif, Context, TreeWalker1),
  629. ifelse_ast(Expression, IfAstInfo, ElifAstInfo, Context, TreeWalker2);
  630. ({'if', Expression, Contents}, TreeWalkerAcc) ->
  631. {IfAstInfo, TreeWalker1} = body_ast(Contents, Context, TreeWalkerAcc),
  632. {ElseAstInfo, TreeWalker2} = empty_ast(TreeWalker1),
  633. ifelse_ast(Expression, IfAstInfo, ElseAstInfo, Context, TreeWalker2);
  634. ({'ifchanged', '$undefined', Contents}, TreeWalkerAcc) ->
  635. {IfAstInfo, TreeWalker1} = body_ast(Contents, Context, TreeWalkerAcc),
  636. {ElseAstInfo, TreeWalker2} = empty_ast(TreeWalker1),
  637. ifchanged_contents_ast(Contents, IfAstInfo, ElseAstInfo, Context, TreeWalker2);
  638. ({'ifchanged', Values, Contents}, TreeWalkerAcc) ->
  639. {IfAstInfo, TreeWalker1} = body_ast(Contents, Context, TreeWalkerAcc),
  640. {ElseAstInfo, TreeWalker2} = empty_ast(TreeWalker1),
  641. ifchanged_values_ast(Values, IfAstInfo, ElseAstInfo, Context, TreeWalker2);
  642. ({'ifchangedelse', '$undefined', IfContents, ElseContents}, TreeWalkerAcc) ->
  643. {IfAstInfo, TreeWalker1} = body_ast(IfContents, Context, TreeWalkerAcc),
  644. {ElseAstInfo, TreeWalker2} = body_ast(ElseContents, Context, TreeWalker1),
  645. ifchanged_contents_ast(IfContents, IfAstInfo, ElseAstInfo, Context, TreeWalker2);
  646. ({'ifchangedelse', Values, IfContents, ElseContents}, TreeWalkerAcc) ->
  647. {IfAstInfo, TreeWalker1} = body_ast(IfContents, Context, TreeWalkerAcc),
  648. {ElseAstInfo, TreeWalker2} = body_ast(ElseContents, Context, TreeWalker1),
  649. ifchanged_values_ast(Values, IfAstInfo, ElseAstInfo, Context, TreeWalker2);
  650. ({'ifelse', Expression, IfContents, ElseContents}, TreeWalkerAcc) ->
  651. {IfAstInfo, TreeWalker1} = body_ast(IfContents, Context, TreeWalkerAcc),
  652. {ElseAstInfo, TreeWalker2} = body_ast(ElseContents, Context, TreeWalker1),
  653. ifelse_ast(Expression, IfAstInfo, ElseAstInfo, Context, TreeWalker2);
  654. ({'ifequal', [Arg1, Arg2], Contents}, TreeWalkerAcc) ->
  655. {IfAstInfo, TreeWalker1} = body_ast(Contents, Context, TreeWalkerAcc),
  656. {ElseAstInfo, TreeWalker2} = empty_ast(TreeWalker1),
  657. ifelse_ast({'expr', "eq", Arg1, Arg2}, IfAstInfo, ElseAstInfo, Context, TreeWalker2);
  658. ({'ifequalelse', [Arg1, Arg2], IfContents, ElseContents}, TreeWalkerAcc) ->
  659. {IfAstInfo, TreeWalker1} = body_ast(IfContents, Context, TreeWalkerAcc),
  660. {ElseAstInfo, TreeWalker2} = body_ast(ElseContents, Context,TreeWalker1),
  661. ifelse_ast({'expr', "eq", Arg1, Arg2}, IfAstInfo, ElseAstInfo, Context, TreeWalker2);
  662. ({'ifnotequal', [Arg1, Arg2], Contents}, TreeWalkerAcc) ->
  663. {IfAstInfo, TreeWalker1} = body_ast(Contents, Context, TreeWalkerAcc),
  664. {ElseAstInfo, TreeWalker2} = empty_ast(TreeWalker1),
  665. ifelse_ast({'expr', "ne", Arg1, Arg2}, IfAstInfo, ElseAstInfo, Context, TreeWalker2);
  666. ({'ifnotequalelse', [Arg1, Arg2], IfContents, ElseContents}, TreeWalkerAcc) ->
  667. {IfAstInfo, TreeWalker1} = body_ast(IfContents, Context, TreeWalkerAcc),
  668. {ElseAstInfo, TreeWalker2} = body_ast(ElseContents, Context, TreeWalker1),
  669. ifelse_ast({'expr', "ne", Arg1, Arg2}, IfAstInfo, ElseAstInfo, Context, TreeWalker2);
  670. ({'include', {string_literal, _, File}, Args}, TreeWalkerAcc) ->
  671. include_ast(unescape_string_literal(File), Args, Context#dtl_context.local_scopes, Context, TreeWalkerAcc);
  672. ({'include_only', {string_literal, _, File}, Args}, TreeWalkerAcc) ->
  673. include_ast(unescape_string_literal(File), Args, [], Context, TreeWalkerAcc);
  674. ({'regroup', {ListVariable, Grouper, {identifier, _, NewVariable}}, Contents}, TreeWalkerAcc) ->
  675. regroup_ast(ListVariable, Grouper, NewVariable, Contents, Context, TreeWalkerAcc);
  676. ({'spaceless', Contents}, TreeWalkerAcc) ->
  677. spaceless_ast(Contents, Context, TreeWalkerAcc);
  678. ({'ssi', Arg}, TreeWalkerAcc) ->
  679. ssi_ast(Arg, Context, TreeWalkerAcc);
  680. ({'ssi_parsed', {string_literal, _, FileName}}, TreeWalkerAcc) ->
  681. include_ast(unescape_string_literal(FileName), [], Context#dtl_context.local_scopes, Context, TreeWalkerAcc);
  682. ({'string', _Pos, String}, TreeWalkerAcc) ->
  683. string_ast(String, Context, TreeWalkerAcc);
  684. ({'tag', {identifier, _, Name}, Args}, TreeWalkerAcc) ->
  685. tag_ast(Name, Args, Context, TreeWalkerAcc);
  686. ({'templatetag', {_, _, TagName}}, TreeWalkerAcc) ->
  687. templatetag_ast(TagName, Context, TreeWalkerAcc);
  688. ({'trans', Value}, TreeWalkerAcc) ->
  689. translated_ast(Value, Context, TreeWalkerAcc);
  690. ({'widthratio', Numerator, Denominator, Scale}, TreeWalkerAcc) ->
  691. widthratio_ast(Numerator, Denominator, Scale, Context, TreeWalkerAcc);
  692. ({'with', Args, Contents}, TreeWalkerAcc) ->
  693. with_ast(Args, Contents, Context, TreeWalkerAcc);
  694. ({'extension', Tag}, TreeWalkerAcc) ->
  695. extension_ast(Tag, Context, TreeWalkerAcc);
  696. (ValueToken, TreeWalkerAcc) ->
  697. {{ValueAst,ValueInfo},ValueTreeWalker} = value_ast(ValueToken, true, true, Context, TreeWalkerAcc),
  698. {{format(ValueAst, Context, ValueTreeWalker),ValueInfo},ValueTreeWalker}
  699. end, TreeWalker, DjangoParseTree),
  700. {AstList, {Info, TreeWalker3}} = lists:mapfoldl(
  701. fun({Ast, Info}, {InfoAcc, TreeWalkerAcc}) ->
  702. PresetVars = lists:foldl(fun
  703. (X, Acc) ->
  704. case proplists:lookup(X, Context#dtl_context.vars) of
  705. none ->
  706. Acc;
  707. Val ->
  708. [erl_syntax:abstract(Val) | Acc]
  709. end
  710. end, [], Info#ast_info.var_names),
  711. case PresetVars of
  712. [] ->
  713. {Ast, {merge_info(Info, InfoAcc), TreeWalkerAcc}};
  714. _ ->
  715. Counter = TreeWalkerAcc#treewalker.counter,
  716. Name = lists:concat([pre_render, Counter]),
  717. Ast1 = erl_syntax:application(none, erl_syntax:atom(Name),
  718. [erl_syntax:list(PresetVars)]),
  719. PreRenderAst = erl_syntax:function(erl_syntax:atom(Name),
  720. [erl_syntax:clause([erl_syntax:variable("_Variables")], none, [Ast])]),
  721. PreRenderAsts = Info#ast_info.pre_render_asts,
  722. Info1 = Info#ast_info{pre_render_asts = [PreRenderAst | PreRenderAsts]},
  723. {Ast1, {merge_info(Info1, InfoAcc), TreeWalkerAcc#treewalker{counter = Counter + 1}}}
  724. end
  725. end, {#ast_info{}, TreeWalker2}, AstInfoList),
  726. {{erl_syntax:list(AstList), Info}, TreeWalker3}.
  727. value_ast(ValueToken, AsString, EmptyIfUndefined, Context, TreeWalker) ->
  728. case ValueToken of
  729. {'expr', Operator, Value} ->
  730. {{ValueAst,InfoValue}, TreeWalker1} = value_ast(Value, false, EmptyIfUndefined, Context, TreeWalker),
  731. Ast = erl_syntax:application(erl_syntax:atom(erlydtl_runtime),
  732. erl_syntax:atom(Operator),
  733. [ValueAst]),
  734. {{Ast, InfoValue}, TreeWalker1};
  735. {'expr', Operator, Value1, Value2} ->
  736. {{Value1Ast,InfoValue1}, TreeWalker1} = value_ast(Value1, false, EmptyIfUndefined, Context, TreeWalker),
  737. {{Value2Ast,InfoValue2}, TreeWalker2} = value_ast(Value2, false, EmptyIfUndefined, Context, TreeWalker1),
  738. Ast = erl_syntax:application(erl_syntax:atom(erlydtl_runtime),
  739. erl_syntax:atom(Operator),
  740. [Value1Ast, Value2Ast]),
  741. {{Ast, merge_info(InfoValue1,InfoValue2)}, TreeWalker2};
  742. {'string_literal', _Pos, String} ->
  743. string_ast(unescape_string_literal(String), Context, TreeWalker);
  744. {'number_literal', _Pos, Number} ->
  745. case AsString of
  746. true -> string_ast(Number, Context, TreeWalker);
  747. false -> {{erl_syntax:integer(list_to_integer(Number)), #ast_info{}}, TreeWalker}
  748. end;
  749. {'apply_filter', Variable, Filter} ->
  750. filter_ast(Variable, Filter, Context, TreeWalker);
  751. {'attribute', _} = Variable ->
  752. {Ast, VarName} = resolve_variable_ast(Variable, Context, EmptyIfUndefined),
  753. {{Ast, #ast_info{var_names = [VarName]}}, TreeWalker};
  754. {'variable', _} = Variable ->
  755. {Ast, VarName} = resolve_variable_ast(Variable, Context, EmptyIfUndefined),
  756. {{Ast, #ast_info{var_names = [VarName]}}, TreeWalker};
  757. {extension, Tag} ->
  758. extension_ast(Tag, Context, TreeWalker)
  759. end.
  760. extension_ast(Tag, Context, TreeWalker) ->
  761. case call_extension(Context, compile_ast, [Tag, Context, TreeWalker]) of
  762. undefined ->
  763. throw({error, {unknown_extension, Tag}});
  764. Result ->
  765. Result
  766. end.
  767. merge_info(Info1, Info2) ->
  768. #ast_info{
  769. dependencies =
  770. lists:merge(
  771. lists:sort(Info1#ast_info.dependencies),
  772. lists:sort(Info2#ast_info.dependencies)),
  773. var_names =
  774. lists:merge(
  775. lists:sort(Info1#ast_info.var_names),
  776. lists:sort(Info2#ast_info.var_names)),
  777. translatable_strings =
  778. lists:merge(
  779. lists:sort(Info1#ast_info.translatable_strings),
  780. lists:sort(Info2#ast_info.translatable_strings)),
  781. translated_blocks =
  782. lists:merge(
  783. lists:sort(Info1#ast_info.translated_blocks),
  784. lists:sort(Info2#ast_info.translated_blocks)),
  785. custom_tags =
  786. lists:merge(
  787. lists:sort(Info1#ast_info.custom_tags),
  788. lists:sort(Info2#ast_info.custom_tags)),
  789. pre_render_asts =
  790. lists:merge(
  791. Info1#ast_info.pre_render_asts,
  792. Info2#ast_info.pre_render_asts)}.
  793. with_dependencies([], Args) ->
  794. Args;
  795. with_dependencies([Dependency | Rest], Args) ->
  796. with_dependencies(Rest, with_dependency(Dependency, Args)).
  797. with_dependency(FilePath, {{Ast, Info}, TreeWalker}) ->
  798. {{Ast, Info#ast_info{dependencies = [FilePath | Info#ast_info.dependencies]}}, TreeWalker}.
  799. empty_ast(TreeWalker) ->
  800. {{erl_syntax:list([]), #ast_info{}}, TreeWalker}.
  801. blocktrans_ast(ArgList, Contents, Context, TreeWalker) ->
  802. {NewScope, {ArgInfo, TreeWalker1}} = lists:mapfoldl(fun
  803. ({{identifier, _, LocalVarName}, Value}, {AstInfo1, TreeWalker1}) ->
  804. {{Ast, Info}, TreeWalker2} = value_ast(Value, false, false, Context, TreeWalker1),
  805. {{LocalVarName, Ast}, {merge_info(AstInfo1, Info), TreeWalker2}}
  806. end, {#ast_info{}, TreeWalker}, ArgList),
  807. NewContext = Context#dtl_context{ local_scopes = [NewScope|Context#dtl_context.local_scopes] },
  808. SourceText = lists:flatten(erlydtl_unparser:unparse(Contents)),
  809. {{DefaultAst, AstInfo}, TreeWalker2} = body_ast(Contents, NewContext, TreeWalker1),
  810. MergedInfo = merge_info(AstInfo, ArgInfo),
  811. case Context#dtl_context.blocktrans_fun of
  812. none ->
  813. {{DefaultAst, MergedInfo}, TreeWalker2};
  814. BlockTransFun when is_function(BlockTransFun) ->
  815. {FinalAstInfo, FinalTreeWalker, Clauses} = lists:foldr(fun(Locale, {AstInfoAcc, ThisTreeWalker, ClauseAcc}) ->
  816. case BlockTransFun(SourceText, Locale) of
  817. default ->
  818. {AstInfoAcc, ThisTreeWalker, ClauseAcc};
  819. Body ->
  820. {ok, DjangoParseTree} = parse(Body, Context),
  821. {{ThisAst, ThisAstInfo}, TreeWalker3} = body_ast(DjangoParseTree, NewContext, ThisTreeWalker),
  822. {merge_info(ThisAstInfo, AstInfoAcc), TreeWalker3,
  823. [erl_syntax:clause([erl_syntax:string(Locale)], none, [ThisAst])|ClauseAcc]}
  824. end
  825. end, {MergedInfo, TreeWalker2, []}, Context#dtl_context.blocktrans_locales),
  826. Ast = erl_syntax:case_expr(erl_syntax:variable("_CurrentLocale"),
  827. Clauses ++ [erl_syntax:clause([erl_syntax:underscore()], none, [DefaultAst])]),
  828. {{Ast, FinalAstInfo#ast_info{ translated_blocks = [SourceText] }}, FinalTreeWalker}
  829. end.
  830. translated_ast({string_literal, _, String}, Context, TreeWalker) ->
  831. NewStr = unescape_string_literal(String),
  832. DefaultString = case Context#dtl_context.locale of
  833. none -> NewStr;
  834. Locale -> erlydtl_i18n:translate(NewStr,Locale)
  835. end,
  836. translated_ast2(erl_syntax:string(NewStr), erl_syntax:string(DefaultString),
  837. #ast_info{translatable_strings = [NewStr]}, TreeWalker);
  838. translated_ast(ValueToken, Context, TreeWalker) ->
  839. {{Ast, Info}, TreeWalker1} = value_ast(ValueToken, true, false, Context, TreeWalker),
  840. translated_ast2(Ast, Ast, Info, TreeWalker1).
  841. translated_ast2(NewStrAst, DefaultStringAst, AstInfo, TreeWalker) ->
  842. StringLookupAst = erl_syntax:application(
  843. erl_syntax:atom(erlydtl_runtime),
  844. erl_syntax:atom(translate),
  845. [NewStrAst, erl_syntax:variable("_TranslationFun"), DefaultStringAst]),
  846. {{StringLookupAst, AstInfo}, TreeWalker}.
  847. % Completely unnecessary in ErlyDTL (use {{ "{%" }} etc), but implemented for compatibility.
  848. templatetag_ast("openblock", Context, TreeWalker) ->
  849. string_ast("{%", Context, TreeWalker);
  850. templatetag_ast("closeblock", Context, TreeWalker) ->
  851. string_ast("%}", Context, TreeWalker);
  852. templatetag_ast("openvariable", Context, TreeWalker) ->
  853. string_ast("{{", Context, TreeWalker);
  854. templatetag_ast("closevariable", Context, TreeWalker) ->
  855. string_ast("}}", Context, TreeWalker);
  856. templatetag_ast("openbrace", Context, TreeWalker) ->
  857. string_ast("{", Context, TreeWalker);
  858. templatetag_ast("closebrace", Context, TreeWalker) ->
  859. string_ast("}", Context, TreeWalker);
  860. templatetag_ast("opencomment", Context, TreeWalker) ->
  861. string_ast("{#", Context, TreeWalker);
  862. templatetag_ast("closecomment", Context, TreeWalker) ->
  863. string_ast("#}", Context, TreeWalker).
  864. widthratio_ast(Numerator, Denominator, Scale, Context, TreeWalker) ->
  865. {{NumAst, NumInfo}, TreeWalker1} = value_ast(Numerator, false, true, Context, TreeWalker),
  866. {{DenAst, DenInfo}, TreeWalker2} = value_ast(Denominator, false, true, Context, TreeWalker1),
  867. {{ScaleAst, ScaleInfo}, TreeWalker3} = value_ast(Scale, false, true, Context, TreeWalker2),
  868. {{format_number_ast(erl_syntax:application(
  869. erl_syntax:atom(erlydtl_runtime),
  870. erl_syntax:atom(widthratio),
  871. [NumAst, DenAst, ScaleAst])), merge_info(ScaleInfo, merge_info(NumInfo, DenInfo))},
  872. TreeWalker3}.
  873. binary_string(String) ->
  874. erl_syntax:binary([erl_syntax:binary_field(erl_syntax:integer(X)) || X <- String]).
  875. string_ast(String, #dtl_context{ binary_strings = true }, TreeWalker) when is_list(String) ->
  876. {{binary_string(String), #ast_info{}}, TreeWalker};
  877. string_ast(String, #dtl_context{ binary_strings = false }, TreeWalker) when is_list(String) ->
  878. {{erl_syntax:string(String), #ast_info{}}, TreeWalker}; %% less verbose AST, better for development and debugging
  879. string_ast(S, Context, TreeWalker) when is_atom(S) ->
  880. string_ast(atom_to_list(S), Context, TreeWalker).
  881. include_ast(File, ArgList, Scopes, Context, TreeWalker) ->
  882. FilePath = full_path(File, Context#dtl_context.doc_root),
  883. case parse(FilePath, Context) of
  884. {ok, InclusionParseTree, CheckSum} ->
  885. {NewScope, {ArgInfo, TreeWalker1}} = lists:mapfoldl(fun
  886. ({{identifier, _, LocalVarName}, Value}, {AstInfo1, TreeWalker1}) ->
  887. {{Ast, Info}, TreeWalker2} = value_ast(Value, false, false, Context, TreeWalker1),
  888. {{LocalVarName, Ast}, {merge_info(AstInfo1, Info), TreeWalker2}}
  889. end, {#ast_info{}, TreeWalker}, ArgList),
  890. {{BodyAst, BodyInfo}, TreeWalker2} = with_dependency({FilePath, CheckSum},
  891. body_ast(InclusionParseTree, Context#dtl_context{
  892. parse_trail = [FilePath | Context#dtl_context.parse_trail],
  893. local_scopes = [NewScope|Scopes]
  894. }, TreeWalker1)),
  895. {{BodyAst, merge_info(BodyInfo, ArgInfo)}, TreeWalker2};
  896. Err ->
  897. throw(Err)
  898. end.
  899. % include at run-time
  900. ssi_ast(FileName, Context, TreeWalker) ->
  901. {{Ast, Info}, TreeWalker1} = value_ast(FileName, true, true, Context, TreeWalker),
  902. {Mod, Fun} = Context#dtl_context.reader,
  903. {{erl_syntax:application(
  904. erl_syntax:atom(erlydtl_runtime),
  905. erl_syntax:atom(read_file),
  906. [erl_syntax:atom(Mod), erl_syntax:atom(Fun), erl_syntax:string(Context#dtl_context.doc_root), Ast]), Info}, TreeWalker1}.
  907. filter_tag_ast(FilterList, Contents, Context, TreeWalker) ->
  908. {{InnerAst, Info}, TreeWalker1} = body_ast(Contents, Context#dtl_context{auto_escape = did}, TreeWalker),
  909. {{FilteredAst, FilteredInfo}, TreeWalker2} = lists:foldl(fun
  910. ([{identifier, _, 'escape'}], {{AstAcc, InfoAcc}, TreeWalkerAcc}) ->
  911. {{AstAcc, InfoAcc}, TreeWalkerAcc#treewalker{safe = true}};
  912. ([{identifier, _, 'safe'}], {{AstAcc, InfoAcc}, TreeWalkerAcc}) ->
  913. {{AstAcc, InfoAcc}, TreeWalkerAcc#treewalker{safe = true}};
  914. ([{identifier, _, 'safeseq'}], {{AstAcc, InfoAcc}, TreeWalkerAcc}) ->
  915. {{AstAcc, InfoAcc}, TreeWalkerAcc#treewalker{safe = true}};
  916. (Filter, {{AstAcc, InfoAcc}, TreeWalkerAcc}) ->
  917. {Ast, AstInfo} = filter_ast1(Filter, AstAcc, Context),
  918. {{Ast, merge_info(InfoAcc, AstInfo)}, TreeWalkerAcc}
  919. end, {{erl_syntax:application(
  920. erl_syntax:atom(erlang),
  921. erl_syntax:atom(iolist_to_binary),
  922. [InnerAst]), Info}, TreeWalker1}, FilterList),
  923. EscapedAst = case search_for_escape_filter(lists:reverse(FilterList), Context) of
  924. on ->
  925. erl_syntax:application(
  926. erl_syntax:atom(erlydtl_filters),
  927. erl_syntax:atom(force_escape),
  928. [FilteredAst]);
  929. _ ->
  930. FilteredAst
  931. end,
  932. {{EscapedAst, FilteredInfo}, TreeWalker2}.
  933. search_for_escape_filter(FilterList, #dtl_context{auto_escape = on}) ->
  934. search_for_safe_filter(FilterList);
  935. search_for_escape_filter(_, #dtl_context{auto_escape = did}) ->
  936. off;
  937. search_for_escape_filter([[{identifier, _, 'escape'}]|Rest], _Context) ->
  938. search_for_safe_filter(Rest);
  939. search_for_escape_filter([_|Rest], Context) ->
  940. search_for_escape_filter(Rest, Context);
  941. search_for_escape_filter([], _Context) ->
  942. off.
  943. search_for_safe_filter([[{identifier, _, 'safe'}]|_]) ->
  944. off;
  945. search_for_safe_filter([[{identifier, _, 'safeseq'}]|_]) ->
  946. off;
  947. search_for_safe_filter([_|Rest]) ->
  948. search_for_safe_filter(Rest);
  949. search_for_safe_filter([]) ->
  950. on.
  951. filter_ast(Variable, Filter, Context, TreeWalker) ->
  952. % the escape filter is special; it is always applied last, so we have to go digging for it
  953. % AutoEscape = 'did' means we (will have) decided whether to escape the current variable,
  954. % so don't do any more escaping
  955. {{UnescapedAst, Info}, TreeWalker2} = filter_ast_noescape(Variable, Filter,
  956. Context#dtl_context{auto_escape = did}, TreeWalker),
  957. EscapedAst = case search_for_escape_filter(Variable, Filter, Context) of
  958. on ->
  959. erl_syntax:application(
  960. erl_syntax:atom(erlydtl_filters),
  961. erl_syntax:atom(force_escape),
  962. [UnescapedAst]);
  963. _ ->
  964. UnescapedAst
  965. end,
  966. {{EscapedAst, Info}, TreeWalker2}.
  967. filter_ast_noescape(Variable, [{identifier, _, 'escape'}], Context, TreeWalker) ->
  968. value_ast(Variable, true, false, Context, TreeWalker#treewalker{safe = true});
  969. filter_ast_noescape(Variable, [{identifier, _, 'safe'}], Context, TreeWalker) ->
  970. value_ast(Variable, true, false, Context, TreeWalker#treewalker{safe = true});
  971. filter_ast_noescape(Variable, [{identifier, _, 'safeseq'}], Context, TreeWalker) ->
  972. value_ast(Variable, true, false, Context, TreeWalker#treewalker{safe = true});
  973. filter_ast_noescape(Variable, Filter, Context, TreeWalker) ->
  974. {{VariableAst, Info1}, TreeWalker2} = value_ast(Variable, true, false, Context, TreeWalker),
  975. {VarValue, Info2} = filter_ast1(Filter, VariableAst, Context),
  976. {{VarValue, merge_info(Info1, Info2)}, TreeWalker2}.
  977. filter_ast1([{identifier, _, Name}, {string_literal, _, ArgName}], VariableAst, #dtl_context{ binary_strings = true } = Context) ->
  978. filter_ast2(Name, VariableAst, [binary_string(unescape_string_literal(ArgName))], [], Context);
  979. filter_ast1([{identifier, _, Name}, {string_literal, _, ArgName}], VariableAst, #dtl_context{ binary_strings = false } = Context) ->
  980. filter_ast2(Name, VariableAst, [erl_syntax:string(unescape_string_literal(ArgName))], [], Context);
  981. filter_ast1([{identifier, _, Name}, {number_literal, _, ArgName}], VariableAst, Context) ->
  982. filter_ast2(Name, VariableAst, [erl_syntax:integer(list_to_integer(ArgName))], [], Context);
  983. filter_ast1([{identifier, _, Name}, ArgVariable], VariableAst, Context) ->
  984. {ArgAst, ArgVarName} = resolve_variable_ast(ArgVariable, Context, false),
  985. filter_ast2(Name, VariableAst, [ArgAst], [ArgVarName], Context);
  986. filter_ast1([{identifier, _, Name}], VariableAst, Context) ->
  987. filter_ast2(Name, VariableAst, [], [], Context).
  988. filter_ast2(Name, VariableAst, [], VarNames, #dtl_context{ filter_modules = [Module|Rest] } = Context) ->
  989. case lists:member({Name, 1}, Module:module_info(exports)) of
  990. true ->
  991. {erl_syntax:application(erl_syntax:atom(Module), erl_syntax:atom(Name),
  992. [VariableAst]), #ast_info{var_names = VarNames}};
  993. false ->
  994. filter_ast2(Name, VariableAst, [], VarNames, Context#dtl_context{ filter_modules = Rest })
  995. end;
  996. filter_ast2(Name, VariableAst, [Arg], VarNames, #dtl_context{ filter_modules = [Module|Rest] } = Context) ->
  997. case lists:member({Name, 2}, Module:module_info(exports)) of
  998. true ->
  999. {erl_syntax:application(erl_syntax:atom(Module), erl_syntax:atom(Name),
  1000. [VariableAst, Arg]), #ast_info{var_names = VarNames}};
  1001. false ->
  1002. filter_ast2(Name, VariableAst, [Arg], VarNames, Context#dtl_context{ filter_modules = Rest })
  1003. end.
  1004. search_for_escape_filter(Variable, Filter, #dtl_context{auto_escape = on}) ->
  1005. search_for_safe_filter(Variable, Filter);
  1006. search_for_escape_filter(_, _, #dtl_context{auto_escape = did}) ->
  1007. off;
  1008. search_for_escape_filter(Variable, [{identifier, _, 'escape'}] = Filter, _Context) ->
  1009. search_for_safe_filter(Variable, Filter);
  1010. search_for_escape_filter({apply_filter, Variable, Filter}, _, Context) ->
  1011. search_for_escape_filter(Variable, Filter, Context);
  1012. search_for_escape_filter(_Variable, _Filter, _Context) ->
  1013. off.
  1014. search_for_safe_filter(_, [{identifier, _, 'safe'}]) ->
  1015. off;
  1016. search_for_safe_filter(_, [{identifier, _, 'safeseq'}]) ->
  1017. off;
  1018. search_for_safe_filter({apply_filter, Variable, Filter}, _) ->
  1019. search_for_safe_filter(Variable, Filter);
  1020. search_for_safe_filter(_Variable, _Filter) ->
  1021. on.
  1022. resolve_variable_ast(VarTuple, Context, true) ->
  1023. resolve_variable_ast1(VarTuple, Context, 'fetch_value');
  1024. resolve_variable_ast(VarTuple, Context, false) ->
  1025. resolve_variable_ast1(VarTuple, Context, 'find_value').
  1026. resolve_variable_ast1({attribute, {{identifier, {Row, Col}, AttrName}, Variable}}, Context, FinderFunction) ->
  1027. {VarAst, VarName} = resolve_variable_ast1(Variable, Context, FinderFunction),
  1028. FileNameAst = case Context#dtl_context.parse_trail of
  1029. [] -> erl_syntax:atom(undefined);
  1030. [H|_] -> erl_syntax:string(H)
  1031. end,
  1032. {erl_syntax:application(erl_syntax:atom(erlydtl_runtime), erl_syntax:atom(FinderFunction),
  1033. [erl_syntax:atom(AttrName), VarAst, FileNameAst,
  1034. erl_syntax:tuple([erl_syntax:integer(Row), erl_syntax:integer(Col)])
  1035. ]), VarName};
  1036. resolve_variable_ast1({variable, {identifier, {Row, Col}, VarName}}, Context, FinderFunction) ->
  1037. VarValue = case resolve_scoped_variable_ast(VarName, Context) of
  1038. undefined ->
  1039. FileNameAst = case Context#dtl_context.parse_trail of
  1040. [] -> erl_syntax:atom(undefined);
  1041. [H|_] -> erl_syntax:string(H)
  1042. end,
  1043. erl_syntax:application(erl_syntax:atom(erlydtl_runtime), erl_syntax:atom(FinderFunction),
  1044. [erl_syntax:atom(VarName), erl_syntax:variable("_Variables"), FileNameAst,
  1045. erl_syntax:tuple([erl_syntax:integer(Row), erl_syntax:integer(Col)])
  1046. ]);
  1047. Val ->
  1048. Val
  1049. end,
  1050. {VarValue, VarName};
  1051. resolve_variable_ast1(What, _Context, _FinderFunction) ->
  1052. error_logger:error_msg("~p:resolve_variable_ast unhandled: ~p~n", [?MODULE, What]).
  1053. resolve_scoped_variable_ast(VarName, Context) ->
  1054. lists:foldl(fun(Scope, Value) ->
  1055. case Value of
  1056. undefined -> proplists:get_value(VarName, Scope);
  1057. _ -> Value
  1058. end
  1059. end, undefined, Context#dtl_context.local_scopes).
  1060. format(Ast, Context, TreeWalker) ->
  1061. auto_escape(format_number_ast(Ast), Context, TreeWalker).
  1062. format_number_ast(Ast) ->
  1063. erl_syntax:application(erl_syntax:atom(erlydtl_filters), erl_syntax:atom(format_number),
  1064. [Ast]).
  1065. auto_escape(Value, _, #treewalker{safe = true}) ->
  1066. Value;
  1067. auto_escape(Value, #dtl_context{auto_escape = on}, _) ->
  1068. erl_syntax:application(erl_syntax:atom(erlydtl_filters), erl_syntax:atom(force_escape), [Value]);
  1069. auto_escape(Value, _, _) ->
  1070. Value.
  1071. firstof_ast(Vars, Context, TreeWalker) ->
  1072. body_ast([lists:foldr(fun
  1073. ({L, _, _}=Var, []) when L=:=string_literal;L=:=number_literal ->
  1074. Var;
  1075. ({L, _, _}, _) when L=:=string_literal;L=:=number_literal ->
  1076. erlang:error(errbadliteral);
  1077. (Var, []) ->
  1078. {'ifelse', Var, [Var], []};
  1079. (Var, Acc) ->
  1080. {'ifelse', Var, [Var], [Acc]} end,
  1081. [], Vars)], Context, TreeWalker).
  1082. ifelse_ast(Expression, {IfContentsAst, IfContentsInfo}, {ElseContentsAst, ElseContentsInfo}, Context, TreeWalker) ->
  1083. Info = merge_info(IfContentsInfo, ElseContentsInfo),
  1084. {{Ast, ExpressionInfo}, TreeWalker1} = value_ast(Expression, false, false, Context, TreeWalker),
  1085. {{erl_syntax:case_expr(erl_syntax:application(erl_syntax:atom(erlydtl_runtime), erl_syntax:atom(is_true), [Ast]),
  1086. [erl_syntax:clause([erl_syntax:atom(true)], none,
  1087. [IfContentsAst]),
  1088. erl_syntax:clause([erl_syntax:underscore()], none,
  1089. [ElseContentsAst])
  1090. ]), merge_info(ExpressionInfo, Info)}, TreeWalker1}.
  1091. with_ast(ArgList, Contents, Context, TreeWalker) ->
  1092. {ArgAstList, {ArgInfo, TreeWalker1}} = lists:mapfoldl(fun
  1093. ({{identifier, _, _LocalVarName}, Value}, {AstInfo1, TreeWalker1}) ->
  1094. {{Ast, Info}, TreeWalker2} = value_ast(Value, false, false, Context, TreeWalker1),
  1095. {Ast, {merge_info(AstInfo1, Info), TreeWalker2}}
  1096. end, {#ast_info{}, TreeWalker}, ArgList),
  1097. NewScope = lists:map(fun({{identifier, _, LocalVarName}, _Value}) ->
  1098. {LocalVarName, erl_syntax:variable(lists:concat(["Var_", LocalVarName]))}
  1099. end, ArgList),
  1100. {{InnerAst, InnerInfo}, TreeWalker2} = body_ast(Contents,
  1101. Context#dtl_context{local_scopes = [NewScope|Context#dtl_context.local_scopes]}, TreeWalker1),
  1102. {{erl_syntax:application(
  1103. erl_syntax:fun_expr([
  1104. erl_syntax:clause(lists:map(fun({_, Var}) -> Var end, NewScope), none,
  1105. [InnerAst])]), ArgAstList), merge_info(ArgInfo, InnerInfo)}, TreeWalker2}.
  1106. regroup_ast(ListVariable, GrouperVariable, LocalVarName, Contents, Context, TreeWalker) ->
  1107. {{ListAst, ListInfo}, TreeWalker1} = value_ast(ListVariable, false, true, Context, TreeWalker),
  1108. NewScope = [{LocalVarName, erl_syntax:variable(lists:concat(["Var_", LocalVarName]))}],
  1109. {{InnerAst, InnerInfo}, TreeWalker2} = body_ast(Contents,
  1110. Context#dtl_context{ local_scopes = [NewScope|Context#dtl_context.local_scopes] }, TreeWalker1),
  1111. Ast = {erl_syntax:application(
  1112. erl_syntax:fun_expr([
  1113. erl_syntax:clause([erl_syntax:variable(lists:concat(["Var_", LocalVarName]))], none,
  1114. [InnerAst])]),
  1115. [erl_syntax:application(erl_syntax:atom(erlydtl_runtime), erl_syntax:atom(regroup),
  1116. [ListAst, regroup_filter(GrouperVariable,[])])]), merge_info(ListInfo, InnerInfo)},
  1117. {Ast,TreeWalker2}.
  1118. regroup_filter({attribute,{{identifier,_,Ident},Next}},Acc) ->
  1119. regroup_filter(Next,[erl_syntax:atom(Ident)|Acc]);
  1120. regroup_filter({variable,{identifier,_,Var}},Acc) ->
  1121. erl_syntax:list([erl_syntax:atom(Var)|Acc]).
  1122. for_loop_ast(IteratorList, LoopValue, IsReversed, Contents, {EmptyContentsAst, EmptyContentsInfo}, Context, TreeWalker) ->
  1123. Vars = lists:map(fun({identifier, _, Iterator}) ->
  1124. erl_syntax:variable(lists:concat(["Var_", Iterator]))
  1125. end, IteratorList),
  1126. {{InnerAst, Info}, TreeWalker1} = body_ast(Contents,
  1127. Context#dtl_context{local_scopes = [
  1128. [{'forloop', erl_syntax:variable("Counters")} | lists:map(
  1129. fun({identifier, _, Iterator}) ->
  1130. {Iterator, erl_syntax:variable(lists:concat(["Var_", Iterator]))}
  1131. end, IteratorList)] | Context#dtl_context.local_scopes]}, TreeWalker),
  1132. CounterAst = erl_syntax:application(erl_syntax:atom(erlydtl_runtime),
  1133. erl_syntax:atom(increment_counter_stats), [erl_syntax:variable("Counters")]),
  1134. {{LoopValueAst, LoopValueInfo}, TreeWalker2} = value_ast(LoopValue, false, true, Context, TreeWalker1),
  1135. LoopValueAst0 = case IsReversed of
  1136. true -> erl_syntax:application(erl_syntax:atom(lists), erl_syntax:atom(reverse), [LoopValueAst]);
  1137. false -> LoopValueAst
  1138. end,
  1139. CounterVars0 = case resolve_scoped_variable_ast('forloop', Context) of
  1140. undefined ->
  1141. erl_syntax:application(erl_syntax:atom(erlydtl_runtime), erl_syntax:atom(init_counter_stats), [LoopValueAst0]);
  1142. Value ->
  1143. erl_syntax:application(erl_syntax:atom(erlydtl_runtime), erl_syntax:atom(init_counter_stats), [LoopValueAst0, Value])
  1144. end,
  1145. {{erl_syntax:case_expr(
  1146. erl_syntax:application(
  1147. erl_syntax:atom('erlydtl_runtime'), erl_syntax:atom('forloop'),
  1148. [erl_syntax:fun_expr([
  1149. erl_syntax:clause([erl_syntax:tuple(Vars), erl_syntax:variable("Counters")], none,
  1150. [erl_syntax:tuple([InnerAst, CounterAst])]),
  1151. erl_syntax:clause(case Vars of [H] -> [H, erl_syntax:variable("Counters")];
  1152. _ -> [erl_syntax:list(Vars), erl_syntax:variable("Counters")] end, none,
  1153. [erl_syntax:tuple([InnerAst, CounterAst])])
  1154. ]),
  1155. CounterVars0, LoopValueAst0]),
  1156. [erl_syntax:clause(
  1157. [erl_syntax:tuple([erl_syntax:underscore(),
  1158. erl_syntax:list([erl_syntax:tuple([erl_syntax:atom(counter), erl_syntax:integer(1)])],
  1159. erl_syntax:underscore())])],
  1160. none, [EmptyContentsAst]),
  1161. erl_syntax:clause(
  1162. [erl_syntax:tuple([erl_syntax:variable("L"), erl_syntax:underscore()])],
  1163. none, [erl_syntax:variable("L")])]
  1164. ),
  1165. merge_info(merge_info(Info, EmptyContentsInfo), LoopValueInfo)
  1166. }, TreeWalker2}.
  1167. ifchanged_values_ast(Values, {IfContentsAst, IfContentsInfo}, {ElseContentsAst, ElseContentsInfo}, Context, TreeWalker) ->
  1168. Info = merge_info(IfContentsInfo, ElseContentsInfo),
  1169. ValueAstFun = fun(Expr, {LTreeWalker, LInfo, Acc}) ->
  1170. {{EAst, EInfo}, ETw} = value_ast(Expr, false, true, Context, LTreeWalker),
  1171. {ETw, merge_info(LInfo, EInfo), [erl_syntax:tuple([erl_syntax:integer(erlang:phash2(Expr)), EAst])|Acc]} end,
  1172. {TreeWalker1, MergedInfo, Changed} = lists:foldl(ValueAstFun, {TreeWalker, Info, []}, Values),
  1173. {{erl_syntax:case_expr(erl_syntax:application(erl_syntax:atom(erlydtl_runtime), erl_syntax:atom(ifchanged), [erl_syntax:list(Changed)]),
  1174. [erl_syntax:clause([erl_syntax:atom(true)], none,
  1175. [IfContentsAst]),
  1176. erl_syntax:clause([erl_syntax:underscore()], none,
  1177. [ElseContentsAst])
  1178. ]), MergedInfo}, TreeWalker1}.
  1179. ifchanged_contents_ast(Contents, {IfContentsAst, IfContentsInfo}, {ElseContentsAst, ElseContentsInfo}, _Context, TreeWalker) ->
  1180. Info = merge_info(IfContentsInfo, ElseContentsInfo),
  1181. Key = erl_syntax:integer(erlang:phash2(Contents)),
  1182. {{erl_syntax:case_expr(erl_syntax:application(erl_syntax:atom(erlydtl_runtime), erl_syntax:atom(ifchanged), [erl_syntax:list([erl_syntax:tuple([Key, IfContentsAst])])]),
  1183. [erl_syntax:clause([erl_syntax:atom(true)], none,
  1184. [IfContentsAst]),
  1185. erl_syntax:clause([erl_syntax:underscore()], none,
  1186. [ElseContentsAst])
  1187. ]), Info}, TreeWalker}.
  1188. cycle_ast(Names, Context, TreeWalker) ->
  1189. {NamesTuple, VarNames} = lists:mapfoldl(fun
  1190. ({string_literal, _, Str}, VarNamesAcc) ->
  1191. {{S, _}, _} = string_ast(unescape_string_literal(Str), Context, TreeWalker),
  1192. {S, VarNamesAcc};
  1193. ({variable, _}=Var, VarNamesAcc) ->
  1194. {V, VarName} = resolve_variable_ast(Var, Context, true),
  1195. {V, [VarName|VarNamesAcc]};
  1196. ({number_literal, _, Num}, VarNamesAcc) ->
  1197. {format(erl_syntax:integer(Num), Context, TreeWalker), VarNamesAcc};
  1198. (_, VarNamesAcc) ->
  1199. {[], VarNamesAcc}
  1200. end, [], Names),
  1201. {{erl_syntax:application(
  1202. erl_syntax:atom('erlydtl_runtime'), erl_syntax:atom('cycle'),
  1203. [erl_syntax:tuple(NamesTuple), erl_syntax:variable("Counters")]), #ast_info{ var_names = VarNames }}, TreeWalker}.
  1204. %% Older Django templates treat cycle with comma-delimited elements as strings
  1205. cycle_compat_ast(Names, Context, TreeWalker) ->
  1206. NamesTuple = lists:map(fun
  1207. ({identifier, _, X}) ->
  1208. {{S, _}, _} = string_ast(X, Context, TreeWalker),
  1209. S
  1210. end, Names),
  1211. {{erl_syntax:application(
  1212. erl_syntax:atom('erlydtl_runtime'), erl_syntax:atom('cycle'),
  1213. [erl_syntax:tuple(NamesTuple), erl_syntax:variable("Counters")]), #ast_info{}}, TreeWalker}.
  1214. now_ast(FormatString, Context, TreeWalker) ->
  1215. % Note: we can't use unescape_string_literal here
  1216. % because we want to allow escaping in the format string.
  1217. % We only want to remove the surrounding escapes,
  1218. % i.e. \"foo\" becomes "foo"
  1219. UnescapeOuter = string:strip(FormatString, both, 34),
  1220. {{StringAst, Info}, TreeWalker1} = string_ast(UnescapeOuter, Context, TreeWalker),
  1221. {{erl_syntax:application(
  1222. erl_syntax:atom(erlydtl_dateformat),
  1223. erl_syntax:atom(format),
  1224. [StringAst]), Info}, TreeWalker1}.
  1225. spaceless_ast(Contents, Context, TreeWalker) ->
  1226. {{Ast, Info}, TreeWalker1} = body_ast(Contents, Context, TreeWalker),
  1227. {{erl_syntax:application(
  1228. erl_syntax:atom(erlydtl_runtime),
  1229. erl_syntax:atom(spaceless),
  1230. [Ast]), Info}, TreeWalker1}.
  1231. unescape_string_literal(String) ->
  1232. unescape_string_literal(string:strip(String, both, 34), [], noslash).
  1233. unescape_string_literal([], Acc, noslash) ->
  1234. lists:reverse(Acc);
  1235. unescape_string_literal([$\\ | Rest], Acc, noslash) ->
  1236. unescape_string_literal(Rest, Acc, slash);
  1237. unescape_string_literal([C | Rest], Acc, noslash) ->
  1238. unescape_string_literal(Rest, [C | Acc], noslash);
  1239. unescape_string_literal("n" ++ Rest, Acc, slash) ->
  1240. unescape_string_literal(Rest, [$\n | Acc], noslash);
  1241. unescape_string_literal("r" ++ Rest, Acc, slash) ->
  1242. unescape_string_literal(Rest, [$\r | Acc], noslash);
  1243. unescape_string_literal("t" ++ Rest, Acc, slash) ->
  1244. unescape_string_literal(Rest, [$\t | Acc], noslash);
  1245. unescape_string_literal([C | Rest], Acc, slash) ->
  1246. unescape_string_literal(Rest, [C | Acc], noslash).
  1247. full_path(File, DocRoot) ->
  1248. case filename:absname(File) of
  1249. File -> File;
  1250. _ -> filename:join([DocRoot, File])
  1251. end.
  1252. %%-------------------------------------------------------------------
  1253. %% Custom tags
  1254. %%-------------------------------------------------------------------
  1255. key_to_string(Key) when is_atom(Key) ->
  1256. erl_syntax:string(atom_to_list(Key));
  1257. key_to_string(Key) when is_list(Key) ->
  1258. erl_syntax:string(Key).
  1259. tag_ast(Name, Args, Context, TreeWalker) ->
  1260. {{InterpretedArgs, AstInfo1}, TreeWalker1} = lists:foldr(fun
  1261. ({{identifier, _, Key}, {trans, StringLiteral}}, {{ArgsAcc, AstInfoAcc}, TreeWalkerAcc}) ->
  1262. {{TransAst, TransAstInfo}, TreeWalker0} = translated_ast(StringLiteral, Context, TreeWalkerAcc),
  1263. {{[erl_syntax:tuple([erl_syntax:atom(Key), TransAst])|ArgsAcc], merge_info(TransAstInfo, AstInfoAcc)}, TreeWalker0};
  1264. ({{identifier, _, Key}, Value}, {{ArgsAcc, AstInfoAcc}, TreeWalkerAcc}) ->
  1265. {{Ast0, AstInfo0}, TreeWalker0} = value_ast(Value, false, false, Context, TreeWalkerAcc),
  1266. {{[erl_syntax:tuple([erl_syntax:atom(Key), Ast0])|ArgsAcc], merge_info(AstInfo0, AstInfoAcc)}, TreeWalker0}
  1267. end, {{[], #ast_info{}}, TreeWalker}, Args),
  1268. {RenderAst, RenderInfo} = custom_tags_modules_ast(Name, InterpretedArgs, Context),
  1269. {{RenderAst, merge_info(AstInfo1, RenderInfo)}, TreeWalker1}.
  1270. custom_tags_modules_ast(Name, InterpretedArgs, #dtl_context{ custom_tags_modules = [], is_compiling_dir = false }) ->
  1271. {erl_syntax:application(none, erl_syntax:atom(render_tag),
  1272. [key_to_string(Name), erl_syntax:list(InterpretedArgs),
  1273. erl_syntax:variable("RenderOptions")]),
  1274. #ast_info{custom_tags = [Name]}};
  1275. custom_tags_modules_ast(Name, InterpretedArgs, #dtl_context{ custom_tags_modules = [], is_compiling_dir = true, module = Module }) ->
  1276. {erl_syntax:application(erl_syntax:atom(Module), erl_syntax:atom(Name),
  1277. [erl_syntax:list(InterpretedArgs), erl_syntax:variable("RenderOptions")]),
  1278. #ast_info{ custom_tags = [Name] }};
  1279. custom_tags_modules_ast(Name, InterpretedArgs, #dtl_context{ custom_tags_modules = [Module|Rest] } = Context) ->
  1280. try lists:max([I || {N,I} <- Module:module_info(exports), N =:= Name]) of
  1281. 2 ->
  1282. {erl_syntax:application(erl_syntax:atom(Module), erl_syntax:atom(Name),
  1283. [erl_syntax:list(InterpretedArgs),
  1284. erl_syntax:variable("RenderOptions")]), #ast_info{}};
  1285. 1 ->
  1286. {erl_syntax:application(erl_syntax:atom(Module), erl_syntax:atom(Name),
  1287. [erl_syntax:list(InterpretedArgs)]), #ast_info{}};
  1288. I ->
  1289. throw({unsupported_custom_tag_fun, {Module, Name, I}})
  1290. catch _:function_clause ->
  1291. custom_tags_modules_ast(Name, InterpretedArgs,
  1292. Context#dtl_context{ custom_tags_modules = Rest })
  1293. end.
  1294. print(true, Fmt, Args) ->
  1295. io:format(Fmt, Args);
  1296. print(_, _Fmt, _Args) ->
  1297. ok.
  1298. call_ast(Module, TreeWalkerAcc) ->
  1299. call_ast(Module, erl_syntax:variable("_Variables"), #ast_info{}, TreeWalkerAcc).
  1300. call_with_ast(Module, Variable, Context, TreeWalker) ->
  1301. {VarAst, VarName} = resolve_variable_ast(Variable, Context, false),
  1302. call_ast(Module, VarAst, #ast_info{var_names=[VarName]}, TreeWalker).
  1303. call_ast(Module, Variable, AstInfo, TreeWalker) ->
  1304. AppAst = erl_syntax:application(
  1305. erl_syntax:atom(Module),
  1306. erl_syntax:atom(render),
  1307. [Variable, erl_syntax:variable("RenderOptions")]),
  1308. RenderedAst = erl_syntax:variable("Rendered"),
  1309. OkAst = erl_syntax:clause(
  1310. [erl_syntax:tuple([erl_syntax:atom(ok), RenderedAst])],
  1311. none,
  1312. [RenderedAst]),
  1313. ReasonAst = erl_syntax:variable("Reason"),
  1314. ErrStrAst = erl_syntax:application(
  1315. erl_syntax:atom(io_lib),
  1316. erl_syntax:atom(format),
  1317. [erl_syntax:string("error: ~p"), erl_syntax:list([ReasonAst])]),
  1318. ErrorAst = erl_syntax:clause(
  1319. [erl_syntax:tuple([erl_syntax:atom(error), ReasonAst])],
  1320. none,
  1321. [ErrStrAst]),
  1322. CallAst = erl_syntax:case_expr(AppAst, [OkAst, ErrorAst]),
  1323. with_dependencies(Module:dependencies(), {{CallAst, AstInfo}, TreeWalker}).