texy/ast.ml at master · tmprender/texy · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
(* Abstract Syntax Tree and functions for printing it  - based off MicroC ast*)

type op = Add | Sub | Mult | Div | Equal | Neq | Less | Leq | Greater | Geq |
          And | Or

type uop = Neg | Not

type typ = Int | Bool | Word | Char | Float | File | Void | Array of typ * int | Struct of string

type bind = typ * string

type expr =
    Literal of int
  | Fliteral of string
  | WordLit of string
  | CharLit of char
  | BoolLit of bool
  | ArrAcc of string * expr
  | Conbin of expr
  | Bincon of expr
  | Bitflip of expr
  | Shiftup of expr * expr
  | Shiftdown of expr * expr
  | Concat of expr * expr
  | Id of string
  | Binop of expr * op * expr
  | Unop of uop * expr
  | Assign of expr * expr
  | ArrayAssign of string * expr
  | Call of string * expr list
  | ArrayLit of expr list
  | StructVar of expr * string
  | Noexpr

type stmt =
    Block of stmt list
  | Expr of expr
  | Return of expr
  | If of expr * stmt * stmt
  | For of expr * expr * expr * stmt
  | While of expr * stmt

type func_decl = {
    typ : typ;
    fname : string;
    formals : bind list;
    locals : bind list;
    body : stmt list;
  }

type struct_decl = {
    sname: string;
    vars: bind list;
  }

type program = {
    var_decls: bind list;
    struct_decls: struct_decl list;
    func_decls: func_decl list;
}


(* Pretty-printing functions *)

let string_of_op = function
    Add -> "+"
  | Sub -> "-"
  | Mult -> "*"
  | Div -> "/"
  | Equal -> "=="
  | Neq -> "!="
  | Less -> "<"
  | Leq -> "<="
  | Greater -> ">"
  | Geq -> ">="
  | And -> "&&"
  | Or -> "||"

let string_of_uop = function
    Neg -> "-"
  | Not -> "!"

let rec string_of_expr = function
    Literal(l) -> string_of_int l
  | Fliteral(l) -> l
  | CharLit(l) -> Char.escaped l
  | WordLit(w) -> w
  | ArrayLit(arr) -> "[" ^ String.concat ", " (List.map string_of_expr arr) ^ "]"
  | BoolLit(true) -> "true"
  | BoolLit(false) -> "false"
  | Id(s) -> s
  | Conbin(e) -> "#" ^ string_of_expr e
  | Bincon(e) -> "%" ^ string_of_expr e
  | Bitflip(e) -> "~" ^ string_of_expr e
  | Shiftup(e1,e2) -> string_of_expr e1 ^ "#+" ^ string_of_expr e2
  | Shiftdown(e1,e2) -> string_of_expr e1 ^ "#-" ^ string_of_expr e2
  | Concat(e1, e2) -> string_of_expr e1 ^ "^" ^ string_of_expr e2
  | Binop(e1, o, e2) ->
      string_of_expr e1 ^ " " ^ string_of_op o ^ " " ^ string_of_expr e2
  | Unop(o, e) -> string_of_uop o ^ string_of_expr e
  | Assign(v, e) -> string_of_expr v ^ " = " ^ string_of_expr e
  | ArrayAssign(v,i) -> v ^ "[" ^ string_of_expr i ^ "]"
  | Call(f, el) ->
      f ^ "(" ^ String.concat ", " (List.map string_of_expr el) ^ ")"
  | ArrAcc(n, e) ->
      n ^ "[" ^ string_of_expr e ^ "]"
  | StructVar(s, v) -> string_of_expr s ^ "." ^ v
  | Noexpr -> ""

let rec string_of_stmt = function
    Block(stmts) ->
      "{\n" ^ String.concat "" (List.map string_of_stmt stmts) ^ "}\n"
  | Expr(expr) -> string_of_expr expr ^ ";\n";
  | Return(expr) -> "return " ^ string_of_expr expr ^ ";\n";
  | If(e, s, Block([])) -> "if (" ^ string_of_expr e ^ ")\n" ^ string_of_stmt s
  | If(e, s1, s2) ->  "if (" ^ string_of_expr e ^ ")\n" ^
      string_of_stmt s1 ^ "else\n" ^ string_of_stmt s2
  | For(e1, e2, e3, s) ->
      "for (" ^ string_of_expr e1  ^ " ; " ^ string_of_expr e2 ^ " ; " ^
      string_of_expr e3  ^ ") " ^ string_of_stmt s
  | While(e, s) -> "while (" ^ string_of_expr e ^ ") " ^ string_of_stmt s

let rec string_of_typ = function
    Int -> "int"
  | Bool -> "bool"
  | Word -> "word"
  | Float -> "float"
  | Char -> "char"
  | File -> "file"
  | Void -> "void"
  | Array(t,i) -> string_of_typ t ^ "[" ^ string_of_int i ^"]"
  | Struct(s) -> "struct " ^ s

let string_of_vdecl (t, id) = string_of_typ t ^ " " ^ id ^ ";\n"

let string_of_sdecl sdecl =
  "struct " ^ sdecl.sname ^  " {\n" ^ String.concat "" (List.map string_of_vdecl sdecl.vars) ^ "};\n"


let string_of_fdecl fdecl =
  string_of_typ fdecl.typ ^ " " ^
  fdecl.fname ^ "(" ^ String.concat ", " (List.map snd fdecl.formals) ^
  ")\n{\n" ^
  String.concat "" (List.map string_of_vdecl fdecl.locals) ^
  String.concat "" (List.map string_of_stmt fdecl.body) ^
  "}\n"

let string_of_program program =
  String.concat "" (List.map string_of_vdecl program.var_decls) ^ "\n"  ^
  String.concat "\n" (List.map string_of_sdecl program.struct_decls) ^ "\n" ^
  String.concat "\n" (List.map string_of_fdecl program.func_decls)