package mopsa

You can search for identifiers within the package.

in-package search v0.2.0

On This Page

Interpreter state
Parsing
Printing
Main loop
Interactive "program"

Module `Repl.Frontend`

Read-eval-print-loop interactive frontend. Borrows the syntax and semantics from universal.

Interpreter state

*********************

type ctx = {

ctx_var : Universal.Lang.Frontend.var_context;
ctx_fun : Universal.Lang.Frontend.fun_context;

}

val init_ctx : unit -> ctx

Parsing

***********

val range_of_string : ?org:??? -> string -> MopsaLib.range

val parse_string : 
  ?org:??? ->
  ((Lexing.lexbuf -> Mopsa_universal_parser.U_parser.token) ->
    Lexing.lexbuf ->
    'a) ->
  string ->
  'a

Helper to parse a string using a menhir parser entry point.

val parse_expr : ?org:??? -> ctx -> string -> MopsaLib.expr

Parse an expression.

val parse_stmt : ?org:??? -> ctx -> string -> MopsaLib.stmt

Parse a statement.

val parse_vardec : 
  ?org:??? ->
  ctx ->
  string ->
  ctx * MopsaLib.stmt list * MopsaLib.var list

Parse a variable declaration.

val parse_fundec : ?org:??? -> ctx -> string -> ctx * Universal.Lang.Ast.fundec

Parse a function declaration.

val parse_var : ?org:??? -> ctx -> string -> MopsaLib.var

Parse a variable.

type input_class =

| VarDecl
| FunDecl
| Stmt

val vardecl_str : Str.regexp

val fundecl_str : Str.regexp

val classify_input : string -> input_class

Try to guess the nature of the input.

Printing

************

val eol : Str.regexp

val print_highlight : string -> MopsaLib.range -> unit

Prints a string with some locations highlighted.

Main loop

*************

val spaces : Str.regexp

val repl_ctx : Mopsa_utils.Core.LineEdit.ctx

val prompt : string

val col_reset : string

val col_error : string

val col_out : string

val pf : ('a, Format.formatter, unit) format -> 'a

val print_usage : unit -> unit

val repl_loop : 
  ctx ->
  ('a, 'b) Framework.Core.Manager.man ->
  'a Core.Flow.flow ->
  'a Core.Flow.flow

val enter_repl : 
  ('a, 'b) Framework.Core.Manager.man ->
  'a Core.Flow.flow ->
  'a Core.Flow.flow

Main loop.

Interactive "program"

type MopsaLib.prog_kind +=

| P_REPL

val parse_program : 'a list -> MopsaLib.program

Ignore files and return the constant P_REPL program.

module Domain : sig ... end