File: build/ast_info.ml (return to index)



Statistics:  
kind coverage
binding 3 / 3 (100 %)
sequence 0 / 0 (- %)
for 0 / 0 (- %)
if/then 0 / 0 (- %)
try 0 / 0 (- %)
while 0 / 0 (- %)
match/function 71 / 74 (95 %)
kind coverage
class expression 0 / 0 (- %)
class initializer 0 / 0 (- %)
class method 0 / 0 (- %)
class value 0 / 0 (- %)
toplevel expression 0 / 0 (- %)
lazy operator 0 / 0 (- %)



Source:

fold all unfold all
000001| (**
000002| This program is free software; you can redistribute it and / or modify
000003| it under the terms of the GNU General Public License as published by
000004| the Free Software Foundation; version 3 of the License.
000005|  
000006| This program is distributed in the hope that it will be useful,
000007| but WITHOUT ANY WARRANTY; without even the implied warranty of
000008| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
000009| GNU General Public License for more details.
000010|  
000011| Pretty prints the runtime AST
000012|  
000013| @author Tony BenBrahim < tony.benbrahim at gmail.com >
000014|  
000015| *)
000016|  
000017| module AstInfo =
000018| struct
000019|         
000020|         open Ast
000021|         
000022|         (**
000023|         Returns a pretty printed representation of the runtime AST
000024|         @param statement the top level statement (program)
000025|         @return a string with the pretty printed AST
000026|         *)
000027|         let statement_description statement =
000028|                 (*[2]*)let rec statement_descriptionl level statement =
000029|                         (*[1714]*)let rec get_closure_vars = function
000030|                                 | None -> (*[340]*)"None"
000031|                                 | Some t -> (*[18]*)(Hashtbl.fold (fun n _ s -> (*[18]*)let (d, i) = n in (*[18]*)s^"Local("^(string_of_int d)^","^(string_of_int i)^"),") t "[")^"]"
000032|                         
000033|                         and prefix = function
000034|                                 | 0 -> (*[2]*)""
000035|                                 | level -> (*[11082]*)(String.make (level * 3) ' ') ^ "+--"
000036|                         
000037|                         and location_name = function
000038|                                 | GlobalVar(uid, ind) ->(*[212]*)"Global("^(string_of_int uid)^","^(string_of_int ind)^")\n"
000039|                                 | LocalVar(uid, d, ind) ->(*[1274]*)"Local("^(string_of_int uid)^","^(string_of_int d)^","^(string_of_int ind)^")\n"
000040|                         
000041|                         and opname = function
000042|                                 | Plus -> (*[82]*)"+"
000043|                                 | Minus -> (*[10]*)"-"
000044|                                 | Divide -> (*[8]*)"/"
000045|                                 | Times -> (*[6]*)"*"
000046|                                 | Modulo -> (*[8]*)"%"
000047|                                 | And -> (*[164]*)"&&"
000048|                                 | Or -> (*[22]*)"||"
000049|                         
000050|                         and compopname = function
000051|                                 | LessThan -> (*[10]*)"<"
000052|                                 | LessThanEqual -> (*[2]*)">"
000053|                                 | Equal -> (*[328]*)"=="
000054|                                 | GreaterThan -> (*[2]*)">"
000055|                                 | GreaterThanEqual -> (*[6]*)">="
000056|                                 | NotEqual -> (*[48]*)"!="
000057|                         
000058|                         and expr_descriptionl level = function
000059|                                 | RBinaryOp (op1, op, op2) ->
000060|                                                 (*[300]*)(prefix level) ^
000061|                                                 ("BinOp " ^
000062|                                                         ((opname op) ^
000063|                                                                 ("\n" ^
000064|                                                                         ((expr_descriptionl (level + 1) op1) ^
000065|                                                                                 (expr_descriptionl (level + 1) op2)))))
000066|                                 | RCompOp (op1, op, op2) ->
000067|                                                 (*[396]*)(prefix level) ^
000068|                                                 ("CompOp " ^
000069|                                                         ((compopname op) ^
000070|                                                                 ("\n" ^
000071|                                                                         ((expr_descriptionl (level + 1) op1) ^
000072|                                                                                 (expr_descriptionl (level + 1) op2)))))
000073|                                 | RValue value ->
000074|                                                 (*[2638]*)(prefix level) ^ "Value reference\n" ^ value_descriptionl (level + 1) value
000075|                                 | RMapExpr v ->
000076|                                                 (*[370]*)(prefix level) ^ ("Map\n" ^ ((property_list (level + 1) v) ^ "\n"))
000077|                                 | RArrayExpr v ->
000078|                                                 (*[134]*)(prefix level) ^ ("Array\n" ^ (expression_list (level + 1) v))
000079|                                 | RVariable(loc) ->
000080|                                                 (*[1344]*)(prefix level) ^"Variable " ^(location_name loc)
000081|                                 | RVarArg(loc) ->
000082|                                                 (*[2]*)(prefix level) ^ "VarArg" ^(location_name loc)
000083|                                 | RNot(expr) ->
000084|                                                 (*[30]*)(prefix level) ^ "Not\n"^(expr_descriptionl (level + 1) expr)
000085|                                 | RDeclaration(expr1, expr2) ->
000086|                                                 (*[320]*)(prefix level)^"Declare\n"^
000087|                                                 (expr_descriptionl (level + 1) expr1)^(expr_descriptionl (level + 1) expr2)
000088|                                 | RAssignment(expr1, expr2) ->
000089|                                                 (*[138]*)(prefix level)^"Assignment\n"^
000090|                                                 (expr_descriptionl (level + 1) expr1)^(expr_descriptionl (level + 1) expr2)
000091|                                 | RPostFixSum(expr, inc) -> (*[6]*)(prefix level)^"++("^(string_of_int inc)^")\n"^
000092|                                                 (expr_descriptionl (level + 1) expr)
000093|                                 | RMemberExpr(expr1, expr2) ->
000094|                                                 (*[394]*)(prefix level)^"Member\n"^
000095|                                                 (expr_descriptionl (level + 1) expr1)^(expr_descriptionl (level + 1) expr2)
000096|                                 | RTernaryCond(expr1, expr2, expr3) ->
000097|                                                 (*[16]*)(prefix level)^"Ternary condition\n"^
000098|                                                 (expr_descriptionl (level + 1) expr1)^(expr_descriptionl (level + 1) expr2)^
000099|                                                 (expr_descriptionl (level + 1) expr3)
000100|                                 | RFunctionCall(expr, exprl) ->
000101|                                                 (*[392]*)(prefix level)^"FunctionCall\n"^(expr_descriptionl (level + 1) expr)^
000102|                                                 (expression_list (level + 1) exprl)
000103|                         
000104|                         and value_descriptionl level = function
000105|                                 | RIntegerValue v ->
000106|                                                 (*[710]*)(prefix level) ^ ("Integer " ^ ((string_of_int v) ^ "\n"))
000107|                                 | RFunctionValue (stacksize, depth, numargs, varargs, stmts, closure_vars, inline) ->
000108|                                                 (*[358]*)(prefix level) ^
000109|                                                 "RFunction("^(string_of_int stacksize)^","^(string_of_int depth)^","^(string_of_int numargs)
000110|                                                 ^","^(string_of_bool varargs)^","^(get_closure_vars closure_vars)^
000111|                                                 ", inline "^(match inline with | Some _ -> (*[70]*)"true" | None -> (*[288]*)"false")^
000112|                                                 ")\n"
000113|                                                 ^ (statement_list (level + 1) stmts)
000114|                                 | RLibraryFunction(_) -> (*[0]*)"" (* never in ast *)
000115|                                 | RBooleanValue v ->
000116|                                                 (*[266]*)(prefix level) ^ ("Boolean " ^ ((string_of_bool v) ^ "\n"))
000117|                                 | RStringValue v -> (*[1232]*)(prefix level) ^ ("String " ^ (v ^ "\n"))
000118|                                 | RFloatValue v ->
000119|                                                 (*[24]*)(prefix level) ^ ("Float " ^ ((string_of_float v) ^ "\n"))
000120|                                 | RMapValue( _, _) -> (*[0]*)"" (* Not in AST *)
000121|                                 | RVoid -> (*[48]*)(prefix level) ^"void\n"
000122|                                 | RUndefined -> (*[0]*)(prefix level) ^"Undefined\n"
000123|                         
000124|                         and statement_list level stmt_list =
000125|                                 (*[358]*)List.fold_left (fun acc el -> (*[836]*)acc ^ (statement_descriptionl level el))
000126|                                         "" stmt_list
000127|                         
000128|                         and expression_list level expr_list =
000129|                                 (*[526]*)List.fold_left (fun acc el -> (*[1016]*)acc ^ (expr_descriptionl level el)) ""
000130|                                         expr_list
000131|                         
000132|                         and property_list level prop_list =
000133|                                 (*[370]*)List.fold_left
000134|                                         (fun acc el ->
000135|                                                                 (*[712]*)let (name, expr) = el
000136|                                                                 in
000137|                                                                 (*[712]*)acc ^
000138|                                                                 ((prefix level) ^
000139|                                                                         ("Property " ^
000140|                                                                                 (name ^ ("\n" ^ (expr_descriptionl (level + 1) expr))))))
000141|                                         "" prop_list
000142|                         
000143|                         in match statement with
000144|                         | RStatementBlock(stmts) ->
000145|                                         (*[264]*)List.fold_left(fun pre stmt -> (*[442]*)pre^(statement_descriptionl (level + 1) stmt))
000146|                                                 ((prefix level) ^"Statement block\n") stmts
000147|                         | RProgram(stmts) ->
000148|                                         (*[2]*)List.fold_left(fun pre stmt -> (*[8]*)pre^(statement_descriptionl (level + 1) stmt))
000149|                                                 ((prefix level) ^"Program\n") stmts
000150|                         | RTryFinally(stmt1, stmt2, env) ->
000151|                                         (*[8]*)(prefix level)^"Try\n"^(statement_descriptionl (level + 1) stmt1)^
000152|                                         (prefix level)^"finally\n"^(statement_descriptionl (level + 1) stmt2)
000153|                         | RTryCatch(stmt1, vloc, stmt2, env) ->
000154|                                         (*[98]*)(prefix level)^"Try\n"^(statement_descriptionl (level + 1) stmt1)^
000155|                                         (prefix level)^"catch "^(location_name vloc)^(statement_descriptionl (level + 1) stmt2)
000156|                         | RSwitch(expr, stmts, env) ->
000157|                                         (*[14]*)List.fold_left(fun pre stmt -> (*[84]*)pre^(statement_descriptionl (level + 1) stmt))
000158|                                                 ((prefix level)^"Switch\n"^(expr_descriptionl (level + 1) expr)) stmts
000159|                         | RForEach(vloc, expr, stmt, env) ->
000160|                                         (*[22]*)(prefix level)^"RForEach "^(location_name vloc)^"\n"^(expr_descriptionl (level + 1) expr)^
000161|                                         (statement_descriptionl (level + 1) stmt)
000162|                         | RIf (expr, iflist, elselist, env) ->
000163|                                         (*[36]*)(prefix level) ^
000164|                                         ("If/Else\n" ^
000165|                                                 ((expr_descriptionl (level + 1) expr) ^
000166|                                                         ((statement_descriptionl (level + 1) iflist) ^
000167|                                                                 (statement_descriptionl (level + 1) elselist))))
000168|                         | RReturn( expr, env) ->
000169|                                         (*[452]*)(prefix level) ^
000170|                                         ("Return\n" ^ (expr_descriptionl (level + 1) expr))
000171|                         | RExpressionStatement (expr , env) -> (*[566]*)expr_descriptionl level expr
000172|                         | RContinue(env) -> (*[8]*)(prefix level) ^ "Continue\n"
000173|                         | RBreak(env) -> (*[16]*)(prefix level) ^ "Break\n"
000174|                         | RFor (expr1, expr2, expr3, stmt_list, env) ->
000175|                                         (*[16]*)(prefix level) ^
000176|                                         ("For\n" ^
000177|                                                 ((expr_descriptionl (level + 1) expr1) ^
000178|                                                         ((expr_descriptionl (level + 1) expr2) ^
000179|                                                                 ((expr_descriptionl (level + 1) expr3) ^
000180|                                                                         (statement_descriptionl (level + 1) stmt_list)))))
000181|                         | RFastIterator(vloc, start, max, incr, stmt, env) ->
000182|                                         (*[20]*)(prefix level)^ ("FastIterator "^" "^(string_of_int start)^" "
000183|                                                 ^(string_of_int max)^" "^(string_of_int incr)^" "
000184|                                                 ^(location_name vloc)^(statement_descriptionl (level + 1) stmt))
000185|                         | RNoop -> (*[136]*)(prefix level) ^ "Noop\n"
000186|                         | RThrow(expr, env) -> (*[12]*)(prefix level)^"Throw\n"^(expr_descriptionl (level + 1) expr)
000187|                         | RCase(Some expr, env) -> (*[30]*)(prefix level)^"Case\n"^(expr_descriptionl (level + 1) expr)
000188|                         | RCase(None, env) -> (*[14]*)(prefix level)^"DefaultCase\n"
000189|                 
000190|                 in (*[2]*)statement_descriptionl 0 statement
000191|         
000192|         (**
000193|         Pretty prints the representation of the runtime AST
000194|         @param statement the top level statement (program)
000195|         @return unit
000196|         *)
000197|         let print_ast statement = (*[2]*)print_string (statement_description statement)
000198|         
000199| end

Legend:
   some code - line containing no point
   some code - line containing only visited points
   some code - line containing only unvisited points
   some code - line containing both visited and unvisited points