taddeus
/
civicaml


			
				
					
						
						
							123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193
							(** Type definitions for abstract syntax tree, assembly code, and exceptions. *)

(** {2 Abstract Syntax Tree} *)

(** [(filename, startline, endline, startcol, endcol)]
    Location of node in source code. Used for error reporting. *)
type location = string * int * int * int * int

(** All operators supported by CiviC. *)
type operator =
  | Neg | Not
  | Add | Sub | Mul | Div | Mod
  | Eq | Ne | Lt | Le | Gt | Ge
  | And | Or

(** Wrappers for constant values. This eliminates the need for separate
    [(Bool|Int|Float)Const] nodes, and these values can be passed to {!instr}
    constructors as well. *)
type const =
  | BoolVal of bool
  | IntVal of int
  | FloatVal of float

(** Data types supported by CiviC. [ArrayDims] defines an array type with a set
    of dimensions. {!Dimreduce} replaces this multi-dimensional type with an
    [Array] type, which signifies a one-dimensional array of a certain basic
    type. *)
type ctype =
  | Void | Bool | Int | Float | Array of ctype
  | ArrayDims of ctype * node list

(** Annotations for {!node}. Each node has a list of zero or more annotations
    that are gradually added through the compiler phases:

    - [Loc] is a location added by the parser.
    - [Depth] is the nesting level of a variable or function, and is added by
      {!Context}.
    - [Type] is a {!ctype} annotation added by {!Typecheck}.
    - [Index] is the stack index of a variable declaration, added by {!Index}.
    - [LabelName] is also added during index analysis, it holds the label name
      of a [FunDef]. *)
and annotation =
  | Loc of location
  | Depth of int
  | Type of ctype
  | Index of int
  | LabelName of string

(** Shorthand for annotation list used in definition of {!node}, should not be
    used elsewhere. *)
and ann = annotation list

(** Abstract Syntax Tree nodes. *)
and node =
  (* Global *)
  | Program of node list * ann
    (** list of declarations *)
  | FunDec of ctype * string * node list * ann
    (** ret_type, name, params *)
  | FunDef of bool * ctype * string * node list * node * ann
    (** export, ret_type, name, params, body *)
  | GlobalDec of ctype * string * ann
    (** type, name *)
  | GlobalDef of bool * ctype * string * node option * ann
    (** export, type, name, initialisation *)
  | Param of ctype * string * ann
    (** type, name *)
  | Dim of string * ann
    (** name *)

  | VarDecs of node list
  | LocalFuns of node list

  (* Statements *)
  | VarDec of ctype * string * node option * ann
    (** type, name, initialisation *)
  | Assign of string * node list option * node * ann
    (** name, indices, value *)
  | For of string * node * node * node * node * ann
    (** counter, start, stop, step, body *)
  | Allocate of node * node list * ann
    (** declaration, dims *)
  | Return of node * ann                     (** return value [return <value>;] *)
  | Expr of node                             (** expression statement [<expr>;] *)
  | Block of node list                       (** body [{ <body> }] *)
  | If of node * node * ann                  (** condition, body [if (condition) { body }] *)
  | IfElse of node * node * node * ann
    (** condition, true_body, false_body [if (<condition>) { <true_body> } else { <false_body> }] *)
  | While of node * node * ann
    (** condition, body [while (<condition>) { <body> }] *)
  | DoWhile of node * node * ann
    (** condition, body [do { <body> } whlie (<condition>)] *)

  (* Expressions *)
  | Const of const * ann                     (** constant [bool|int|float constant] *)
  | ArrayConst of node list * ann            (** array initialisation [[ <expr> , ... ]] *)
  | Var of string * node list option * ann   (** name, indices [<name> | <name>[<indices>] ] *)
  | Monop of operator * node * ann           (** operator, operand [<operator><operand>] *)
  | Binop of operator * node * node * ann    (** operator, left, right [<left> <operator> <right>] *)
  | TypeCast of ctype * node * ann           (** target_type, value [(target_type)value] *)
  | FunCall of string * node list * ann      (** name, args [<name>(<args>)] *)
  | Arg of node                              (** function argument *)

  (* Additional types for convenience in traversals
   * Mostly used to annotate existing nodes with information from declarations *)
  | VarUse of node * node list option * ann  (* Same as Var, but with decl. *)
  | FunUse of node * node list * ann         (* Same as FunCall, but with decl. *)
  | VarLet of node * node list option * node * ann (* replacement for Assign *)
  | ArrayScalar of node                      (* (Bool|Int|Float)Const *)
  | ArrayInit of node * node list            (* Array(Scalar|Const), dimensions *)
  | Cond of node * node * node * ann         (* cond, true_expr, false_expr *)
  | DummyNode                                (* null node, pruned by traversals *)

(** {2 Assembly instructions} *)

type stack_scope = Glob | Local | Rel of int | Current
type rtn_scope = ExternFun of int | LocalFun of int * string
type instr =
  | Comment of string                 (* # <comment> *)
  | InlineComment of instr * string   (* <instr>  # <comment> *)
  | Label of string                   (* <label>: *)

  (* Directives *)
  (* .export "<name>" <ret_type> [ <arg_type>; ... ] <label> *)
  | Export of string * ctype * ctype list * string
  (* .import "<name>" <ret_type> [ <arg_type>; ... ] *)
  | Import of string * ctype * ctype list
  (* .const <value> *)
  | ConstDef of const
  (* .global <type> *)
  | Global of ctype

  | Store of ctype * stack_scope * int (* [ifba]store[ gn] *)

  | Load of ctype * stack_scope * int  (* [ifb]load[ gn] G *)
  | LoadConst of ctype * int           (* [ifb]loadc C *)
  | LoadImm of const                   (* [ifb]load_[01tf] <value> *)

  (* Operators *)
  | Op of operator * ctype             (* [ifb]() *)
  | Convert of ctype * ctype           (* i2f|f2i *)
  | Inc of int * int                   (* iinc L C *)
  | Dec of int * int                   (* idec L C *)
  | IncOne of int                      (* iinc_1 L *)
  | DecOne of int                      (* idec_1 L *)

  (* Control flow *)
  | RtnInit of stack_scope
  | RtnJmp of rtn_scope
  | RtnEnter of int
  | Ret of ctype
  | Branch of bool * string
  | Jump of string

  (* Stack management *)
  | Pop of ctype                       (* [ifb]pop *)

  (* Arrays *)
  | NewArray of ctype * int
  | LoadArray of ctype
  | StoreArray of ctype

  | EmptyLine
  | DummyInstr

(** {2 General} *)

(* Intermediate representations between phases *)
type intermediate =
  | Empty
  | FileContent of string * string
  | Ast of node
  | Assembly of instr list

(** Container for command-line arguments. *)
type args_record = {
  mutable infile   : string option;
  mutable outfile  : string option;
  mutable verbose  : int;
  mutable cpp      : bool;
  mutable optimize : bool;
  mutable endphase : string;
}

(** {2 Exceptions} *)

exception LocError of location * string
exception NodeError of node * string
exception CompileError of string
exception EmptyError

exception InvalidNode
exception InvalidInput of string