mirror of
https://github.com/LucasVbr/croissant.git
synced 2026-05-13 17:12:10 +00:00
refactor: Syntax with unit tests
This commit is contained in:
Lucàs
@@ -0,0 +1,10 @@
|
||||
(library
|
||||
(name Analyzer)
|
||||
(modules lexer parser)
|
||||
(libraries Syntax))
|
||||
|
||||
(menhir
|
||||
(modules parser))
|
||||
|
||||
(ocamllex
|
||||
(modules lexer))
|
||||
@@ -0,0 +1,67 @@
|
||||
{
|
||||
open Parser
|
||||
exception Error of char
|
||||
|
||||
let buffer = Buffer.create 256
|
||||
}
|
||||
|
||||
let white_space = [' ' '\t' '\n']
|
||||
|
||||
let letter = ['a'-'z' 'A'-'Z']
|
||||
let digit = ['0'-'9']
|
||||
let alphanum = letter | digit
|
||||
let non_digit = '_'
|
||||
|
||||
let identifier = letter (alphanum | non_digit)*
|
||||
let interger = digit+
|
||||
let float = digit+ '.' digit+
|
||||
|
||||
rule token = parse
|
||||
| white_space { token lexbuf }
|
||||
| '\n' { Lexing.new_line lexbuf; token lexbuf }
|
||||
|
||||
(* Comments *)
|
||||
| "//" { line_comment lexbuf }
|
||||
| "/*" { block_comment lexbuf }
|
||||
|
||||
(* Delimiters *)
|
||||
| '(' { LPAREN }
|
||||
| ')' { RPAREN }
|
||||
| ';' { SEMICOLON }
|
||||
|
||||
(* Operators *)
|
||||
| '+' { PLUS }
|
||||
| '-' { MINUS }
|
||||
| '*' { TIMES }
|
||||
| '/' { DIV }
|
||||
|
||||
(* Keywords *)
|
||||
(* ... *)
|
||||
|
||||
(* Literals *)
|
||||
| interger as i { INT (int_of_string i) }
|
||||
(* | float as f { FLOAT (float_of_string f) } *)
|
||||
|
||||
(* Identifiers *)
|
||||
(* ... *)
|
||||
|
||||
| eof { EOF }
|
||||
| _ as c { raise (Error c) }
|
||||
|
||||
and string = parse
|
||||
| '"' { token lexbuf }
|
||||
| '\\' { Buffer.add_char buffer '\\'; string lexbuf }
|
||||
| '\n' { Buffer.add_char buffer '\n'; string lexbuf }
|
||||
| eof { raise (Error '"') }
|
||||
| _ { Buffer.add_char buffer (Lexing.lexeme_char lexbuf 0); string lexbuf }
|
||||
|
||||
and line_comment = parse
|
||||
| '\n' { Lexing.new_line lexbuf; token lexbuf }
|
||||
| eof { EOF }
|
||||
| _ { line_comment lexbuf }
|
||||
|
||||
and block_comment = parse
|
||||
| "*/" { token lexbuf }
|
||||
| '\n' { Lexing.new_line lexbuf; block_comment lexbuf }
|
||||
| eof { EOF }
|
||||
| _ { block_comment lexbuf }
|
||||
@@ -0,0 +1,53 @@
|
||||
%{
|
||||
open Syntax
|
||||
%}
|
||||
|
||||
%token <int> INT
|
||||
%token PLUS "+"
|
||||
%token MINUS "-"
|
||||
%token TIMES "*"
|
||||
%token DIV "/"
|
||||
|
||||
%token SEMICOLON ";"
|
||||
|
||||
%token LPAREN "("
|
||||
%token RPAREN ")"
|
||||
|
||||
%token EOF
|
||||
|
||||
%left PLUS MINUS
|
||||
%left TIMES DIV
|
||||
|
||||
%nonassoc UMINUS
|
||||
|
||||
%start <SourceFiles.source_files> main
|
||||
|
||||
%%
|
||||
|
||||
main:
|
||||
| statements EOF { SourceFiles.SourceFile $1 }
|
||||
|
||||
statements:
|
||||
| statement ";" { $1 }
|
||||
| statement ";" statements { Statements.SequenceStatement ($1, $3) }
|
||||
|
||||
statement:
|
||||
| expression { Statements.ExpressionStatement($1) }
|
||||
|
||||
expression:
|
||||
| literal { Expressions.Literal($1) }
|
||||
| unary_expression { $1 }
|
||||
| binary_expression { $1 }
|
||||
| "(" expression ")" { $2 }
|
||||
|
||||
literal:
|
||||
| INT { Literals.Integer($1) }
|
||||
|
||||
unary_expression:
|
||||
| "-" expression %prec UMINUS { Expressions.UnaryExpression(UnaryOperators.ArithmeticNegation, $2) }
|
||||
|
||||
binary_expression:
|
||||
| expression "+" expression { Expressions.BinaryExpression (BinaryOperators.Add, $1, $3) }
|
||||
| expression "-" expression { Expressions.BinaryExpression (BinaryOperators.Subtract, $1, $3) }
|
||||
| expression "*" expression { Expressions.BinaryExpression (BinaryOperators.Multiply, $1, $3) }
|
||||
| expression "/" expression { Expressions.BinaryExpression (BinaryOperators.Divide, $1, $3) }
|
||||
@@ -0,0 +1 @@
|
||||
type environment = { variables : (string * _type) list }
|
||||
@@ -1,30 +0,0 @@
|
||||
open Printf
|
||||
open Typecheck
|
||||
|
||||
let analyze lexbuf =
|
||||
let ast =
|
||||
try Parser.main Lexer.token lexbuf with
|
||||
| Lexer.Error c ->
|
||||
let file_name = lexbuf.lex_curr_p.pos_fname
|
||||
and line_num = lexbuf.lex_curr_p.pos_lnum
|
||||
and col_num = lexbuf.lex_curr_p.pos_cnum - lexbuf.lex_curr_p.pos_bol in
|
||||
fprintf stderr "Fichier \"%s\", ligne %d, colonne %d\n%s: %s\n"
|
||||
file_name line_num col_num "Erreur lexicale"
|
||||
("Caractère '" ^ String.make 1 c ^ "' inconnu");
|
||||
exit 1
|
||||
| Parser.Error ->
|
||||
let file_name = lexbuf.lex_curr_p.pos_fname
|
||||
and line_num = lexbuf.lex_curr_p.pos_lnum
|
||||
and col_num = lexbuf.lex_curr_p.pos_cnum - lexbuf.lex_curr_p.pos_bol in
|
||||
fprintf stderr "Fichier \"%s\", ligne %d, colonne %d\n%s: %s\n"
|
||||
file_name line_num col_num "Erreur syntaxique" "Syntaxe incorrecte";
|
||||
exit 1
|
||||
in
|
||||
let _ = type_of_source_file ast in
|
||||
ast
|
||||
|
||||
let analyze_file file_name =
|
||||
let file_stream = open_in file_name in
|
||||
let lexbuf = Lexing.from_channel file_stream in
|
||||
Lexing.set_filename lexbuf file_name;
|
||||
analyze lexbuf
|
||||
@@ -1,10 +0,0 @@
|
||||
(library
|
||||
(name ast)
|
||||
(modules lexer parser syntax print typecheck analyzer)
|
||||
)
|
||||
|
||||
(menhir
|
||||
(modules parser))
|
||||
|
||||
(ocamllex
|
||||
(modules lexer))
|
||||
@@ -1,90 +0,0 @@
|
||||
(* lib/lexer.mll *)
|
||||
{
|
||||
open Parser
|
||||
exception Error of char
|
||||
|
||||
let buffer = Buffer.create 256
|
||||
}
|
||||
|
||||
let letter = ['a'-'z' 'A'-'Z']
|
||||
let digit = ['0'-'9']
|
||||
let alphanum = letter | digit
|
||||
let non_digit = '_'
|
||||
|
||||
let identifier = letter (alphanum | non_digit)*
|
||||
let integer = digit+
|
||||
let float = digit* '.' digit+
|
||||
|
||||
rule token = parse
|
||||
| ' ' | '\t' { token lexbuf }
|
||||
| "/*" { block_comment lexbuf }
|
||||
| "//" { line_comment lexbuf }
|
||||
| '\n' { Lexing.new_line lexbuf; token lexbuf }
|
||||
|
||||
| '+' { PLUS }
|
||||
| '-' { MINUS }
|
||||
| '*' { TIMES }
|
||||
| '/' { DIVIDE }
|
||||
| "&&" { AMPERSAND_AMPERSAND }
|
||||
| "||" { BAR_BAR }
|
||||
| "==" { EQUALS_EQUALS }
|
||||
| "!=" { EXCLAMATION_EQUALS }
|
||||
| '<' { LESS_THAN }
|
||||
| "<=" { LESS_THAN_EQUALS }
|
||||
| '>' { GREATER_THAN }
|
||||
| ">=" { GREATER_THAN_EQUALS }
|
||||
| '=' { EQUALS }
|
||||
|
||||
| "!" { EXCLAMATION }
|
||||
| ';' { SEMICOLON }
|
||||
| ':' { COLON }
|
||||
| ',' { COMMA }
|
||||
|
||||
| '(' { LPAREN }
|
||||
| ')' { RPAREN }
|
||||
|
||||
| "var" { VAR }
|
||||
| "vrai" { BOOLEAN(true) }
|
||||
| "faux" { BOOLEAN(false) }
|
||||
| "nul" { NULL }
|
||||
|
||||
| "entier" { INTEGER_TYPE }
|
||||
| "reel" { FLOAT_TYPE }
|
||||
| "caractere" { CHARACTER_TYPE }
|
||||
| "chaine" { STRING_TYPE }
|
||||
| "booleen" { BOOLEAN_TYPE }
|
||||
| "vide" { VOID_TYPE }
|
||||
|
||||
| integer as lxm { INTEGER(int_of_string lxm) }
|
||||
| float as lxm { FLOAT(float_of_string lxm) }
|
||||
|
||||
| "'\\''" { CHARACTER '\'' }
|
||||
| "'\\n'" { CHARACTER '\n' }
|
||||
| "'\\t'" { CHARACTER '\t' }
|
||||
| "'\\\\'" { CHARACTER '\\' }
|
||||
| "'\\r'" { CHARACTER '\r' }
|
||||
| "'\\b'" { CHARACTER '\b' }
|
||||
| "'" [^'\\'] "'" { CHARACTER (String.get (Lexing.lexeme lexbuf) 1) }
|
||||
|
||||
| "\"" { Buffer.clear buffer; string lexbuf }
|
||||
| identifier as lxm { IDENTIFIER(lxm) }
|
||||
|
||||
| eof { EOF }
|
||||
| _ as c { raise (Error c) }
|
||||
|
||||
and string = parse
|
||||
| "\"" { STRING(Buffer.contents buffer)}
|
||||
| "\\\"" { Buffer.add_char buffer '"'; string lexbuf }
|
||||
| '\\' { Buffer.add_char buffer '\\'; string lexbuf }
|
||||
| _ as c { Buffer.add_char buffer c; string lexbuf }
|
||||
|
||||
and line_comment = parse
|
||||
| '\n' { Lexing.new_line lexbuf; token lexbuf }
|
||||
| eof { EOF }
|
||||
| _ { line_comment lexbuf }
|
||||
|
||||
and block_comment = parse
|
||||
| "*/" { token lexbuf }
|
||||
| '\n' { Lexing.new_line lexbuf; block_comment lexbuf }
|
||||
| eof { EOF }
|
||||
| _ { block_comment lexbuf }
|
||||
@@ -1,117 +0,0 @@
|
||||
/* lib/parser.mly */
|
||||
%{
|
||||
open Syntax
|
||||
%}
|
||||
|
||||
%token <int> INTEGER
|
||||
%token <float> FLOAT
|
||||
%token <bool> BOOLEAN
|
||||
%token <char> CHARACTER
|
||||
%token <string> STRING
|
||||
%token <string> IDENTIFIER
|
||||
%token NULL
|
||||
|
||||
%token INTEGER_TYPE
|
||||
%token FLOAT_TYPE
|
||||
%token CHARACTER_TYPE
|
||||
%token STRING_TYPE
|
||||
%token BOOLEAN_TYPE
|
||||
%token VOID_TYPE
|
||||
|
||||
%token PLUS "+"
|
||||
%token MINUS "-"
|
||||
%token TIMES "*"
|
||||
%token DIVIDE "/"
|
||||
%token AMPERSAND_AMPERSAND "&&"
|
||||
%token BAR_BAR "||"
|
||||
%token EXCLAMATION "!"
|
||||
%token EQUALS_EQUALS "=="
|
||||
%token EXCLAMATION_EQUALS "!="
|
||||
%token LESS_THAN "<"
|
||||
%token LESS_THAN_EQUALS "<="
|
||||
%token GREATER_THAN ">"
|
||||
%token GREATER_THAN_EQUALS ">="
|
||||
%token EQUALS "="
|
||||
|
||||
%token LPAREN "("
|
||||
%token RPAREN ")"
|
||||
|
||||
%token SEMICOLON ";"
|
||||
%token COLON ":"
|
||||
%token COMMA ","
|
||||
|
||||
%token VAR "var"
|
||||
|
||||
%token EOF
|
||||
|
||||
%left "&&" "||"
|
||||
%left "+" "-"
|
||||
%left "*" "/"
|
||||
%nonassoc UMINUS
|
||||
|
||||
%start main
|
||||
%type <source_file> main
|
||||
|
||||
%%
|
||||
|
||||
main:
|
||||
| statements EOF { SourceFile($1) }
|
||||
| EOF { SourceFile([]) }
|
||||
|
||||
statements:
|
||||
| statement ";" { [$1] }
|
||||
| statement ";" statements { $1 :: $3 }
|
||||
|
||||
statement:
|
||||
| expression { ExpressionStatement($1) }
|
||||
| "var" variable_declaration_list { VariableStatement($2) }
|
||||
|
||||
variable_declaration_list:
|
||||
| variable_declaration { [$1] }
|
||||
| variable_declaration "," variable_declaration_list { $1 :: $3 }
|
||||
|
||||
variable_declaration:
|
||||
| IDENTIFIER ":" tp "=" expression { VariableDeclaration($3, Identifier($1), $5) }
|
||||
| IDENTIFIER ":" tp { VariableDeclaration($3, Identifier($1), Literal(Null)) }
|
||||
|
||||
tp:
|
||||
| INTEGER_TYPE { IntegerType }
|
||||
| FLOAT_TYPE { FloatType }
|
||||
| CHARACTER_TYPE { CharacterType }
|
||||
| STRING_TYPE { StringType }
|
||||
| BOOLEAN_TYPE { BooleanType }
|
||||
| VOID_TYPE { VoidType }
|
||||
|
||||
expression:
|
||||
| literal { Literal($1) }
|
||||
| IDENTIFIER { Identifier($1) }
|
||||
| unary_expression { $1 }
|
||||
| binary_expression { $1 }
|
||||
| "(" expression ")" { $2 }
|
||||
|
||||
literal:
|
||||
| INTEGER { Integer($1) }
|
||||
| FLOAT { Float($1) }
|
||||
| CHARACTER { Character($1) }
|
||||
| STRING { String($1) }
|
||||
| BOOLEAN { Boolean($1) }
|
||||
| NULL { Null }
|
||||
|
||||
unary_expression:
|
||||
| "-" expression %prec UMINUS { UnaryExpression(Negate, $2) }
|
||||
| "!" expression { UnaryExpression(Not, $2) }
|
||||
|
||||
binary_expression:
|
||||
| e1=expression "+" e2=expression { BinaryExpression(Add, e1, e2) }
|
||||
| e1=expression "-" e2=expression { BinaryExpression(Subtract, e1, e2) }
|
||||
| e1=expression "*" e2=expression { BinaryExpression(Multiply, e1, e2) }
|
||||
| e1=expression "/" e2=expression { BinaryExpression(Divide, e1, e2) }
|
||||
| e1=expression "&&" e2=expression { BinaryExpression(AmpersandAmpersand, e1, e2) }
|
||||
| e1=expression "||" e2=expression { BinaryExpression(BarBar, e1, e2) }
|
||||
| e1=expression "==" e2=expression { BinaryExpression(EqualsEquals, e1, e2) }
|
||||
| e1=expression "!=" e2=expression { BinaryExpression(ExclamationEquals, e1, e2) }
|
||||
| e1=expression "<" e2=expression { BinaryExpression(LessThan, e1, e2) }
|
||||
| e1=expression "<=" e2=expression { BinaryExpression(LessThanEquals, e1, e2) }
|
||||
| e1=expression ">" e2=expression { BinaryExpression(GreaterThan, e1, e2) }
|
||||
| e1=expression ">=" e2=expression { BinaryExpression(GreaterThanEquals, e1, e2) }
|
||||
| e1=expression "=" e2=expression { BinaryExpression(Assign, e1, e2) }
|
||||
@@ -1,84 +0,0 @@
|
||||
(* lib/ast/print.ml *)
|
||||
|
||||
open Syntax
|
||||
|
||||
(** [string_of_type t] returns a string representation of the type [t]. *)
|
||||
let string_of_type = function
|
||||
| IntegerType -> "IntegerType"
|
||||
| FloatType -> "FloatType"
|
||||
| CharacterType -> "CharacterType"
|
||||
| StringType -> "StringType"
|
||||
| BooleanType -> "BooleanType"
|
||||
| VoidType -> "VoidType"
|
||||
|
||||
(** [string_of_literal l] returns a string representation of the literal [l]. *)
|
||||
let string_of_literal = function
|
||||
| Integer i -> "Integer(" ^ string_of_int i ^ ")"
|
||||
| Float f -> "Float(" ^ string_of_float f ^ ")"
|
||||
| Character c -> "Character('" ^ Char.escaped c ^ "')"
|
||||
| String s -> "String(\"" ^ String.escaped s ^ "\")"
|
||||
| Boolean b -> "Boolean(" ^ string_of_bool b ^ ")"
|
||||
| Null -> "Null"
|
||||
|
||||
(** [string_of_binary_operator op] returns a string representation of the binary operator [op]. *)
|
||||
let string_of_binary_operator = function
|
||||
| Add -> "Add"
|
||||
| Subtract -> "Subtract"
|
||||
| Multiply -> "Multiply"
|
||||
| Divide -> "Divide"
|
||||
| AmpersandAmpersand -> "AmpersandAmpersand"
|
||||
| BarBar -> "BarBar"
|
||||
| EqualsEquals -> "EqualsEquals"
|
||||
| ExclamationEquals -> "ExclamationEquals"
|
||||
| LessThan -> "LessThan"
|
||||
| LessThanEquals -> "LessThanEquals"
|
||||
| GreaterThan -> "GreaterThan"
|
||||
| GreaterThanEquals -> "GreaterThanEquals"
|
||||
| Assign -> "Assign"
|
||||
|
||||
(** [string_of_unary_operator op] returns a string representation of the unary operator [op]. *)
|
||||
let string_of_unary_operator = function Negate -> "Negate" | Not -> "Not"
|
||||
|
||||
(** [string_of_expression e] returns a string representation of the expression [e]. *)
|
||||
let rec string_of_expression = function
|
||||
| Literal l -> "Literal(" ^ string_of_literal l ^ ")"
|
||||
| Identifier i -> "Identifier(\"" ^ i ^ "\")"
|
||||
| UnaryExpression (op, e) ->
|
||||
"UnaryExpression("
|
||||
^ string_of_unary_operator op
|
||||
^ ", " ^ string_of_expression e ^ ")"
|
||||
| BinaryExpression (op, e1, e2) ->
|
||||
"BinaryExpression("
|
||||
^ string_of_binary_operator op
|
||||
^ ", " ^ string_of_expression e1 ^ ", " ^ string_of_expression e2 ^ ")"
|
||||
|
||||
let string_of_variable_declaration = function
|
||||
| VariableDeclaration (t, id, e) ->
|
||||
"VariableDeclaration(" ^ string_of_type t ^ ", " ^ string_of_expression id
|
||||
^ ", " ^ string_of_expression e ^ ")"
|
||||
|
||||
(** [string_of_statement s] returns a string representation of the statement [s]. *)
|
||||
let string_of_statement = function
|
||||
| ExpressionStatement e ->
|
||||
"ExpressionStatement(" ^ string_of_expression e ^ ")"
|
||||
| VariableStatement decls ->
|
||||
let decl_strings = List.map string_of_variable_declaration decls in
|
||||
"VariableStatement([" ^ String.concat ", " decl_strings ^ "])"
|
||||
|
||||
(** [string_of_source_file f] returns a string representation of the source file [f]. *)
|
||||
let string_of_source_file = function
|
||||
| SourceFile stmts ->
|
||||
let stmt_strings = List.map string_of_statement stmts in
|
||||
"SourceFile([" ^ String.concat ", " stmt_strings ^ "])"
|
||||
|
||||
(** The signature of the module [Print]. *)
|
||||
module type Print = sig
|
||||
val string_of_type : _type -> string
|
||||
val string_of_binary_operator : binary_operator -> string
|
||||
val string_of_unary_operator : unary_operator -> string
|
||||
val string_of_literal : literal -> string
|
||||
val string_of_expression : expression -> string
|
||||
val string_of_variable_declaration : variable_declaration -> string
|
||||
val string_of_statement : statement -> string
|
||||
val string_of_source_file : source_file -> string
|
||||
end
|
||||
@@ -1,49 +0,0 @@
|
||||
(* lib/ast/syntax.ml *)
|
||||
|
||||
type _type =
|
||||
| IntegerType
|
||||
| FloatType
|
||||
| CharacterType
|
||||
| StringType
|
||||
| BooleanType
|
||||
| VoidType
|
||||
|
||||
type literal =
|
||||
| Integer of int
|
||||
| Float of float
|
||||
| Character of char
|
||||
| String of string
|
||||
| Boolean of bool
|
||||
| Null
|
||||
|
||||
type binary_operator =
|
||||
| Add
|
||||
| Subtract
|
||||
| Multiply
|
||||
| Divide
|
||||
| AmpersandAmpersand
|
||||
| BarBar
|
||||
| EqualsEquals
|
||||
| ExclamationEquals
|
||||
| LessThan
|
||||
| LessThanEquals
|
||||
| GreaterThan
|
||||
| GreaterThanEquals
|
||||
| Assign
|
||||
|
||||
type unary_operator = Negate | Not
|
||||
|
||||
type expression =
|
||||
| Literal of literal
|
||||
| Identifier of string
|
||||
| UnaryExpression of unary_operator * expression
|
||||
| BinaryExpression of binary_operator * expression * expression
|
||||
|
||||
type variable_declaration =
|
||||
| VariableDeclaration of _type * expression * expression
|
||||
|
||||
type statement =
|
||||
| ExpressionStatement of expression
|
||||
| VariableStatement of variable_declaration list
|
||||
|
||||
type source_file = SourceFile of statement list
|
||||
@@ -1,97 +0,0 @@
|
||||
(* lib/ast/syntax.ml *)
|
||||
|
||||
open Syntax
|
||||
|
||||
exception Type_error of string
|
||||
|
||||
type environment = { variables : (string * _type) list }
|
||||
|
||||
(** [type_of_literal lit] returns the type of the given literal. *)
|
||||
let type_of_literal (lit : literal) : _type =
|
||||
match lit with
|
||||
| Integer _ -> IntegerType
|
||||
| Float _ -> FloatType
|
||||
| Character _ -> CharacterType
|
||||
| String _ -> StringType
|
||||
| Boolean _ -> BooleanType
|
||||
| Null -> VoidType
|
||||
|
||||
(** [type_of_expression env expr] returns the type of the given expression. *)
|
||||
let rec type_of_expression (env : environment) (expr : expression) : _type =
|
||||
match expr with
|
||||
| Literal lit -> type_of_literal lit
|
||||
| Identifier id -> (
|
||||
try List.assoc id env.variables
|
||||
with Not_found -> raise (Type_error ("Unknown variable " ^ id)))
|
||||
| UnaryExpression (op, expr) -> (
|
||||
let expr_type = type_of_expression env expr in
|
||||
match op with
|
||||
| Negate -> (
|
||||
match expr_type with
|
||||
| IntegerType | FloatType -> expr_type
|
||||
| _ ->
|
||||
raise
|
||||
(Type_error "Negate operator can only be applied to numbers"))
|
||||
| Not -> (
|
||||
match expr_type with
|
||||
| BooleanType -> BooleanType
|
||||
| _ ->
|
||||
raise (Type_error "Not operator can only be applied to booleans"))
|
||||
)
|
||||
| BinaryExpression (op, left, right) -> (
|
||||
let left_type = type_of_expression env left in
|
||||
let right_type = type_of_expression env right in
|
||||
match op with
|
||||
| Add | Subtract | Multiply | Divide -> (
|
||||
match (left_type, right_type) with
|
||||
| IntegerType, IntegerType -> IntegerType
|
||||
| FloatType, FloatType -> FloatType
|
||||
| IntegerType, FloatType | FloatType, IntegerType -> FloatType
|
||||
| _ -> raise (Type_error "Arithmetic operations require numbers"))
|
||||
| AmpersandAmpersand | BarBar -> (
|
||||
match (left_type, right_type) with
|
||||
| BooleanType, BooleanType -> BooleanType
|
||||
| _ -> raise (Type_error "Logical operations require booleans"))
|
||||
| EqualsEquals | ExclamationEquals -> BooleanType
|
||||
| LessThan | LessThanEquals | GreaterThan | GreaterThanEquals -> (
|
||||
match (left_type, right_type) with
|
||||
| IntegerType, IntegerType | FloatType, FloatType -> BooleanType
|
||||
| IntegerType, FloatType | FloatType, IntegerType -> BooleanType
|
||||
| _ -> raise (Type_error "Comparison operations require numbers"))
|
||||
| Assign -> (
|
||||
match left with
|
||||
| Identifier _ ->
|
||||
if left_type = right_type then left_type
|
||||
else raise (Type_error "Assignment requires matching types")
|
||||
| _ ->
|
||||
raise
|
||||
(Type_error
|
||||
"Assignment requires a variable on the left-hand side")))
|
||||
|
||||
(** [type_of_variable_declaration env var_decl] returns the environment after
|
||||
processing the given variable declaration. *)
|
||||
let type_of_variable_declaration (env : environment)
|
||||
(VariableDeclaration (_type, id_expr, expr)) =
|
||||
match id_expr with
|
||||
| Identifier id ->
|
||||
let expr_type = type_of_expression env expr in
|
||||
if expr_type = _type then { variables = (id, _type) :: env.variables }
|
||||
else
|
||||
raise (Type_error ("Type mismatch in variable declaration for " ^ id))
|
||||
| _ -> raise (Type_error "Variable name must be an identifier")
|
||||
|
||||
(** [type_of_statement env stmt] returns the environment after processing the
|
||||
given statement. *)
|
||||
let type_of_statement (env : environment) (stmt : statement) =
|
||||
match stmt with
|
||||
| ExpressionStatement expr ->
|
||||
let _ = type_of_expression env expr in
|
||||
env
|
||||
| VariableStatement var_decls ->
|
||||
List.fold_left type_of_variable_declaration env var_decls
|
||||
|
||||
(** [type_of_source_file (SourceFile stmts)] returns the environment after
|
||||
processing the given source file. *)
|
||||
let type_of_source_file (SourceFile stmts) =
|
||||
let initial_env = { variables = [] } in
|
||||
List.fold_left type_of_statement initial_env stmts
|
||||
@@ -1 +1,3 @@
|
||||
;lib/dune
|
||||
(library
|
||||
(name Croissant)
|
||||
(libraries Syntax Analyzer))
|
||||
|
||||
@@ -1,5 +0,0 @@
|
||||
; lib/eval/dune
|
||||
|
||||
;(library
|
||||
; (name eval)
|
||||
; (modules eval))
|
||||
@@ -0,0 +1,7 @@
|
||||
type binary_operators = Add | Subtract | Multiply | Divide
|
||||
|
||||
let pp_binary_operators = function
|
||||
| Add -> "Add"
|
||||
| Subtract -> "Subtract"
|
||||
| Multiply -> "Multiply"
|
||||
| Divide -> "Divide"
|
||||
@@ -0,0 +1,21 @@
|
||||
open Literals
|
||||
open UnaryOperators
|
||||
open BinaryOperators
|
||||
|
||||
type expressions =
|
||||
| Literal of literals
|
||||
| UnaryExpression of unary_operators * expressions
|
||||
| BinaryExpression of binary_operators * expressions * expressions
|
||||
|
||||
let rec pp_expressions = function
|
||||
| Literal l ->
|
||||
let pp_l = pp_literals l in
|
||||
Printf.sprintf "Literal(%s)" pp_l
|
||||
| UnaryExpression (op, e) ->
|
||||
let pp_op = pp_unary_operators op and pp_e = pp_expressions e in
|
||||
Printf.sprintf "UnaryExpression(%s, %s)" pp_op pp_e
|
||||
| BinaryExpression (op, e1, e2) ->
|
||||
let pp_op = pp_binary_operators op
|
||||
and pp_e1 = pp_expressions e1
|
||||
and pp_e2 = pp_expressions e2 in
|
||||
Printf.sprintf "BinaryExpression(%s, %s, %s)" pp_op pp_e1 pp_e2
|
||||
@@ -0,0 +1,15 @@
|
||||
type literals =
|
||||
| Integer of int
|
||||
| Float of float
|
||||
| Character of char
|
||||
| String of string
|
||||
| Boolean of bool
|
||||
| Null
|
||||
|
||||
let pp_literals = function
|
||||
| Integer i -> Printf.sprintf "Integer(%d)" i
|
||||
| Float f -> Printf.sprintf "Float(%f)" f
|
||||
| Character c -> Printf.sprintf "Character('%c')" c
|
||||
| String s -> Printf.sprintf "String(\"%s\")" s
|
||||
| Boolean b -> Printf.sprintf "Boolean(%b)" b
|
||||
| Null -> "Null"
|
||||
@@ -0,0 +1,8 @@
|
||||
open Statements
|
||||
|
||||
type source_files = SourceFile of statements
|
||||
|
||||
let pp_source_files = function
|
||||
| SourceFile stmts ->
|
||||
let pp_stmt = pp_statements stmts in
|
||||
Printf.sprintf "SourceFile(%s)" pp_stmt
|
||||
@@ -0,0 +1,13 @@
|
||||
open Expressions
|
||||
|
||||
type statements =
|
||||
| SequenceStatement of statements * statements
|
||||
| ExpressionStatement of expressions
|
||||
|
||||
let rec pp_statements = function
|
||||
| SequenceStatement (stmt1, stmt2) ->
|
||||
let pp_stmt1 = pp_statements stmt1 and pp_stmt2 = pp_statements stmt2 in
|
||||
Printf.sprintf "SequenceStatement(%s, %s)" pp_stmt1 pp_stmt2
|
||||
| ExpressionStatement expr ->
|
||||
let pp_expr = pp_expressions expr in
|
||||
Printf.sprintf "ExpressionStatement(%s)" pp_expr
|
||||
@@ -0,0 +1,15 @@
|
||||
type types =
|
||||
| IntegerType
|
||||
| FloatType
|
||||
| CharacterType
|
||||
| StringType
|
||||
| BooleanType
|
||||
| VoidType
|
||||
|
||||
let pp_types = function
|
||||
| IntegerType -> "IntegerType"
|
||||
| FloatType -> "FloatType"
|
||||
| CharacterType -> "CharacterType"
|
||||
| StringType -> "StringType"
|
||||
| BooleanType -> "BooleanType"
|
||||
| VoidType -> "VoidType"
|
||||
@@ -0,0 +1,5 @@
|
||||
type unary_operators = ArithmeticNegation | LogicalNegation
|
||||
|
||||
let pp_unary_operators = function
|
||||
| ArithmeticNegation -> "ArithmeticNegation"
|
||||
| LogicalNegation -> "LogicalNegation"
|
||||
@@ -0,0 +1,10 @@
|
||||
(library
|
||||
(name Syntax)
|
||||
(modules
|
||||
Types
|
||||
Literals
|
||||
BinaryOperators
|
||||
UnaryOperators
|
||||
Expressions
|
||||
Statements
|
||||
SourceFiles))
|
||||
Reference in New Issue
Block a user