
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)

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