an implementation of language AA More...

Inheritance diagram for com.cliffc.aa.Parse:

Collaboration diagram for com.cliffc.aa.Parse:

Public Attributes
final GVNGCM	_gvn

Package Functions
	Parse (String src, Env env, String str)

UnOrFunPtrNode	bal_open ()

Node	bfact (int oldx, UnOrFunPtrNode bfun)
	A balanced operator as a fact(). More...

Node	do_exit (ScopeNode s, Node rez)

String	dump ()

String	dumprpo ()

TypeEnv	go ()

Static Package Functions
static boolean	isOp (String s)

Private Member Functions
Node	_expr (int prec)

Node	_expr_higher (int prec, Node lhs)

Node	_expr_higher_require (int prec, String bintok, Node lhs)

boolean	_good_prec_tok (int prec, String bintok)

Node	_short_circuit_expr (Node lhs, int prec, String bintok, Node op, int opx, int lhsx, int rhsx)

Node	apply ()
	Parse a lisp-like function application. More...

Node	expr ()
	Parse an expression, a series of terms separated by binary operators. More...

Node	fact ()
	Parse a factor, a leaf grammar token fact = num // number fact = "string" // string fact = (stmts) // General statements parsed recursively fact = (tuple,) // tuple; first comma required, trailing comma not required fact = balop+ stmts balop- // Constructor with initial size Ex: [ 7 ] // Array constructor fact = balop+ stmts[, stmts] balop- // Constructor with initial elements Ex: [ 1 , 2 ] // Array constructor with initial elements fact = {binop} // Special syntactic form of binop; no spaces allowed; returns function constant fact = {uniop} // Special syntactic form of uniop; no spaces allowed; returns function constant fact = {func} // Anonymous function declaration fact = id // variable lookup, NOT a binop or uniop but might be e.g. More...

int	field_number ()

Node	func ()

TypeEnv	gather_errors ()

Node	ifex ()
	Parse an if-expression, with lazy eval on the branches. More...

Node	inc (String tok, int d)

Node	merge_exits (Node rez)

Type	number ()

void	prog ()
	Parse a top-level: prog = stmts END. More...

void	remove_unknown_callers ()

Node	stmt (boolean lookup_current_scope_only)
	A statement is a list of variables to final-assign or re-assign, and an ifex for the value. More...

Node	stmts ()
	Parse a list of statements; final semi-colon is optional. More...

Node	stmts (boolean lookup_current_scope_only)

Node	string ()
	Parse a String; _x is at '"'. More...

Node	struct ()
	Parse anonymous struct; the opening "@{" already parsed. More...

Node	term ()
	Any number field-lookups or function applications, then an optional assignment term = id++ \| id– term = uniop term term = tfact [tuple \| .field \| [.field[:]=stmt \| .field++ \| .field– \| e] term = tfact bopen stmts bclose // if bopen/bclose is arity-2 e.g. More...

Node	tfact ()
	Parse an optionally typed factor tfact = fact[:type]. More...

String	token ()

String	token0 ()

Node	tstmt ()
	A type-statement assigns a type to a type variable. More...

Node	tuple (int oldx, Node s, int first_arg_start)
	Parse a tuple; first stmt but not the ',' parsed. More...

Node	typechk (Node x, Type t, Node mem, Parse bad)

Private Attributes
final byte[]	_buf

Env	_e

int	_lastNWS

final AryInt	_lines

final NumberFormat	_nf

final ParsePosition	_pp

final String	_src

final String	_str

int	_x

Static Private Attributes
static final Access	args_are_mutable =Access.Final
	Parse an anonymous function; the opening '{' already parsed. More...

private< N extends Node > N	init (N n)

private< N extends Node > N	set_ctrl (N n)

Parse	errMsg ()

Parse	errMsg (int x)

Parse[]	errMsgs (int... xs)

Type	type ()
	Parse a type or return null type = tcon \| tfun \| tary \| tstruct \| ttuple \| tvar // Type choices tcon = int, int[1,8,16,32,64], flt, flt[32,64], real, str[?] tary = '[' type? ']' // Cannot specify type for array size tfun = {[[type]* ->]? type } // Function types mirror func decls tmod = = \| := \| == // '=' is r/final, ':=' is r/w, '==' is read-only tstruct = [id [tmod [type?]];]*} // Struct types are field names with optional types. More...

Type	typev ()

Type	typep (boolean type_var)

Type	typeq (Type t)

Access	tmod ()

Type	type0 (boolean type_var)

void	require (char c, int oldx)

void	require (String s, int oldx)

boolean	peek (char c)

boolean	peek_noWS (char c)

boolean	peek1 (byte c0, char c)

boolean	peek2 (byte c0, String s2)

boolean	peek (String s)

boolean	peek_not (char c, char no)

String	peek (String[] toks)

boolean	peek1 (String tok)

byte	skipWS ()
	Advance parse pointer to the first non-whitespace character, and return that character, -1 otherwise. More...

void	skipEOL ()

void	skipBlock ()

void	skipNonWS ()

void	kill (Node n)

Node	mem ()

void	set_mem (Node n)

ConNode	con (Type t)

ScopeNode	lookup_scope (String tok, boolean lookup_current_scope_only)

void	create (String tok, Node n, Access mutable)

Node	get_display_ptr (ScopeNode scope)

Node[]	args (Node a0, Node a1)

Node[]	args (Node a0, Node a1, Node a2)

Node[]	args (Node a0, Node a1, Node a2, Node a3)

Node[]	_args (Node[] args)

Node	do_call (Parse[] bads, Node... args)

Node	do_call0 (boolean unpack, Parse[] bads, Node... args)

ErrNode	err_ctrl1 (Node.ErrMsg msg)

ErrNode	err_ctrl2 (String msg)

void	err_ctrl0 (String s)

void	err_ctrl3 (String s, Parse open)

	Parse (Parse P)

static boolean	isWS (byte c)
	Return true if `c` passes a test. More...

static boolean	isAlpha0 (byte c)

static boolean	isAlpha1 (byte c)

static boolean	isOp0 (byte c)

static boolean	isOp1 (byte c)

static boolean	isDigit (byte c)

Node	gvn (Node n)

Node	ctrl ()

Node	lookup (String tok)

ScopeNode	scope ()

String	errLocMsg (String s)

String	toString ()

boolean	equals (Object loc)

int	hashCode ()

int	compareTo (Parse loc)

Detailed Description

an implementation of language AA

GRAMMAR: prog = stmts END stmts= [tstmt|stmt][; stmts]*[;]? // multiple statements; final ';' is optional tstmt= tvar = :type // type variable assignment stmt = [id[:type] [:]=]* ifex // ids are (re-)assigned, and are available in later statements stmt = ^ifex // Early function exit ifex = apply [? stmt [: stmt]] // trinary short-circuit logic; missing ":stmt" will default to 0 apply= expr | expr expr* // Lisp-like application-as-adjacent expr = term [binop term]* // gather all the binops and sort by precedence term = uniop term // Any number of prefix uniops term = id++ | id– // then postfix update ops term = tfact bopen stmts bclose // if bopen/bclose is arity-2 e.g. ary[idx] term = tfact bopen stmts bclose stmt // if bopen/bclose is arity-3 e.g. ary[idx]=val term = tfact post // A term is a tfact and some more stuff... post = empty // A term can be just a plain 'tfact' post = (tuple) post // Application argument list post = .field post // Field and tuple lookup post = .field [:]= stmt // Field (re)assignment. Plain '=' is a final assignment post = .field++ | .field– // Allowed anytime a := is allowed post = :type post // TODO: Add this, remove 'tfact' tfact= fact[:type] // Typed fact fact = id // variable lookup fact = num // number fact = "string" // string fact = [stmts] // array decl with size fact = [stmts,[stmts,]*] // array decl with tuple fact = (stmts) // General statements parsed recursively fact = (tuple) // Tuple builder fact = func // Anonymous function declaration fact = stmts } // Anonymous struct declaration, assignments define fields fact = {binop} // Special syntactic form of binop; no spaces allowed; returns function constant fact = {uniop} // Special syntactic form of uniop; no spaces allowed; returns function constant tuple= (stmts,[stmts,]) // Tuple; final comma is optional, first comma is required binop= +-*%&|/<>!= [ ]= // etc; primitive lookup; can determine infix binop at parse-time uniop= -!~# a // etc; primitive lookup; can determine infix uniop at parse-time func = { [id[:type]* ->]? stmts} // Anonymous function declaration, if no args then the -> is optional // Pattern matching: 1 arg is the arg; 2+ args break down a (required) tuple str = [.%]* // String contents; \t
\r% standard escapes str = %[num]?[.num]?fact // Percent escape embeds a 'fact' in a string; "name=%name\n" type = tcon | tvar | tfun[?] | tstruct[?] | ttuple[?] // Types are a tcon or a tfun or a tstruct or a type variable. A trailing ? means 'nilable' tcon = int, int[1,8,16,32,64], flt, flt[32,64], real, str[?] tfun = {[[type]* ->]? type } // Function types mirror func declarations ttuple = ( [[type],]* ) // Tuple types are just a list of optional types; the count of commas dictates the length, zero commas is zero length. Tuples are always final. tmod = := | = | == // ':=' or '' is r/w, '=' is final, '==' is r/o tstruct = [id [tmod [type?]],]*} // Struct types are field names with optional types. Spaces not allowed tvar = id // Type variable lookup

Definition at line 68 of file Parse.java.

Constructor & Destructor Documentation

◆ Parse() [1/2]

com.cliffc.aa.Parse.Parse	(	String	src,
		Env	env,
		String	str
	)

package

Definition at line 82 of file Parse.java.

                                            {
     _src = src;
     _e   = env;
     _buf = str.getBytes();
     _x   = 0;
  
     // Set fields strictly for Java number parsing
     _nf = NumberFormat.getInstance();
     _nf.setGroupingUsed(false);
     _pp = new ParsePosition(0);
     _str = str;           // Keep a complete string copy for java number parsing
     _lines = new AryInt();//
     _lines.push(0);       // Line 0 at offset 0
     _gvn = Env.GVN;       // Pessimistic during parsing
   }

References com.cliffc.aa.Parse._buf, com.cliffc.aa.Parse._e, com.cliffc.aa.Parse._gvn, com.cliffc.aa.Parse._lines, com.cliffc.aa.Parse._nf, com.cliffc.aa.Parse._pp, com.cliffc.aa.Parse._src, com.cliffc.aa.Parse._str, com.cliffc.aa.Parse._x, com.cliffc.aa.Env.GVN, and com.cliffc.aa.util.AryInt.push().

Referenced by com.cliffc.aa.Parse.equals(), and com.cliffc.aa.Parse.errMsg().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Parse() [2/2]

com.cliffc.aa.Parse.Parse ( Parse P )

private

Definition at line 1445 of file Parse.java.

                            {
     _src  = P._src;
     _buf  = P._buf;
     _x    = P._x;
     _lines= P._lines;
     _gvn  = P._gvn;
     _lastNWS = P._lastNWS;
     _e    = null;  _nf  = null;  _pp  = null;  _str = null;
   }

References com.cliffc.aa.Parse._buf, com.cliffc.aa.Parse._e, com.cliffc.aa.Parse._gvn, com.cliffc.aa.Parse._lastNWS, com.cliffc.aa.Parse._lines, com.cliffc.aa.Parse._nf, com.cliffc.aa.Parse._pp, com.cliffc.aa.Parse._src, com.cliffc.aa.Parse._str, and com.cliffc.aa.Parse._x.

Member Function Documentation

◆ _args()

Node [] com.cliffc.aa.Parse._args ( Node[] args )

private

Definition at line 1398 of file Parse.java.

                                     {
     //args[MEM_IDX] = gvn(new FreshNode(_e._nongen,ctrl(),mem())).keep(); // Always memory
     for( int i=ARG_IDX; i<args.length; i++ ) args[i].keep(); // Hook all args before reducing display
     args[DSP_IDX] = gvn(new FreshNode(_e._nongen,ctrl(),gvn(new FP2DispNode(args[DSP_IDX])))); // Reduce display
     args[CTL_IDX] = ctrl();     // Always control
     args[MEM_IDX] = mem();      // Always memory
     for( int i=ARG_IDX; i<args.length; i++ ) {
       args[i].unkeep();
       // Generally might want this in unkeep(), except for cost
       if( args[i]._val.is_con() ) Env.GVN.add_reduce(args[i]);
     }
     return args;
   }

References com.cliffc.aa.Parse._e, com.cliffc.aa.Env._nongen, com.cliffc.aa.GVNGCM.add_reduce(), com.cliffc.aa.Parse.args(), com.cliffc.aa.Parse.ctrl(), com.cliffc.aa.Env.GVN, com.cliffc.aa.Parse.gvn(), com.cliffc.aa.Parse.mem(), and com.cliffc.aa.node.Node.unkeep().

Referenced by com.cliffc.aa.Parse.args().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _expr()

Node com.cliffc.aa.Parse._expr ( int prec )

private

Definition at line 465 of file Parse.java.

                                {
     int lhsx = _x;              // Invariant: WS already skipped
     Node lhs = _expr_higher(prec,null);
     if( lhs==null ) return null;
     while( true ) {             // Kleene star at this precedence
       // Look for a binop at this precedence level
       int opx = _x;             // Invariant: WS already skipped
       String bintok = peek(PrimNode.PRIM_TOKS);
       if( !_good_prec_tok(prec,bintok) ) return lhs; // No token at this precedence
       _x += bintok.length();
       skipWS();
       int rhsx = _x;            // Invariant: WS already skipped
       lhs.keep();
       // Get the matching FunPtr (or Unresolved).
       // This is a primitive lookup and always returns a FRESH copy (see HM.Ident).
       UnOrFunPtrNode op = _e.lookup_filter_fresh(bintok.intern(),2,ctrl()); // BinOp, or null
       assert op!=null;          // Since found valid token, must find matching primnode
       FunNode sfun = op.funptr().fun();
       assert sfun._op_prec == prec;
       // Check for Thunking the RHS
       if( sfun._thunk_rhs ) {
         lhs = _short_circuit_expr(lhs.unkeep(),prec,bintok,op,opx,lhsx,rhsx);
       } else {                  // Not a thunk!  Eager evaluation of RHS
         op.keep();
         Node rhs = _expr_higher_require(prec,bintok,lhs.unkeep());
         // Emit the call to both terms
         // LHS in unhooked prior to optimizing/replacing.
         lhs = do_call(errMsgs(opx,lhsx,rhsx), args(op.unkeep(),lhs,rhs));
       }
       // Invariant: LHS is unhooked
     }
   }

Referenced by com.cliffc.aa.Parse._expr_higher(), and com.cliffc.aa.Parse.expr().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _expr_higher()

Node com.cliffc.aa.Parse._expr_higher	(	int	prec,
		Node	lhs
	)

private

Definition at line 499 of file Parse.java.

                                                   {
     if( lhs != null ) lhs.keep();
     Node rhs = prec+1 == PrimNode.PREC_TOKS.length ? term() : _expr(prec+1);
     if( lhs != null ) lhs.unkeep();
     return rhs;
   }

References com.cliffc.aa.Parse._expr(), com.cliffc.aa.node.Node.keep(), com.cliffc.aa.node.PrimNode.PREC_TOKS, com.cliffc.aa.Parse.term(), and com.cliffc.aa.node.Node.unkeep().

Referenced by com.cliffc.aa.Parse._expr(), and com.cliffc.aa.Parse._expr_higher_require().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _expr_higher_require()

Node com.cliffc.aa.Parse._expr_higher_require	(	int	prec,
		String	bintok,
		Node	lhs
	)

private

Definition at line 505 of file Parse.java.

                                                                          {
     Node rhs = _expr_higher(prec,lhs);
     return rhs==null ? err_ctrl2("Missing term after '"+bintok+"'") : rhs;
   }

References com.cliffc.aa.Parse._expr_higher(), and com.cliffc.aa.Parse.err_ctrl2().

Referenced by com.cliffc.aa.Parse._expr(), and com.cliffc.aa.Parse._short_circuit_expr().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _good_prec_tok()

boolean com.cliffc.aa.Parse._good_prec_tok	(	int	prec,
		String	bintok
	)

private

Definition at line 510 of file Parse.java.

                                                           {
     if( bintok==null ) return false;
     for( String tok : PrimNode.PREC_TOKS[prec] ) if( Util.eq(bintok,tok) ) return true;
     return false;
   }

References com.cliffc.aa.util.Util.eq(), and com.cliffc.aa.node.PrimNode.PREC_TOKS.

Referenced by com.cliffc.aa.Parse._expr().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _short_circuit_expr()

Node com.cliffc.aa.Parse._short_circuit_expr	(	Node	lhs,
		int	prec,
		String	bintok,
		Node	op,
		int	opx,
		int	lhsx,
		int	rhsx
	)

private

Definition at line 521 of file Parse.java.

                                                                                                             {
     // Capture state so we can unwind after parsing delayed execution
     NewObjNode stk = scope().stk(); // Display
     Node old_ctrl = ctrl().keep(2);
     Node old_mem  = mem ().keep(2);
     op.keep(2);
     TypeStruct old_ts = stk._ts;
     Ary<Node> old_defs = stk._defs.deepCopy();
     lhs.keep(2);
  
     // Insert a thunk header to capture the delayed execution
     ThunkNode thunk = (ThunkNode)gvn(new ThunkNode(mem()));
     set_ctrl(thunk);
     set_mem (gvn(new ParmNode(MEM_IDX,"mem",thunk.keep(2),TypeMem.MEM,Env.DEFMEM,null)));
  
     // Delayed execution parse of RHS
     Node rhs = _expr_higher_require(prec,bintok,lhs);
  
     // Insert thunk tail, unwind memory state
     ThretNode thet = gvn(new ThretNode(ctrl(),mem(),rhs,Env.GVN.add_flow(thunk.unkeep(2)))).keep(2);
     set_ctrl(old_ctrl.unkeep(2));
     set_mem (old_mem .unkeep(2));
     for( int i=0; i<old_defs._len; i++ )
       assert old_defs.at(i)==stk._defs.at(i); // Nothing peeked thru the Thunk & updated outside
  
     // Emit the call to both terms.  Both the emitted call and the thunk MUST
     // inline right now.
     lhs = do_call(errMsgs(opx,lhsx,rhsx), args(op.unkeep(2),lhs.unkeep(2),thet.unkeep(2)));
     assert thunk.is_dead() && thet.is_dead(); // Thunk, in fact, inlined
  
     // Extra variables in the thunk not available after the thunk.
     // Set them to Err.
     if( stk._ts != old_ts ) {
       lhs.keep(2);
       for( int i=old_defs._len; i<stk._defs._len; i++ ) {
         String fname = stk._ts.fld(i-1)._fld;
         String msg = "'"+fname+"' not defined prior to the short-circuit";
         Parse bad = errMsg(rhsx);
         Node err = gvn(new ErrNode(ctrl(),bad,msg));
         set_mem(gvn(new StoreNode(mem(),scope().ptr(),err,Access.Final,fname,bad)));
       }
       lhs.unkeep(2);
     }
     return lhs;
   }

Referenced by com.cliffc.aa.Parse._expr().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ apply()

Node com.cliffc.aa.Parse.apply ( )

private

Parse a lisp-like function application.

To avoid the common bug of forgetting a ';', these must be on the same line. apply = expr apply = expr expr*

Definition at line 427 of file Parse.java.

                        {
     Node expr = expr();
     if( expr == null ) return null;
     while( true ) {
       skipWS();
       int oldx = _x;
       int old_last = _lastNWS;
       expr.keep(2);             // Keep alive across argument parse
       Node arg = expr();
       if( arg==null ) return expr.unkeep(2);
       // To avoid the common bug of forgetting a ';', these must be on the same line.
       int line_last = _lines.binary_search(old_last);
       int line_now  = _lines.binary_search(_x);
       if( line_last != line_now ) {
         _x = oldx;  _lastNWS = old_last;  expr.unhook();
         return err_ctrl2("Lisp-like function application split between lines "+line_last+" and "+line_now+", but must be on the same line; possible missing semicolon?");
       }
       expr = do_call(errMsgs(oldx,oldx),args(expr.unkeep(2),arg)); // Pass the 1 arg
     }
   }

References com.cliffc.aa.Parse._lastNWS, com.cliffc.aa.Parse._lines, com.cliffc.aa.Parse._x, com.cliffc.aa.Parse.args(), com.cliffc.aa.util.AryInt.binary_search(), com.cliffc.aa.Parse.do_call(), com.cliffc.aa.Parse.err_ctrl2(), com.cliffc.aa.Parse.errMsgs(), com.cliffc.aa.Parse.expr(), com.cliffc.aa.node.Node.keep(), com.cliffc.aa.Parse.skipWS(), com.cliffc.aa.node.Node.unhook(), and com.cliffc.aa.node.Node.unkeep().

Referenced by com.cliffc.aa.Parse.ifex().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ args() [1/3]

Node [] com.cliffc.aa.Parse.args	(	Node	a0,
		Node	a1
	)

private

Definition at line 1395 of file Parse.java.

1395 { return _args(new Node[]{null,null,a0,a1,a0}); }

References com.cliffc.aa.Parse._args().

Referenced by com.cliffc.aa.Parse._args(), com.cliffc.aa.Parse._expr(), com.cliffc.aa.Parse._short_circuit_expr(), com.cliffc.aa.Parse.apply(), com.cliffc.aa.Parse.bfact(), com.cliffc.aa.Parse.do_call(), com.cliffc.aa.Parse.do_call0(), com.cliffc.aa.Parse.inc(), com.cliffc.aa.Parse.term(), and com.cliffc.aa.Parse.tuple().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ args() [2/3]

Node [] com.cliffc.aa.Parse.args	(	Node	a0,
		Node	a1,
		Node	a2
	)

private

Definition at line 1396 of file Parse.java.

1396 { return _args(new Node[]{null,null,a0,a1,a2,a0}); }

References com.cliffc.aa.Parse._args().

Here is the call graph for this function:

◆ args() [3/3]

Node [] com.cliffc.aa.Parse.args	(	Node	a0,
		Node	a1,
		Node	a2,
		Node	a3
	)

private

Definition at line 1397 of file Parse.java.

1397 { return _args(new Node[]{null,null,a0,a1,a2,a3,a0}); }

References com.cliffc.aa.Parse._args().

Here is the call graph for this function:

◆ bal_open()

UnOrFunPtrNode com.cliffc.aa.Parse.bal_open ( )

package

Definition at line 1054 of file Parse.java.

                             {
     int oldx = _x;
     String bal = token();
     if( bal==null ) return null;
     // This is a primitive lookup and always returns a FRESH copy (see HM.Ident).
     UnOrFunPtrNode bfun = _e.lookup_filter_fresh(bal.intern(),0,ctrl()); // No nargs filtering
     if( bfun==null || bfun.op_prec() != 0 ) { _x=oldx; return null; }
     // Actual minimal length uniop might be smaller than the parsed token
     // (greedy algo vs not-greed)
     _x = oldx+bfun.funptr()._name.length();
     return bfun;
   }

References com.cliffc.aa.Parse._e, com.cliffc.aa.node.FunPtrNode._name, com.cliffc.aa.Parse._x, com.cliffc.aa.Parse.ctrl(), com.cliffc.aa.node.UnOrFunPtrNode.funptr(), com.cliffc.aa.Env.lookup_filter_fresh(), com.cliffc.aa.node.Node.op_prec(), and com.cliffc.aa.Parse.token().

Referenced by com.cliffc.aa.Parse.term().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ bfact()

Node com.cliffc.aa.Parse.bfact	(	int	oldx,
		UnOrFunPtrNode	bfun
	)

package

A balanced operator as a fact().

Any balancing token can be used. bterm = [ stmts ] // size constructor bterm = [ stmts, [stmts,]* ] // tuple constructor

Definition at line 1040 of file Parse.java.

                                             {
     skipWS();
     int oldx2 = _x;             // Start of stmts
     Node s = stmts();
     if( s==null ) { _x = oldx; return null; } // A bare "()" pair is not a statement
     if( peek(',') ) {
       _x --;                    // Reparse the ',' in tuple
       throw unimpl();
     }
     require(bfun.funptr().fun()._bal_close,oldx);
     return do_call(errMsgs(oldx,oldx2),args(bfun,s));
   }

References com.cliffc.aa.node.FunNode._bal_close, com.cliffc.aa.Parse._x, com.cliffc.aa.Parse.args(), com.cliffc.aa.Parse.do_call(), com.cliffc.aa.Parse.errMsgs(), com.cliffc.aa.node.FunPtrNode.fun(), com.cliffc.aa.node.UnOrFunPtrNode.funptr(), com.cliffc.aa.Parse.peek(), com.cliffc.aa.Parse.require(), com.cliffc.aa.Parse.skipWS(), and com.cliffc.aa.Parse.stmts().

Referenced by com.cliffc.aa.Parse.fact().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ compareTo()

int com.cliffc.aa.Parse.compareTo ( Parse loc )

Definition at line 1500 of file Parse.java.

                                             {
     int x = _src.compareTo(loc._src);
     if( x!=0 ) return x;
     return _x - loc._x;
   }

References com.cliffc.aa.Parse._src, and com.cliffc.aa.Parse._x.

◆ con()

ConNode com.cliffc.aa.Parse.con ( Type t )

private

Definition at line 1369 of file Parse.java.

1369 { return (ConNode)Node.con(t); }

References com.cliffc.aa.node.Node.con().

Referenced by com.cliffc.aa.Parse.do_exit(), com.cliffc.aa.Parse.fact(), com.cliffc.aa.Parse.func(), com.cliffc.aa.Parse.inc(), and com.cliffc.aa.Parse.prog().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ create()

void com.cliffc.aa.Parse.create	(	String	tok,
		Node	n,
		Access	mutable
	)

private

Definition at line 1375 of file Parse.java.

1375 { scope().stk().create(tok,n,mutable); }

References com.cliffc.aa.node.NewObjNode.create(), com.cliffc.aa.Parse.scope(), and com.cliffc.aa.node.ScopeNode.stk().

Referenced by com.cliffc.aa.Parse.func(), com.cliffc.aa.Parse.inc(), and com.cliffc.aa.Parse.stmt().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ctrl()

Node com.cliffc.aa.Parse.ctrl ( )

Definition at line 1363 of file Parse.java.

1363 { return scope().ctrl(); }

References com.cliffc.aa.node.ScopeNode.ctrl(), and com.cliffc.aa.Parse.scope().

Referenced by com.cliffc.aa.Parse._args(), com.cliffc.aa.Parse._expr(), com.cliffc.aa.Parse._short_circuit_expr(), com.cliffc.aa.Parse.bal_open(), com.cliffc.aa.Parse.do_call0(), com.cliffc.aa.Parse.do_exit(), com.cliffc.aa.Parse.err_ctrl2(), com.cliffc.aa.Parse.err_ctrl3(), com.cliffc.aa.Parse.fact(), com.cliffc.aa.Parse.func(), com.cliffc.aa.Parse.ifex(), com.cliffc.aa.Parse.inc(), com.cliffc.aa.Parse.merge_exits(), com.cliffc.aa.Parse.struct(), and com.cliffc.aa.Parse.term().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ do_call()

Node com.cliffc.aa.Parse.do_call	(	Parse[]	bads,
		Node...	args
	)

private

Definition at line 1414 of file Parse.java.

1414 { return do_call0(true,bads,args); }

References com.cliffc.aa.Parse.args(), and com.cliffc.aa.Parse.do_call0().

Referenced by com.cliffc.aa.Parse._expr(), com.cliffc.aa.Parse._short_circuit_expr(), com.cliffc.aa.Parse.apply(), com.cliffc.aa.Parse.bfact(), com.cliffc.aa.Parse.inc(), and com.cliffc.aa.Parse.term().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ do_call0()

Node com.cliffc.aa.Parse.do_call0	(	boolean	unpack,
		Parse[]	bads,
		Node...	args
	)

private

Definition at line 1415 of file Parse.java.

                                                                       {
     CallNode call0 = new CallNode(unpack,bads,args);
     CallNode call = (CallNode)gvn(call0);
     // Call Epilog takes in the call which it uses to track wireable functions.
     // CallEpi internally tracks all wired functions.
  
     CallEpiNode cepi = (CallEpiNode)gvn(new CallEpiNode(call,Env.DEFMEM));
     Node ctrl = gvn(new CProjNode(cepi.keep()));
     if( ctrl.is_copy(0)!=null ) ctrl = ctrl.is_copy(0); // More aggressively fold, so Thunks can more aggressively assert
     set_ctrl(ctrl);
     set_mem(gvn(new MProjNode(cepi))); // Return memory from all called functions
     // As soon as CEPI is unkeep, a whole lotta things are allowed, including
     // e.g. inlining
     if( !cepi._is_copy ) {
       Env.GVN.add_work_all(cepi);
       for( int i = 0; i < cepi.nwired(); i++ )
         Env.GVN.add_inline(cepi.wired(i).fun());
     } else Env.GVN.add_flow(cepi);
     return gvn(new ProjNode(cepi.unkeep(),REZ_IDX));
   }

References com.cliffc.aa.node.CallEpiNode._is_copy, com.cliffc.aa.GVNGCM.add_flow(), com.cliffc.aa.GVNGCM.add_inline(), com.cliffc.aa.GVNGCM.add_work_all(), com.cliffc.aa.Parse.args(), com.cliffc.aa.Parse.ctrl(), com.cliffc.aa.Env.DEFMEM, com.cliffc.aa.node.RetNode.fun(), com.cliffc.aa.Env.GVN, com.cliffc.aa.Parse.gvn(), com.cliffc.aa.node.Node.is_copy(), com.cliffc.aa.node.Node.keep(), com.cliffc.aa.node.CallEpiNode.nwired(), com.cliffc.aa.Parse.set_ctrl(), com.cliffc.aa.Parse.set_mem(), com.cliffc.aa.node.Node.unkeep(), and com.cliffc.aa.node.CallEpiNode.wired().

Referenced by com.cliffc.aa.Parse.do_call(), and com.cliffc.aa.Parse.term().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ do_exit()

Node com.cliffc.aa.Parse.do_exit	(	ScopeNode	s,
		Node	rez
	)

package

Definition at line 1019 of file Parse.java.

                                         {
     Node ctrl = s.early_ctrl();
     Node mem  = s.early_mem ();
     Node val  = s.early_val ();
     if( ctrl == null ) {
       s.set_def(4,ctrl=new RegionNode((Node)null).keep()); ctrl._val=Type.CTRL;
       s.set_def(5,mem =new PhiNode(TypeMem.MEM, null,(Node)null).keep());
       s.set_def(6,val =new PhiNode(Type.SCALAR, null,(Node)null).keep());
     }
     ctrl.add_def(ctrl());
     mem .add_def(mem ());
     val .add_def(rez   );
     set_ctrl(Env.XCTRL);
     set_mem (con(TypeMem.XMEM));
     return Env.XNIL;
   }

References com.cliffc.aa.node.Node._val, com.cliffc.aa.node.Node.add_def(), com.cliffc.aa.Parse.con(), com.cliffc.aa.type.Type< T extends Type< T >.CTRL, com.cliffc.aa.Parse.ctrl(), com.cliffc.aa.node.ScopeNode.early_ctrl(), com.cliffc.aa.node.ScopeNode.early_mem(), com.cliffc.aa.node.ScopeNode.early_val(), com.cliffc.aa.node.Node.keep(), com.cliffc.aa.type.TypeMem.MEM, com.cliffc.aa.Parse.mem(), com.cliffc.aa.type.Type< T extends Type< T >.SCALAR, com.cliffc.aa.Parse.set_ctrl(), com.cliffc.aa.node.Node.set_def(), com.cliffc.aa.Parse.set_mem(), com.cliffc.aa.Env.XCTRL, com.cliffc.aa.type.TypeMem.XMEM, and com.cliffc.aa.Env.XNIL.

Referenced by com.cliffc.aa.Env.early_exit().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ dump()

String com.cliffc.aa.Parse.dump ( )

package

Definition at line 97 of file Parse.java.

97 { return scope().dump(99); }// debugging hook

References com.cliffc.aa.node.Node.dump(), and com.cliffc.aa.Parse.scope().

Here is the call graph for this function:

◆ dumprpo()

String com.cliffc.aa.Parse.dumprpo ( )

package

Definition at line 98 of file Parse.java.

98 { return Env.START.dumprpo(false,false); }// debugging hook

References com.cliffc.aa.node.Node.dumprpo(), and com.cliffc.aa.Env.START.

Here is the call graph for this function:

◆ equals()

boolean com.cliffc.aa.Parse.equals ( Object loc )

Definition at line 1491 of file Parse.java.

                                               {
     if( this==loc ) return true;
     if( !(loc instanceof Parse) ) return false;
     Parse p = (Parse)loc;
     return _x==p._x && _src.equals(p._src);
   }

References com.cliffc.aa.Parse._src, com.cliffc.aa.Parse._x, and com.cliffc.aa.Parse.Parse().

Referenced by com.cliffc.aa.node.Node.ErrMsg.equals().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ err_ctrl0()

void com.cliffc.aa.Parse.err_ctrl0 ( String s )

private

Definition at line 1439 of file Parse.java.

1439 { err_ctrl3(s,errMsg()); }

References com.cliffc.aa.Parse.err_ctrl3(), and com.cliffc.aa.Parse.errMsg().

Referenced by com.cliffc.aa.Parse.func(), and com.cliffc.aa.Parse.stmt().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ err_ctrl1()

ErrNode com.cliffc.aa.Parse.err_ctrl1 ( Node.ErrMsg msg )

private

Definition at line 1437 of file Parse.java.

1437 { return init(new ErrNode(Env.START,msg)); }

References com.cliffc.aa.Parse.init(), and com.cliffc.aa.Env.START.

Referenced by com.cliffc.aa.Parse.inc(), and com.cliffc.aa.Parse.stmt().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ err_ctrl2()

ErrNode com.cliffc.aa.Parse.err_ctrl2 ( String msg )

private

Definition at line 1438 of file Parse.java.

1438 { return init(new ErrNode(ctrl(),errMsg(),msg)).unkeep(); }

References com.cliffc.aa.Parse.ctrl(), com.cliffc.aa.Parse.errMsg(), and com.cliffc.aa.Parse.init().

Referenced by com.cliffc.aa.Parse._expr_higher_require(), com.cliffc.aa.Parse.apply(), com.cliffc.aa.Parse.fact(), com.cliffc.aa.Parse.func(), com.cliffc.aa.Parse.ifex(), com.cliffc.aa.Parse.inc(), com.cliffc.aa.Parse.stmt(), com.cliffc.aa.Parse.term(), and com.cliffc.aa.Parse.tstmt().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ err_ctrl3()

void com.cliffc.aa.Parse.err_ctrl3	(	String	s,
		Parse	open
	)

private

Definition at line 1440 of file Parse.java.

                                                {
     set_ctrl(gvn(new ErrNode(ctrl(),open,s)));
   }

References com.cliffc.aa.Parse.ctrl(), com.cliffc.aa.Parse.gvn(), and com.cliffc.aa.Parse.set_ctrl().

Referenced by com.cliffc.aa.Parse.err_ctrl0(), and com.cliffc.aa.Parse.require().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ errLocMsg()

String com.cliffc.aa.Parse.errLocMsg ( String s )

Definition at line 1466 of file Parse.java.

                                     {
     if( s.charAt(0)=='\n' ) return s;
     // find line start
     int a=_x;
     while( a > 0 && _buf[a-1] != '\n' ) --a;
     if( _buf[a]=='\r' ) a++; // do not include leading \n or \n\r
     // find line end
     int b=_x;
     while( b < _buf.length && _buf[b] != '\n' ) b++;
     if( b < _buf.length ) b--; // do not include trailing \n or \n\r
     // Find line number.  Bin-search returns the insertion-point, which is the NEXT
     // line unless _x is exactly a line start.
     int line = _lines.binary_search(_x); // Find zero-based line insertion point
     if( line == _lines._len ||  _lines.at(line)>_x ) line--;
     // error message using 1-based line
     SB sb = new SB().p(_src).p(':').p(line+1).p(':').p(s).nl();
     sb.p(new String(_buf,a,b-a)).nl();
     int line_start = a;
     for( int i=line_start; i<_x; i++ )
       sb.p(' ');
     return sb.p('^').nl().toString();
   }

References com.cliffc.aa.Parse._buf, com.cliffc.aa.util.AryInt._len, com.cliffc.aa.Parse._lines, com.cliffc.aa.Parse._src, com.cliffc.aa.Parse._x, com.cliffc.aa.util.AryInt.at(), com.cliffc.aa.util.AryInt.binary_search(), com.cliffc.aa.util.SB.nl(), com.cliffc.aa.util.SB.p(), and com.cliffc.aa.util.SB.toString().

Referenced by com.cliffc.aa.node.Node.ErrMsg.toString().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ errMsg() [1/2]

Parse com.cliffc.aa.Parse.errMsg ( )

package

Definition at line 1455 of file Parse.java.

1455 { return errMsg(_x); }

References com.cliffc.aa.Parse._x, and com.cliffc.aa.Parse.errMsg().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ errMsg() [2/2]

Parse com.cliffc.aa.Parse.errMsg ( int x )

package

Definition at line 1456 of file Parse.java.

1456 { Parse P = new Parse(this); P._x=x; return P; }

References com.cliffc.aa.Parse._x, and com.cliffc.aa.Parse.Parse().

Here is the call graph for this function:

◆ errMsgs()

Parse [] com.cliffc.aa.Parse.errMsgs ( int... xs )

package

Definition at line 1457 of file Parse.java.

                              {
     Parse[] Ps = new Parse[xs.length];
     for( int i=0; i<xs.length; i++ )
       Ps[i] = xs[i]==0 ? null : errMsg(xs[i]);
     return Ps;
   }

References com.cliffc.aa.Parse.errMsg().

Referenced by com.cliffc.aa.Parse._expr(), com.cliffc.aa.Parse._short_circuit_expr(), com.cliffc.aa.Parse.apply(), com.cliffc.aa.Parse.bfact(), com.cliffc.aa.Parse.inc(), and com.cliffc.aa.Parse.term().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ expr()

Node com.cliffc.aa.Parse.expr ( )

private

Parse an expression, a series of terms separated by binary operators.

Precedence is encoded in the PrimNode.PRECEDENCE table, and reflects here by the expr# recursive calls. expr = term [binop term]* Calls out for the precedence, starting high and working down low. expr = expr9 [binop9 expr9] expr9 = expr8 [binop8 expr8] ... expr2 = expr1 [binop2 expr1] expr1 = term [binop1 term ]

Definition at line 459 of file Parse.java.

                       {
     skipWS();         // Invariant: WS already skipped before & after each expr depth
     return _expr(1);
   }

References com.cliffc.aa.Parse._expr(), and com.cliffc.aa.Parse.skipWS().

Referenced by com.cliffc.aa.Parse.apply(), and com.cliffc.aa.Parse.ifex().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ fact()

Node com.cliffc.aa.Parse.fact ( )

private

Parse a factor, a leaf grammar token fact = num // number fact = "string" // string fact = (stmts) // General statements parsed recursively fact = (tuple,*) // tuple; first comma required, trailing comma not required fact = balop+ stmts balop- // Constructor with initial size Ex: [ 7 ] // Array constructor fact = balop+ stmts[, stmts]* balop- // Constructor with initial elements Ex: [ 1 , 2 ] // Array constructor with initial elements fact = {binop} // Special syntactic form of binop; no spaces allowed; returns function constant fact = {uniop} // Special syntactic form of uniop; no spaces allowed; returns function constant fact = {func} // Anonymous function declaration fact = id // variable lookup, NOT a binop or uniop but might be e.g.

function-valued, including un-/binops as values

Definition at line 772 of file Parse.java.

                       {
     if( skipWS() == -1 ) return null;
     byte c = _buf[_x];
     if( isDigit(c) ) return con(number());
     if( '"' == c ) {
       Node str = string();
       return str==null ? err_ctrl2("Unterminated string") : str;
     }
     int oldx = _x;
     if( peek1(c,'(') ) {        // a nested statement or a tuple
       int first_arg_start = _x;
       Node s = stmts();
       if( s==null ) { _x = oldx; return null; } // A bare "()" pair is not a statement
       if( peek(')') ) return s;                 // A (grouped) statement
       if( !peek(',') ) return s;                // Not a tuple, probably a syntax error
       _x --;                                    // Reparse the ',' in tuple
       return tuple(oldx,s,first_arg_start);     // Parse a tuple
     }
     // Anonymous function or operator
     if( peek1(c,'{') ) {
       String tok = token0();
       Node op = tok == null ? null : _e.lookup(tok.intern());
       if( peek('}') && op != null && op.op_prec() > 0 )
         // This is a primitive operator lookup as a function constant, and
         // makes a FRESH copy like HM.Ident.
         return gvn(new FreshNode(_e._nongen,ctrl(),op));
       _x = oldx+1;              // Back to the opening paren
       return func();            // Anonymous function
     }
     // Anonymous struct
     if( peek2(c,"@{") ) return struct();
  
     // Check for a valid 'id'
     String tok = token0();
     if( tok == null ) { _x = oldx; return null; }
     tok = tok.intern();
     if( Util.eq(tok,"=") || Util.eq(tok,"^") )
       { _x = oldx; return null; } // Disallow '=' as a fact, too easy to make mistakes
     ScopeNode scope = lookup_scope(tok,false);
     if( scope == null ) { // Assume any unknown id is a forward-ref of a recursive function
       // Ops cannot be forward-refs, so are just 'not a fact'.  Cannot declare
       // them as a undefined forward-ref right now, because the op might be the
       // tail-half of a balanced-op, which is parsed by term() above.
       if( isOp(tok) ) { _x = oldx; return null; }
       // Must be a forward reference
       Env fref_env = _e.lookup_fref(tok=tok.intern());
       if( fref_env==null ) fref_env = _e;
       Node fref = gvn(FunPtrNode.forward_ref(_gvn,tok,errMsg(oldx),fref_env));
       // Place in nearest enclosing closure scope, this will keep promoting until we find the actual scope
       fref_env._scope.stk().create(tok,fref,Access.Final);
       return fref;
     }
     Node def = scope.get(tok);    // Get top-level value; only sane if no stores allowed to modify it
     // Disallow uniop and binop functions as factors.  Only possible if trying
     // to use an operator as a factor, such as "plus = {+}" or "f(1,{+},2)".
     if( def.op_prec() > 0 ) { _x = oldx; return null; }
     // Balanced ops are similar to "{}", "()" or "@{}".
     if( def.op_prec()==0 && def._val instanceof TypeFunPtr )
       return bfact(oldx,(UnOrFunPtrNode)def);
  
     // Else must load against most recent display update.  Get the display to
     // load against.  If the scope is local, we load against it directly,
     // otherwise the display is passed in as a hidden argument.
     // This does a HM.Ident lookup, producing a FRESH tvar every time.
     Node ptr = get_display_ptr(scope);
     return gvn(new FreshNode(_e._nongen,ctrl(),gvn(new LoadNode(mem(),ptr,tok.intern(),null))));
   }

Referenced by com.cliffc.aa.Parse.tfact().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ field_number()

int com.cliffc.aa.Parse.field_number ( )

private

Definition at line 1107 of file Parse.java.

                              {
     byte c = _buf[_x];
     if( !isDigit(c) ) return -1;
     _x++;
     int sum = c-'0';
     while( _x < _buf.length && isDigit(c=_buf[_x]) ) {
       _x++;
       sum = sum*10+c-'0';
     }
     return sum;
   }

References com.cliffc.aa.Parse._buf, com.cliffc.aa.Parse._x, and com.cliffc.aa.Parse.isDigit().

Referenced by com.cliffc.aa.Parse.term().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ func()

Node com.cliffc.aa.Parse.func ( )

private

Definition at line 897 of file Parse.java.

                       {
     int oldx = _x;              // Past opening '{'
     Ary<String> ids = new Ary<>(new String[1],0);
     Ary<Type  > ts  = new Ary<>(new Type  [1],0);
     Ary<Parse > bads= new Ary<>(new Parse [1],0);
  
     // Push an extra hidden display argument.  Similar to java inner-class ptr
     // or when inside of a struct definition: 'this'.
     Node parent_display = scope().ptr();
     TypeMemPtr tpar_disp = (TypeMemPtr) parent_display._val; // Just a TMP of the right alias
     Node fresh_disp = gvn(new FreshNode(_e._nongen,ctrl(),parent_display)).keep();
  
     ids .push(" ctl");
     ts  .push(Type.CTRL);
     bads.push(null);
     ids .push(" mem");
     ts  .push(TypeMem.MEM);
     bads.push(null);
     ids .push("^");
     ts  .push(tpar_disp);
     bads.push(null);
  
     // Parse arguments
     while( true ) {
       String tok = token();
       if( tok == null ) { _x=oldx; break; } // not a "[id]* ->"
       if( Util.eq((tok=tok.intern()),"->") ) break; // End of argument list
       if( !isAlpha0((byte)tok.charAt(0)) ) { _x=oldx; break; } // not a "[id]* ->"
       Type t = Type.SCALAR;    // Untyped, most generic type
       Parse bad = errMsg();    // Capture location in case of type error
       if( peek(':') &&         // Has type annotation?
           (t=type())==null ) { // Get type
         // If no type, might be "{ x := ...}" or "{ fun arg := ...}" which can
         // be valid stmts, hence this may be a no-arg function.
         if( ids._len-1 <= 2 ) { _x=oldx; break; }
         else {
           // Might be: "{ x y z:bad -> body }" which cannot be any stmt.  This
           // is an error in any case.  Treat as a bad type on a valid function.
           err_ctrl0(peek(',') ? "Bad type arg, found a ',' did you mean to use a ';'?" : "Missing or bad type arg");
           t = Type.SCALAR;
           skipNonWS();         // Skip possible type sig, looking for next arg
         }
       }
       ids .add(tok);   // Accumulate args
       ts  .add(t  );
       bads.add(bad);
     }
     // If this is a no-arg function, we may have parsed 1 or 2 tokens as-if
     // args, and then reset.  Also reset to just the mem & display args.
     if( _x == oldx ) { ids.set_len(ARG_IDX); ts.set_len(ARG_IDX); bads.set_len(ARG_IDX);  }
  
     try( GVNGCM.Build<Node> X = _gvn.new Build<>()) { // Nest an environment for the local vars
       // Build the FunNode header
       FunNode fun = (FunNode)X.xform(new FunNode(ids.asAry(),ts.asAry()).add_def(Env.ALL_CTRL));
       // Record H-M VStack in case we clone
       fun.set_nongens(_e._nongen.compact());
       // Build Parms for system incoming values
       Node rpc = X.xform(new ParmNode(0      ,"rpc" ,fun,con(TypeRPC.ALL_CALL),null));
       Node mem = X.xform(new ParmNode(MEM_IDX," mem",fun,TypeMem.MEM,Env.DEFMEM,null));
       Node clo = X.xform(new ParmNode(DSP_IDX,"^"   ,fun,con(tpar_disp),null));
  
       // Increase scope depth for function body.
       try( Env e = new Env(_e,errMsg(oldx-1), true, fun, mem) ) { // Nest an environment for the local vars
         _e = e;                   // Push nested environment
         // Display is special: the default is simply the outer lexical scope.
         // But here, in a function, the display is actually passed in as a hidden
         // extra argument and replaces the default.
         NewObjNode stk = e._scope.stk();
         stk.update(0,Access.Final,clo);
         // Add a nongen memory arg
         _e._nongen.add_var(" mem",mem.tvar());
  
         // Parms for all arguments
         Parse errmsg = errMsg();  // Lazy error message
         for( int i=ARG_IDX; i<ids._len; i++ ) { // User parms start
           Node parm = X.xform(new ParmNode(i,ids.at(i),fun,con(Type.SCALAR),errmsg));
           _e._nongen.add_var(ids.at(i),parm.tvar());
           create(ids.at(i),parm, args_are_mutable);
         }
  
         // Parse function body
         Node rez = stmts();       // Parse function body
         if( rez == null ) rez = err_ctrl2("Missing function body");
         require('}',oldx-1);      // Matched with opening {}
  
         // Merge normal exit into all early-exit paths
         if( e._scope.is_closure() ) rez = merge_exits(rez);
         // Standard return; function control, memory, result, RPC.  Plus a hook
         // to the function for faster access.
         RetNode ret = (RetNode)X.xform(new RetNode(ctrl(),mem(),rez,rpc,fun));
         // The FunPtr builds a real display; any up-scope references are passed in now.
         Node fptr = X.xform(new FunPtrNode(null,ret,fresh_disp.unhook()));
  
         _e = _e._par;                // Pop nested environment; pops nongen also
         return (X._ret=fptr);        // Return function; close-out and DCE 'e'
       }
     }
   }

Referenced by com.cliffc.aa.Parse.fact().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ gather_errors()

TypeEnv com.cliffc.aa.Parse.gather_errors ( )

private

Definition at line 140 of file Parse.java.

                                   {
     // Hunt for typing errors in the alive code
     assert _e._par._par==null; // Top-level only
     HashSet<Node.ErrMsg> errs = new HashSet<>();
     VBitSet bs = new VBitSet();
     scope().walkerr_def(errs,bs);
     if( skipWS() != -1 ) errs.add(Node.ErrMsg.trailingjunk(this));
     ArrayList<Node.ErrMsg> errs0 = new ArrayList<>(errs);
     Collections.sort(errs0);
  
     Type res = scope().rez()._val; // New and improved result
     Type mem = scope().mem()._val;
     return new TypeEnv(res, mem instanceof TypeMem ? (TypeMem)mem : mem.oob(TypeMem.ALLMEM),_e,errs0.isEmpty() ? null : errs0);
   }

References com.cliffc.aa.Parse._e, com.cliffc.aa.Env._par, com.cliffc.aa.node.Node._val, com.cliffc.aa.type.TypeMem.ALLMEM, com.cliffc.aa.node.ScopeNode.mem(), com.cliffc.aa.Parse.mem(), com.cliffc.aa.node.ScopeNode.rez(), com.cliffc.aa.Parse.scope(), com.cliffc.aa.Parse.skipWS(), com.cliffc.aa.node.Node.ErrMsg.trailingjunk(), and com.cliffc.aa.node.Node.walkerr_def().

Referenced by com.cliffc.aa.Parse.go().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_display_ptr()

Node com.cliffc.aa.Parse.get_display_ptr ( ScopeNode scope )

private

Definition at line 1379 of file Parse.java.

                                                   {
     // Issue Loads against the Display, until we get the correct scope.  The
     // Display is a linked list of displays, and we already checked that token
     // exists at scope up in the display.
     Env e = _e;
     Node ptr = e._scope.ptr();
     Node mmem = mem();
     while( true ) {
       if( scope == e._scope ) return ptr;
       ptr = gvn(new LoadNode(mmem,ptr,"^",null)); // Gen linked-list walk code, walking display slot
       assert ptr.sharptr(mmem).is_display_ptr();
       e = e._par;                                 // Walk linked-list in parser also
     }
   }

References com.cliffc.aa.Parse._e, com.cliffc.aa.Env._par, com.cliffc.aa.Env._scope, com.cliffc.aa.Parse.gvn(), com.cliffc.aa.type.Type< T extends Type< T >.is_display_ptr(), com.cliffc.aa.Parse.mem(), com.cliffc.aa.node.ScopeNode.ptr(), com.cliffc.aa.Parse.scope(), and com.cliffc.aa.node.Node.sharptr().

Referenced by com.cliffc.aa.Parse.fact(), com.cliffc.aa.Parse.inc(), and com.cliffc.aa.Parse.stmt().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ go()

TypeEnv com.cliffc.aa.Parse.go ( )

package

Definition at line 104 of file Parse.java.

                 {
     prog();                     // Parse a program
     // Delete names at the top scope before starting optimization.
     _e._scope.keep();
     _e.close_display(_gvn);
     _gvn.iter(GVNGCM.Mode.PesiNoCG); // Pessimistic optimizations; might improve error situation
     remove_unknown_callers();
     _gvn.gcp (GVNGCM.Mode.Opto,scope()); // Global Constant Propagation
     _gvn.iter(GVNGCM.Mode.PesiCG); // Re-check all ideal calls now that types have been maximally lifted
     _gvn.gcp (GVNGCM.Mode.Opto,scope()); // Global Constant Propagation
     _gvn.iter(GVNGCM.Mode.PesiCG); // Re-check all ideal calls now that types have been maximally lifted
     _e._scope.unkeep();
     //assert Type.intern_check();
     return gather_errors();
   }

References com.cliffc.aa.Parse._e, com.cliffc.aa.Parse._gvn, com.cliffc.aa.Env._scope, com.cliffc.aa.Env.close_display(), com.cliffc.aa.Parse.gather_errors(), com.cliffc.aa.GVNGCM.gcp(), com.cliffc.aa.GVNGCM.iter(), com.cliffc.aa.node.Node.keep(), com.cliffc.aa.GVNGCM.Mode.Opto, com.cliffc.aa.GVNGCM.Mode.PesiCG, com.cliffc.aa.GVNGCM.Mode.PesiNoCG, com.cliffc.aa.Parse.prog(), com.cliffc.aa.Parse.remove_unknown_callers(), com.cliffc.aa.Parse.scope(), and com.cliffc.aa.node.Node.unkeep().

Here is the call graph for this function:

◆ gvn()

Node com.cliffc.aa.Parse.gvn ( Node n )

Definition at line 1358 of file Parse.java.

1358 { return n==null ? null : _gvn.xform(n); }

References com.cliffc.aa.Parse._gvn, and com.cliffc.aa.GVNGCM.xform().

Referenced by com.cliffc.aa.Parse._args(), com.cliffc.aa.Parse._short_circuit_expr(), com.cliffc.aa.Parse.do_call0(), com.cliffc.aa.Parse.err_ctrl3(), com.cliffc.aa.Parse.fact(), com.cliffc.aa.Parse.func(), com.cliffc.aa.Parse.get_display_ptr(), com.cliffc.aa.Parse.ifex(), com.cliffc.aa.Parse.inc(), com.cliffc.aa.Parse.string(), com.cliffc.aa.Parse.term(), com.cliffc.aa.Parse.tstmt(), com.cliffc.aa.Parse.tuple(), com.cliffc.aa.Parse.type0(), and com.cliffc.aa.Parse.typechk().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ hashCode()

int com.cliffc.aa.Parse.hashCode ( )

Definition at line 1497 of file Parse.java.

                                   {
     return _src.hashCode()+_x;
   }

References com.cliffc.aa.Parse._src, and com.cliffc.aa.Parse._x.

Referenced by com.cliffc.aa.node.UnresolvedNode.hashCode(), and com.cliffc.aa.node.Node.ErrMsg.hashCode().

Here is the caller graph for this function:

◆ ifex()

Node com.cliffc.aa.Parse.ifex ( )

private

Parse an if-expression, with lazy eval on the branches.

Assignments to new variables are allowed in either arm (as-if each arm is in a mini scope), and variables assigned on all live arms are available afterwards. ifex = expr [? stmt [: stmt]]

Definition at line 380 of file Parse.java.

                       {
     Node expr = apply();
     if( expr == null ) return null; // Expr is required, so missing expr implies not any ifex
     if( !peek('?') ) return expr;   // No if-expression
  
     scope().push_if();            // Start if-expression tracking new defs
     Node ifex = init(new IfNode(ctrl(),expr));
     set_ctrl(gvn(new CProjNode(ifex,1))); // Control for true branch
     Node old_mem = mem().keep(2);         // Keep until parse false-side
     Node tex = stmt(false);               // Parse true expression
     if( tex == null ) tex = err_ctrl2("missing expr after '?'");
     tex.keep(2);                   // Keep until merge point
     Node t_ctrl= ctrl().keep(2);   // Keep until merge point
     Node t_mem = mem ().keep(2);   // Keep until merge point
  
     scope().flip_if();          // Flip side of tracking new defs
     Env.GVN.add_work_all(ifex.unkeep(2));
     set_ctrl(gvn(new CProjNode(ifex,0))); // Control for false branch
     Env.GVN.add_reduce(ifex);
     set_mem(old_mem.unkeep(2));    // Reset memory to before the IF
     Node fex = peek(':') ? stmt(false) : Env.XNIL;
     if( fex == null ) fex = err_ctrl2("missing expr after ':'");
     fex.keep(2);                   // Keep until merge point
     Node f_ctrl= ctrl().keep(2);   // Keep until merge point
     Node f_mem = mem ().keep(2);   // Keep until merge point
  
     Parse bad = errMsg();
     t_mem = scope().check_if(true ,bad,_gvn,t_ctrl,t_mem); // Insert errors if created only 1 side
     f_mem = scope().check_if(false,bad,_gvn,f_ctrl,f_mem); // Insert errors if created only 1 side
     scope().pop_if();         // Pop the if-scope
     RegionNode r = set_ctrl(init(new RegionNode(null,t_ctrl.unkeep(2),f_ctrl.unkeep(2))));
     r._val = Type.CTRL;
     _gvn.add_reduce(t_ctrl);
     _gvn.add_reduce(f_ctrl);
     if( t_ctrl._val==Type.XCTRL ) _gvn.add_flow(t_mem);
     if( f_ctrl._val==Type.XCTRL ) _gvn.add_flow(f_mem);
     set_mem(   gvn(new PhiNode(TypeMem.FULL,bad,r        ,t_mem.unkeep(2),f_mem.unkeep(2))));
     Node rez = gvn(new PhiNode(Type.SCALAR ,bad,r.unkeep(2),tex.unkeep(2),  fex.unkeep(2))) ; // Ifex result
     _gvn.add_work_all(r);
     return rez;
   }

Referenced by com.cliffc.aa.Parse.stmt().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ inc()

Node com.cliffc.aa.Parse.inc	(	String	tok,
		int	d
	)

private

Definition at line 713 of file Parse.java.

                                       {
     skipWS();
     ScopeNode scope = lookup_scope(tok=tok.intern(),false); // Find prior scope of token
     // Need a load/call/store sensible options
     Node n;
     if( scope==null ) {         // Token not already bound to a value
       create(tok,Env.XNIL,Access.RW);
       scope = scope();
     } else {                    // Check existing token for mutable
       if( !scope.is_mutable(tok) )
         return err_ctrl2("Cannot re-assign final val '"+tok+"'");
     }
  
     // Scope is discovered by walking lexical display stack.
     // Pointer to the proper display is found via ptr-walking live display stack.
     // Now properly load from the display.
     // This does a HM.Ident lookup, producing a FRESH tvar every time.
     Node ptr = get_display_ptr(scope);
     n = gvn(new FreshNode(_e._nongen,ctrl(),gvn(new LoadNode(mem(),ptr,tok,null))));
     if( n.is_forward_ref() )    // Prior is actually a forward-ref
       return err_ctrl1(Node.ErrMsg.forward_ref(this,((FunPtrNode)n)));
     // Do a full lookup on "+", and execute the function
     n.keep();
     // This is a primitive lookup and always returns a FRESH copy (see HM.Ident).
     Node plus = _e.lookup_filter_fresh("+",2,ctrl());
     Node sum = do_call(errMsgs(0,_x,_x),args(plus,n,con(TypeInt.con(d))));
     // Active memory for the chosen scope, after the call to plus
     scope().replace_mem(new StoreNode(mem(),ptr,sum,Access.RW,tok,errMsg()));
     return n.unkeep();          // Return pre-increment value
   }

Referenced by com.cliffc.aa.Parse.term().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ init()

private<N extends Node> N com.cliffc.aa.Parse.init ( N n )

package

Definition at line 1359 of file Parse.java.

1359 { return n==null ? null : _gvn.init(n); }

References com.cliffc.aa.Parse._gvn, and com.cliffc.aa.GVNGCM.init().

Referenced by com.cliffc.aa.Parse.err_ctrl1(), com.cliffc.aa.Parse.err_ctrl2(), com.cliffc.aa.Parse.ifex(), and com.cliffc.aa.Parse.tuple().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ isAlpha0()

static boolean com.cliffc.aa.Parse.isAlpha0 ( byte c )

staticprivate

Definition at line 1351 of file Parse.java.

1351 { return ('a'<=c && c <= 'z') || ('A'<=c && c <= 'Z') || (c=='_'); }

Referenced by com.cliffc.aa.Parse.func(), com.cliffc.aa.Parse.isAlpha1(), and com.cliffc.aa.Parse.token0().

Here is the caller graph for this function:

◆ isAlpha1()

static boolean com.cliffc.aa.Parse.isAlpha1 ( byte c )

staticprivate

Definition at line 1352 of file Parse.java.

1352 { return isAlpha0(c) || ('0'<=c && c <= '9'); }

References com.cliffc.aa.Parse.isAlpha0().

Referenced by com.cliffc.aa.Parse.token0().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ isDigit()

static boolean com.cliffc.aa.Parse.isDigit ( byte c )

static

Definition at line 1355 of file Parse.java.

1355 { return '0' <= c && c <= '9'; }

Referenced by com.cliffc.aa.Parse.fact(), and com.cliffc.aa.Parse.field_number().

Here is the caller graph for this function:

◆ isOp()

static boolean com.cliffc.aa.Parse.isOp ( String s )

staticpackage

Definition at line 1089 of file Parse.java.

                                 {
     if( !isOp0((byte)s.charAt(0)) ) return false;
     for( int i=1; i<s.length(); i++ )
       if( !isOp1((byte)s.charAt(i)) ) return false;
     return true;
   }

References com.cliffc.aa.Parse.isOp0(), and com.cliffc.aa.Parse.isOp1().

Referenced by com.cliffc.aa.Parse.fact(), and com.cliffc.aa.Env.lookup_filter_fresh().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ isOp0()

static boolean com.cliffc.aa.Parse.isOp0 ( byte c )

staticprivate

Definition at line 1353 of file Parse.java.

1353 { return "!#$%*+,-.=<>^[]~/&|".indexOf(c) != -1; }

Referenced by com.cliffc.aa.Parse.isOp(), com.cliffc.aa.Parse.isOp1(), and com.cliffc.aa.Parse.token0().

Here is the caller graph for this function:

◆ isOp1()

static boolean com.cliffc.aa.Parse.isOp1 ( byte c )

staticprivate

Definition at line 1354 of file Parse.java.

1354 { return isOp0(c) || ":?".indexOf(c) != -1; }

References com.cliffc.aa.Parse.isOp0().

Referenced by com.cliffc.aa.Parse.isOp(), and com.cliffc.aa.Parse.token0().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ isWS()

static boolean com.cliffc.aa.Parse.isWS ( byte c )

staticprivate

Return true if c passes a test.

Definition at line 1350 of file Parse.java.

1350 { return c == ' ' || c == '\t' || c == '\n' || c == '\r'; }

Referenced by com.cliffc.aa.Parse.skipNonWS(), and com.cliffc.aa.Parse.skipWS().

Here is the caller graph for this function:

◆ kill()

void com.cliffc.aa.Parse.kill ( Node n )

private

Definition at line 1360 of file Parse.java.

                               {
     if( n._uses._len==0 ) n.kill();
   }

References com.cliffc.aa.node.Node._uses, and com.cliffc.aa.node.Node.kill().

Referenced by com.cliffc.aa.Parse.stmts(), and com.cliffc.aa.Parse.term().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ lookup()

Node com.cliffc.aa.Parse.lookup ( String tok )

Definition at line 1372 of file Parse.java.

1372 { return _e.lookup(tok); }

References com.cliffc.aa.Parse._e, and com.cliffc.aa.Env.lookup().

Referenced by com.cliffc.aa.Parse.tstmt(), and com.cliffc.aa.Parse.type0().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ lookup_scope()

ScopeNode com.cliffc.aa.Parse.lookup_scope	(	String	tok,
		boolean	lookup_current_scope_only
	)

private

Definition at line 1373 of file Parse.java.

1373 { return _e.lookup_scope(tok,lookup_current_scope_only); }

References com.cliffc.aa.Parse._e, and com.cliffc.aa.Env.lookup_scope().

Referenced by com.cliffc.aa.Parse.fact(), com.cliffc.aa.Parse.inc(), and com.cliffc.aa.Parse.stmt().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mem()

Node com.cliffc.aa.Parse.mem ( )

private

Definition at line 1366 of file Parse.java.

1366 { return scope().mem(); }

References com.cliffc.aa.node.ScopeNode.mem(), and com.cliffc.aa.Parse.scope().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ merge_exits()

Node com.cliffc.aa.Parse.merge_exits ( Node rez )

private

Definition at line 996 of file Parse.java.

                                      {
     rez.keep();
     ScopeNode s = scope();
     Node ctrl = s.early_ctrl();
     Node mem  = s.early_mem ();
     Node val  = s.early_val ();
     s.early_kill();
     if( ctrl == null ) return rez.unkeep(); // No other exits to merge into
     try(GVNGCM.Build<Node> X = _gvn.new Build<>()) {
       ctrl = ctrl.add_def(ctrl()).unkeep();
       ctrl._val = Type.CTRL;
       set_ctrl(ctrl=X.init(ctrl));
       mem.unkeep().set_def(0,ctrl);
       val.unkeep().set_def(0,ctrl);
       Node mem2 = X.xform(mem.add_def(mem()));
       Node val2 = X.xform(val.add_def(rez.unkeep()));
       set_mem(mem2);
       return (X._ret=val2);
     }
   }

Referenced by com.cliffc.aa.Parse.func().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ number()

Type com.cliffc.aa.Parse.number ( )

private

Definition at line 1098 of file Parse.java.

                         {
     _pp.setIndex(_x);
     Number n = _nf.parse(_str,_pp);
     _x = _pp.getIndex();
     if( n instanceof Long   ) return n.longValue()==0 ? Type.XNIL : TypeInt.con(n.  longValue());
     if( n instanceof Double ) return TypeFlt.con(n.doubleValue());
     throw new RuntimeException(n.getClass().toString()); // Should not happen
   }

References com.cliffc.aa.Parse._nf, com.cliffc.aa.Parse._pp, com.cliffc.aa.Parse._str, com.cliffc.aa.Parse._x, com.cliffc.aa.type.TypeFlt.con(), com.cliffc.aa.type.TypeInt.con(), and com.cliffc.aa.type.Type< T extends Type< T >.XNIL.

Referenced by com.cliffc.aa.Parse.fact().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ peek() [1/3]

boolean com.cliffc.aa.Parse.peek ( char c )

private

Definition at line 1282 of file Parse.java.

1282 { return peek1(skipWS(),c); }

References com.cliffc.aa.Parse.peek1(), and com.cliffc.aa.Parse.skipWS().

Referenced by com.cliffc.aa.Parse._expr(), com.cliffc.aa.Parse.bfact(), com.cliffc.aa.Parse.fact(), com.cliffc.aa.Parse.func(), com.cliffc.aa.Parse.ifex(), com.cliffc.aa.Parse.peek(), com.cliffc.aa.Parse.require(), com.cliffc.aa.Parse.stmt(), com.cliffc.aa.Parse.stmts(), com.cliffc.aa.Parse.term(), com.cliffc.aa.Parse.tfact(), com.cliffc.aa.Parse.tmod(), com.cliffc.aa.Parse.tstmt(), com.cliffc.aa.Parse.tuple(), and com.cliffc.aa.Parse.type0().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ peek() [2/3]

boolean com.cliffc.aa.Parse.peek ( String s )

private

Definition at line 1300 of file Parse.java.

                                    {
     if( !peek(s.charAt(0)) ) return false;
     if( !peek_noWS(s.charAt(1)) ) {  _x--; return false; }
     return true;
   }

References com.cliffc.aa.Parse._x, com.cliffc.aa.Parse.peek(), and com.cliffc.aa.Parse.peek_noWS().

Here is the call graph for this function:

◆ peek() [3/3]

String com.cliffc.aa.Parse.peek ( String[] toks )

private

Definition at line 1313 of file Parse.java.

                                      {
     for( String tok : toks ) if( peek1(tok) ) return tok;
     return null;
   }

References com.cliffc.aa.Parse.peek1().

Here is the call graph for this function:

◆ peek1() [1/2]

boolean com.cliffc.aa.Parse.peek1	(	byte	c0,
		char	c
	)

private

Definition at line 1286 of file Parse.java.

                                            {
     assert c0==-1 || c0== _buf[_x];
     if( c0!=c ) return false;
     _x++;                       // Skip peeked character
     return true;
   }

References com.cliffc.aa.Parse._buf, and com.cliffc.aa.Parse._x.

Referenced by com.cliffc.aa.Parse.fact(), com.cliffc.aa.Parse.peek(), and com.cliffc.aa.Parse.peek_noWS().

Here is the caller graph for this function:

◆ peek1() [2/2]

boolean com.cliffc.aa.Parse.peek1 ( String tok )

private

Definition at line 1317 of file Parse.java.

                                     {
     for( int i=0; i<tok.length(); i++ )
       if( _x+i >= _buf.length || _buf[_x+i] != tok.charAt(i) )
         return false;
     return true;
   }

References com.cliffc.aa.Parse._buf, and com.cliffc.aa.Parse._x.

◆ peek2()

boolean com.cliffc.aa.Parse.peek2	(	byte	c0,
		String	s2
	)

private

Definition at line 1294 of file Parse.java.

                                               {
     if( c0 != s2.charAt(0) ) return false;
     if( _x+1 >= _buf.length || _buf[_x+1] != s2.charAt(1) ) return false;
     _x+=2;                      // Skip peeked characters
     return true;
   }

References com.cliffc.aa.Parse._buf, and com.cliffc.aa.Parse._x.

Referenced by com.cliffc.aa.Parse.fact().

Here is the caller graph for this function:

◆ peek_not()

boolean com.cliffc.aa.Parse.peek_not	(	char	c,
		char	no
	)

private

Definition at line 1306 of file Parse.java.

                                               {
     byte c0 = skipWS();
     if( c0 != c || (_x+1 < _buf.length && _buf[_x+1] == no) ) return false;
     _x++;
     return true;
   }

References com.cliffc.aa.Parse._buf, com.cliffc.aa.Parse._x, and com.cliffc.aa.Parse.skipWS().

Referenced by com.cliffc.aa.Parse.stmt(), com.cliffc.aa.Parse.term(), and com.cliffc.aa.Parse.tmod().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ peek_noWS()

boolean com.cliffc.aa.Parse.peek_noWS ( char c )

private

Definition at line 1283 of file Parse.java.

1283 { return peek1(_x >= _buf.length ? -1 : _buf[_x],c); }

References com.cliffc.aa.Parse._buf, com.cliffc.aa.Parse._x, and com.cliffc.aa.Parse.peek1().

Referenced by com.cliffc.aa.Parse.peek(), and com.cliffc.aa.Parse.typeq().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ prog()

void com.cliffc.aa.Parse.prog ( )

private

Parse a top-level: prog = stmts END.

Definition at line 157 of file Parse.java.

                       {
     _gvn._opt_mode = GVNGCM.Mode.Parse;
     Node res = stmts();
     if( res == null ) res = con(Type.ANY);
     scope().set_rez(res);  // Hook result
   }

References com.cliffc.aa.Parse._gvn, com.cliffc.aa.GVNGCM._opt_mode, com.cliffc.aa.type.Type< T extends Type< T >.ANY, com.cliffc.aa.Parse.con(), com.cliffc.aa.GVNGCM.Mode.Parse, com.cliffc.aa.Parse.scope(), com.cliffc.aa.node.ScopeNode.set_rez(), and com.cliffc.aa.Parse.stmts().

Referenced by com.cliffc.aa.Parse.go().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ remove_unknown_callers()

void com.cliffc.aa.Parse.remove_unknown_callers ( )

private

Definition at line 120 of file Parse.java.

                                         {
     Ary<Node> uses = Env.ALL_CTRL._uses;
     // For all unknown uses of functions, they will all be known after GCP.
     // Remove the hyper-conservative ALL_CTRL edge.  Note that I canNOT run the
     // pessimistic iter() at this point, as GCP needs to discover all the
     // actual call-graph edges and install them directly on the FunNodes.
     for( int i=0; i<uses._len; i++ ) {
       Node use = uses.at(i);
       if( !use.is_prim() ) {
         assert use instanceof FunNode;
         assert use.in(1)==Env.ALL_CTRL;
         use.set_def(1,Env.XCTRL);
         i--;
       }
     }
     // No longer force all memory alive
     Env.DEFMEM.unkeep();
     Env.DEFMEM.insert(Env.ANY);
   }

References com.cliffc.aa.util.Ary< E >._len, com.cliffc.aa.node.Node._uses, com.cliffc.aa.Env.ALL_CTRL, com.cliffc.aa.Env.ANY, com.cliffc.aa.util.Ary< E >.at(), com.cliffc.aa.Env.DEFMEM, com.cliffc.aa.node.Node.in(), com.cliffc.aa.node.Node.insert(), com.cliffc.aa.node.Node.is_prim(), com.cliffc.aa.node.Node.set_def(), com.cliffc.aa.node.Node.unkeep(), and com.cliffc.aa.Env.XCTRL.

Referenced by com.cliffc.aa.Parse.go().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ require() [1/2]

void com.cliffc.aa.Parse.require	(	char	c,
		int	oldx
	)

private

Definition at line 1270 of file Parse.java.

                                            {
     if( peek(c) ) return;
     Parse bad = errMsg();       // Generic error
     bad._x = oldx;              // Openning point
     err_ctrl3("Expected closing '"+c+"' but "+(_x>=_buf.length?"ran out of text":"found '"+(char)(_buf[_x])+"' instead"),bad);
   }

References com.cliffc.aa.Parse._buf, com.cliffc.aa.Parse._x, com.cliffc.aa.Parse.err_ctrl3(), com.cliffc.aa.Parse.errMsg(), and com.cliffc.aa.Parse.peek().

Referenced by com.cliffc.aa.Parse.bfact(), com.cliffc.aa.Parse.func(), com.cliffc.aa.Parse.require(), com.cliffc.aa.Parse.struct(), com.cliffc.aa.Parse.term(), and com.cliffc.aa.Parse.tuple().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ require() [2/2]

void com.cliffc.aa.Parse.require	(	String	s,
		int	oldx
	)

private

Definition at line 1276 of file Parse.java.

                                              {
     for( int i=0; i<s.length(); i++ )
       require(s.charAt(i),oldx);
   }

References com.cliffc.aa.Parse.require().

Here is the call graph for this function:

◆ scope()

ScopeNode com.cliffc.aa.Parse.scope ( )

Definition at line 1374 of file Parse.java.

1374 { return _e._scope; }

References com.cliffc.aa.Parse._e, and com.cliffc.aa.Env._scope.

Here is the caller graph for this function:

◆ set_ctrl()

private<N extends Node> N com.cliffc.aa.Parse.set_ctrl ( N n )

package

Definition at line 1365 of file Parse.java.

1365 { return scope().set_ctrl(n); }

References com.cliffc.aa.Parse.scope(), and com.cliffc.aa.node.ScopeNode.set_ctrl().

Referenced by com.cliffc.aa.Parse._short_circuit_expr(), com.cliffc.aa.Parse.do_call0(), com.cliffc.aa.Parse.do_exit(), com.cliffc.aa.Parse.err_ctrl3(), com.cliffc.aa.Parse.ifex(), and com.cliffc.aa.Parse.merge_exits().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_mem()

void com.cliffc.aa.Parse.set_mem ( Node n )

private

Definition at line 1367 of file Parse.java.

1367 { scope().set_mem(n); }

References com.cliffc.aa.Parse.scope(), and com.cliffc.aa.node.ScopeNode.set_mem().

Referenced by com.cliffc.aa.Parse._short_circuit_expr(), com.cliffc.aa.Parse.do_call0(), com.cliffc.aa.Parse.do_exit(), com.cliffc.aa.Parse.ifex(), com.cliffc.aa.Parse.merge_exits(), com.cliffc.aa.Parse.string(), and com.cliffc.aa.Parse.tuple().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ skipBlock()

void com.cliffc.aa.Parse.skipBlock ( )

private

Definition at line 1343 of file Parse.java.

1343 { throw unimpl(); }

Referenced by com.cliffc.aa.Parse.skipWS().

Here is the caller graph for this function:

◆ skipEOL()

void com.cliffc.aa.Parse.skipEOL ( )

private

Definition at line 1342 of file Parse.java.

1342 { while( _x < _buf.length && _buf[_x] != '\n' ) _x++; }

References com.cliffc.aa.Parse._buf, and com.cliffc.aa.Parse._x.

Referenced by com.cliffc.aa.Parse.skipWS().

Here is the caller graph for this function:

◆ skipNonWS()

void com.cliffc.aa.Parse.skipNonWS ( )

private

Definition at line 1345 of file Parse.java.

                            {
     while( _x < _buf.length && !isWS(_buf[_x]) ) _x++;
   }

References com.cliffc.aa.Parse._buf, com.cliffc.aa.Parse._x, and com.cliffc.aa.Parse.isWS().

Referenced by com.cliffc.aa.Parse.func().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ skipWS()

byte com.cliffc.aa.Parse.skipWS ( )

private

Advance parse pointer to the first non-whitespace character, and return that character, -1 otherwise.

Definition at line 1327 of file Parse.java.

                         {
     int oldx = _x;
     while( _x < _buf.length ) {
       byte c = _buf[_x];
       if( c=='/' && _x+1 < _buf.length && _buf[_x+1]=='/' ) { skipEOL()  ; continue; }
       if( c=='/' && _x+1 < _buf.length && _buf[_x+1]=='*' ) { skipBlock(); continue; }
       if( c=='\n' && _x+1 > _lines.last() ) _lines.push(_x+1);
       if( !isWS(c) ) {
         if( oldx-1 > _lastNWS && !isWS(_buf[oldx-1]) ) _lastNWS = oldx-1;
         return c;
       }
       _x++;
     }
     return -1;
   }

References com.cliffc.aa.Parse._buf, com.cliffc.aa.Parse._lastNWS, com.cliffc.aa.Parse._lines, com.cliffc.aa.Parse._x, com.cliffc.aa.Parse.isWS(), com.cliffc.aa.util.AryInt.last(), com.cliffc.aa.util.AryInt.push(), com.cliffc.aa.Parse.skipBlock(), and com.cliffc.aa.Parse.skipEOL().

Referenced by com.cliffc.aa.Parse._expr(), com.cliffc.aa.Parse.apply(), com.cliffc.aa.Parse.bfact(), com.cliffc.aa.Parse.expr(), com.cliffc.aa.Parse.fact(), com.cliffc.aa.Parse.gather_errors(), com.cliffc.aa.Parse.inc(), com.cliffc.aa.Parse.peek(), com.cliffc.aa.Parse.peek_not(), com.cliffc.aa.Parse.stmt(), com.cliffc.aa.Parse.term(), com.cliffc.aa.Parse.token(), com.cliffc.aa.Parse.tuple(), and com.cliffc.aa.Parse.type0().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ stmt()

Node com.cliffc.aa.Parse.stmt ( boolean lookup_current_scope_only )

private

A statement is a list of variables to final-assign or re-assign, and an ifex for the value.

The variables are available in all later statements. Final-assigned variables can never be assigned again. Forward references must be defined in the same scope (or higher) as the outermost pending def. This is the same as a lambda calc LetRec expression: "let id = def in ..."

stmt = [id[:type] [:]=]* ifex stmt = id // Implicit variable creation with nil stmt = ^ifex // Early function exit

Note the syntax difference between: stmt = id := val // re-assignment stmt = id = val // final assignment tstmt = id =:type // type variable decl, type assignment

The ':=' is the re-assignment token, no spaces allowed.

Definition at line 268 of file Parse.java.

                                                        {
     if( peek('^') ) {           // Early function exit
       Node ifex = ifex();
       if( ifex==null ) ifex=Env.XNIL;
       if( _e._par._par==null )
         return err_ctrl1(Node.ErrMsg.syntax(this,"Function exit but outside any function"));
       return _e.early_exit(this,ifex);
     }
  
     // Gather ids in x = y = z = ....
     Ary<String> toks = new Ary<>(new String[1],0);
     Ary<Type  > ts   = new Ary<>(new Type  [1],0);
     Ary<Parse > badfs= new Ary<>(new Parse [1],0);
     Ary<Parse > badts= new Ary<>(new Parse [1],0);
     BitSet rs = new BitSet();
     boolean default_nil = false;
     _e.nongen_push(_e);
     while( true ) {
       skipWS();
       int oldx = _x;            // Unwind token parse point
       Parse badf = errMsg();    // Capture location in case of field error
       String tok = token();     // Scan for 'id = ...'
       if( tok == null ) break;  // Out of ids
       int oldx2 = _x;           // Unwind assignment flavor point
       Type t = null;
       // x  =: ... type  assignment, handled before we get here
       // x  =  ... final assignment
       // x :=  ... var   assignment
       // x : type  = ... typed final assignment
       // x : type := ... typed var   assignment
       // x : nontype = ... error, missing type
       // p? x : nontype ... part of trinary
       Parse badt = errMsg();    // Capture location in case of type error
       if( peek(":=") ) _x=oldx2; // Avoid confusion with typed assignment test
       else if( peek(':') && (t=type())==null ) { // Check for typed assignment
         if( scope().test_if() ) _x = oldx2; // Grammar ambiguity, resolve p?a:b from a:int
         else err_ctrl0("Missing type after ':'");
       }
       if( peek(":=") ) rs.set(toks._len);              // Re-assignment parse
       else if( !peek_not('=','=') ) {                  // Not any assignment
         // For structs, allow a bare id as a default def of nil
         if( lookup_current_scope_only && ts.isEmpty() && (peek(';') || peek('}') ||
         // These next two tokens are syntactically invalid, but a semi-common error situation:
         //   @{ fld;fld;fld;...  fld );  // Incorrect closing paren.  Go ahead and allow a bare id.
                                                           peek(']') || peek(')' ))) {
           _x--;                                        // Push back statement end
           default_nil=true;                            // Shortcut def of nil
           rs.set(toks._len);                           // Shortcut mutable
         } else {
           _x = oldx; // Unwind the token parse, and try an expression parse
           break;     // Done parsing assignment tokens
         }
       }
  
       toks .add(_e._nongen.add_var(tok.intern(),TV2.make_leaf_ns(null,"Env.add_var")));
       ts   .add(t  );
       badfs.add(badf);
       badts.add(badt);
     }
  
     // Normal statement value parse
     Node ifex = default_nil ? Env.XNIL : ifex(); // Parse an expression for the statement value
     // Check for no-statement after start of assignment, e.g. "x = ;"
     if( ifex == null ) {        // No statement?
       if( toks._len == 0 ) return _e.nongen_pop(null);
       ifex = err_ctrl2("Missing ifex after assignment of '"+toks.last()+"'");
     }
     // Honor all type requests, all at once, by inserting type checks on the ifex.
     for( int i=0; i<ts._len; i++ )
       ifex = typechk(ifex,ts.at(i),mem(),badts.at(i));
     ifex.keep();
  
     // Assign tokens to value
     for( int i=0; i<toks._len; i++ ) {
       String tok = toks.at(i);               // Token being assigned
       Access mutable = rs.get(i) ? Access.RW : Access.Final;  // Assignment is mutable or final
       // Find scope for token.  If not defining struct fields, look for any
       // prior def.  If defining a struct, tokens define a new field in this scope.
       ScopeNode scope = lookup_scope(tok,lookup_current_scope_only);
       if( scope==null ) {                    // Token not already bound at any scope
         if( ifex instanceof FunPtrNode && !ifex.is_forward_ref() )
           ((FunPtrNode)ifex).bind(tok); // Debug only: give name to function
         create(tok,Env.XNIL,Access.RW);  // Create at top of scope as undefined
         scope = scope();                // Scope is the current one
         scope.def_if(tok,mutable,true); // Record if inside arm of if (partial def error check)
       }
       // Handle re-assignments and forward referenced function definitions.
       Node n = scope.stk().get(tok); // Get prior direct binding
       if( n.is_forward_ref() ) {     // Prior is a f-ref
         assert !scope.stk().is_mutable(tok) && scope == scope();
         if( ifex instanceof FunPtrNode )
           ((FunPtrNode)n).merge_ref_def(tok,(FunPtrNode)ifex,scope.stk());
         else ; // Can be here if already in-error
  
       } else { // Store into scope/NewObjNode/display
  
         // Assign into display, changing an existing def
         Node ptr = get_display_ptr(scope); // Pointer, possibly loaded up the display-display
         StoreNode st = new StoreNode(mem(),ptr,ifex,mutable,tok,badfs.at(i));
         scope().replace_mem(st);
         scope.def_if(tok,mutable,false); // Note 1-side-of-if update
       }
     }
  
     return _e.nongen_pop(ifex.unkeep());
   }

Referenced by com.cliffc.aa.Parse.ifex(), com.cliffc.aa.Parse.stmts(), and com.cliffc.aa.Parse.term().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ stmts() [1/2]

Node com.cliffc.aa.Parse.stmts ( )

private

Parse a list of statements; final semi-colon is optional.

stmts= [tstmt or stmt] [; stmts]*[;]?

Definition at line 167 of file Parse.java.

167 { return stmts(false); }

References com.cliffc.aa.Parse.stmts().

Referenced by com.cliffc.aa.Parse.bfact(), com.cliffc.aa.Parse.fact(), com.cliffc.aa.Parse.func(), com.cliffc.aa.Parse.prog(), com.cliffc.aa.Parse.stmts(), com.cliffc.aa.Parse.struct(), com.cliffc.aa.Parse.term(), and com.cliffc.aa.Parse.tuple().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ stmts() [2/2]

Node com.cliffc.aa.Parse.stmts ( boolean lookup_current_scope_only )

private

Definition at line 168 of file Parse.java.

                                                         {
     Node stmt = tstmt(), last = null;
     if( stmt == null ) stmt = stmt(lookup_current_scope_only);
     while( stmt != null ) {
       if( !peek(';') ) return stmt;
       last = stmt.keep();
       stmt = tstmt();
       if( stmt == null ) stmt = stmt(lookup_current_scope_only);
       Env.GVN.add_flow(last.unkeep());
       if( stmt == null ) {
         if( peek(';') ) { _x--; stmt=last; }   // Ignore empty statement
       } else if( !last.is_dead() && stmt != last) kill(last); // prior expression result no longer alive in parser
     }
     return last;
   }

References com.cliffc.aa.Parse._x, com.cliffc.aa.GVNGCM.add_flow(), com.cliffc.aa.Env.GVN, com.cliffc.aa.node.Node.keep(), com.cliffc.aa.Parse.kill(), com.cliffc.aa.Parse.peek(), com.cliffc.aa.Parse.stmt(), and com.cliffc.aa.Parse.tstmt().

Here is the call graph for this function:

◆ string()

Node com.cliffc.aa.Parse.string ( )

private

Parse a String; _x is at '"'.

str = [.%]* // String contents; \t
\r% standard escapes str = %[num]?[.num]?fact // Percent escape embeds a 'fact' in a string; "name=%name\n"

Definition at line 1123 of file Parse.java.

                         {
     int oldx = ++_x;
     byte c;
     while( (c=_buf[_x++]) != '"' ) {
       if( c=='%' ) throw unimpl();
       if( c=='\\' ) throw unimpl();
       if( _x == _buf.length ) return null;
     }
     String str = new String(_buf,oldx,_x-oldx-1).intern();
     // Convert to ptr-to-constant-memory-string
     NewNode nnn = (NewNode)gvn( new NewStrNode.ConStr(str) );
     if( Env.DEFMEM._defs.atX(nnn._alias)==null )
       set_mem(Env.DEFMEM.make_mem_proj(nnn,mem()));
     return gvn( new ProjNode(nnn,REZ_IDX));
   }

References com.cliffc.aa.node.NewNode< T extends TypeObj< T >._alias, com.cliffc.aa.Parse._buf, com.cliffc.aa.node.Node._defs, com.cliffc.aa.Parse._x, com.cliffc.aa.Env.DEFMEM, com.cliffc.aa.Parse.gvn(), com.cliffc.aa.node.DefMemNode.make_mem_proj(), com.cliffc.aa.Parse.mem(), and com.cliffc.aa.Parse.set_mem().

Referenced by com.cliffc.aa.Parse.fact().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ struct()

Node com.cliffc.aa.Parse.struct ( )

private

Parse anonymous struct; the opening "@{" already parsed.

A lexical scope is made and new variables are defined here. Next comes statements, with each assigned value becoming a struct member, then the closing "}". struct = @{ stmts }

Definition at line 876 of file Parse.java.

                         {
     int oldx = _x-1; Node ptr;  // Opening @{
     try( Env e = new Env(_e,errMsg(oldx-1), false,ctrl(),mem()) ) { // Nest an environment for the local vars
       _e = e;                   // Push nested environment
       stmts(true);              // Create local vars-as-fields
       require('}',oldx);        // Matched closing }
       assert ctrl() != e._scope;
       ptr = e._scope.ptr().keep();    // A pointer to the constructed object
       e._par._scope.set_ctrl(ctrl()); // Carry any control changes back to outer scope
       e._par._scope.set_mem (mem ()); // Carry any memory  changes back to outer scope
       _e = e._par;                    // Pop nested environment
     } // Pop lexical scope around struct
     return ptr.unkeep();
   }

References com.cliffc.aa.Parse._e, com.cliffc.aa.Env._par, com.cliffc.aa.Parse._x, com.cliffc.aa.Parse.ctrl(), com.cliffc.aa.Parse.errMsg(), com.cliffc.aa.node.Node.keep(), com.cliffc.aa.Parse.mem(), com.cliffc.aa.Parse.require(), com.cliffc.aa.Parse.stmts(), and com.cliffc.aa.node.Node.unkeep().

Here is the call graph for this function:

◆ term()

Node com.cliffc.aa.Parse.term ( )

private

ary[idx] term = tfact bopen stmts bclose stmt // if bopen/bclose is arity-3 e.g. ary[idx]=val

Definition at line 575 of file Parse.java.

                       {
     int oldx = _x;
     String uni = token();
     if( uni!=null ) {
       // This is a primitive lookup and always returns a FRESH copy (see HM.Ident).
       UnOrFunPtrNode unifun = _e.lookup_filter_fresh(uni.intern(),1,ctrl()); // UniOp, or null
       FunPtrNode ptr = unifun==null ? null : unifun.funptr();
       if( ptr==null || ptr.fun()._op_prec <= 0 ) _x=oldx; // Not a uniop
       else {
         // Token might have been longer than the filtered name; happens if a
         // bunch of operator characters are adjacent but we can make an operator
         // out of the first few.
         _x = oldx+ptr.fun().fptr()._name.length();
         unifun.keep();
         Node term = term();
         if( term==null ) { unifun.unhook(); _x = oldx; return null; }
         unifun.unkeep();
         return do_call(errMsgs(0,oldx),args(unifun,term));
       }
     }
  
     // Check for id++ / id--
     String tok = token();
     if( tok != null ) {
       Node n;
       if( peek("++") && (n=inc(tok, 1))!=null ) return n;
       if( peek("--") && (n=inc(tok,-1))!=null ) return n;
     }
     _x = oldx;
  
     // Normal term expansion
     Node n = tfact();
     if( n == null ) return null;
     while( true ) {             // Repeated application or field lookup is fine
       if( peek('.') ) {         // Field?
         skipWS();               //
         int fld_start=_x;       // Get field start
         String fld = token0();  // Field name
         if( fld == null ) {     // Not a token, check for a field number
           int fldnum = field_number();
           if( fldnum == -1 ) return err_ctrl2("Missing field name after '.'");
           fld = ""+fldnum;      // Convert to a field name
         }
         fld=fld.intern();
  
         Node castnn = gvn(new CastNode(ctrl(),n,TypeMemPtr.ISUSED)); // Remove nil choice
  
         // Store or load against memory
         if( peek(":=") || peek_not('=','=')) {
           Access fin = _buf[_x-2]==':' ? Access.RW : Access.Final;
           Node stmt = stmt(false);
           if( stmt == null ) n = err_ctrl2("Missing stmt after assigning field '."+fld+"'");
           else scope().replace_mem( new StoreNode(mem(),castnn,n=stmt.keep(),fin,fld ,errMsg(fld_start)));
           skipWS();
           return n.unkeep();
         } else {
           n = gvn(new LoadNode(mem(),castnn,fld,errMsg(fld_start)));
         }
  
       } else if( peek('(') ) {  // Attempt a function-call
         oldx = _x;              // Just past paren
         skipWS();               // Skip to start of 1st arg
         n.keep();               // Keep alive across arg parse
         int first_arg_start = _x;
         Node arg = tuple(oldx-1,stmts(),first_arg_start); // Parse argument list
         if( arg == null )       // tfact but no arg is just the tfact
           { _x = oldx; return n.unkeep(); }
         Type tn = n._val;
         boolean may_fun = tn.isa(TypeFunPtr.GENERIC_FUNPTR);
         if( !may_fun && arg.op_prec() >= 0 ) { _x=oldx; return n.unkeep(); }
         if( !may_fun &&
             // Notice the backwards condition: n was already tested for !(tn instanceof TypeFun).
             // Now we test the other way: the generic function can never be an 'n'.
             // Only if we cannot 'isa' in either direction do we bail out early
             // here.  Otherwise, e.g. 'n' might be an unknown function argument
             // and during GCP be 'lifted' to a function; if we bail out now we
             // may disallow a legal program with function arguments.  However,
             // if 'n' is a e.g. Float there's no way it can 'lift' to a function.
             !TypeFunPtr.GENERIC_FUNPTR.isa(tn) ) {
           kill(arg);
           n.unhook();
           n = err_ctrl2("A function is being called, but "+tn+" is not a function");
         } else {
           Parse[] badargs = ((NewObjNode)arg.in(0))._fld_starts; // Args from tuple
           badargs[0] = errMsg(oldx-1); // Base call error reported at the opening paren
           n = do_call0(false,badargs,args(n.unkeep(),arg)); // Pass the tuple
         }
  
       } else {
         // Check for balanced op
         n.keep();
         UnOrFunPtrNode bfun = bal_open();   // Balanced op read
         if( bfun==null ) { n.unkeep(); break; } // Not a balanced op
  
         oldx = _x-1;            // Token start
         skipWS();
         bfun.keep();            // Keep alive across arg parse
         int oldx2 = _x;
         Node idx = stmts();     // Index expression
         tok = token();
         if( idx==null || tok==null ) { n.unhook(); bfun.unkeep(); return err_ctrl2("Missing stmts after '"+tok+"'"); }
         _x -= tok.length(); // Unwind, since token length depends on match
  
         // Need to find which balanced op close.  Find the longest matching name
         FunPtrNode fptr=null;
         UnresolvedNode unr = ((UnOrFunPtrNode)bfun.unkeep()).unk();
         if( unr!=null ) {       // Unresolved of balanced ops?
           for( Node def : unr._defs ) {
             FunPtrNode def0 = (FunPtrNode)def;
             if( tok.startsWith(def0.fun()._bal_close) &&
                 (fptr==null || fptr.fun()._bal_close.length() < def0.fun()._bal_close.length()) )
               fptr = def0;      // Found best match
           }
           Env.GVN.add_dead(Env.GVN.add_reduce(bfun)); // Dropping any new FreshNode, and replacing with this one
           idx.keep();
           bfun = (UnOrFunPtrNode)gvn(new FreshNode(_e._nongen,ctrl(),fptr));
         } else fptr = bfun.funptr(); // Just the one balanced op
         FunNode fun = fptr.fun();
         require(fun._bal_close,oldx);
         if( fun.nargs()==ARG_IDX+2 ) { // array, index
           n = do_call(errMsgs(0,oldx,oldx2),args(bfun,n.unkeep(),idx.unkeep()));
         } else {
           assert fun.nargs()==ARG_IDX+3; // array, index, value
           skipWS();
           int oldx3 = _x;
           bfun.keep();
           Node val = stmt(false);
           if( val==null ) { n.unhook(); return err_ctrl2("Missing stmt after '"+fun._bal_close+"'"); }
           n = do_call(errMsgs(0,oldx,oldx2,oldx3),args(bfun.unkeep(),n.unkeep(),idx.unkeep(),val));
         }
       }
     }
     return n;
   }

Referenced by com.cliffc.aa.Parse._expr_higher().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ tfact()

Node com.cliffc.aa.Parse.tfact ( )

private

Parse an optionally typed factor tfact = fact[:type].

Definition at line 747 of file Parse.java.

                        {
     Node fact = fact();
     if( fact==null ) return null;
     int oldx = _x;
     Parse bad = errMsg();
     if( !peek(':') ) { _x = oldx; return fact; }
     Type t = type();
     if( t==null ) { _x = oldx; return fact; } // No error for missing type, because can be ?: instead
     return typechk(fact,t,mem(),bad);
   }

References com.cliffc.aa.Parse._x, com.cliffc.aa.Parse.errMsg(), com.cliffc.aa.Parse.fact(), com.cliffc.aa.Parse.mem(), com.cliffc.aa.Parse.peek(), com.cliffc.aa.Parse.type(), and com.cliffc.aa.Parse.typechk().

Referenced by com.cliffc.aa.Parse.term().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ tmod()

Access com.cliffc.aa.Parse.tmod ( )

private

Definition at line 1176 of file Parse.java.

                         {
     if( peek_not('=','=') ) { _x--; return Access.Final   ; } // final     , leaving trailing '='
     if( peek(":="       ) ) { _x--; return Access.RW      ; } // read-write, leaving trailing '='
     if( peek("=="       ) ) { _x--; return Access.ReadOnly; } // read-only , leaving trailing '='
     // Default for unnamed field mod
     return Access.RW;
   }

References com.cliffc.aa.Parse._x, com.cliffc.aa.type.TypeFld.Access.Final, com.cliffc.aa.Parse.peek(), com.cliffc.aa.Parse.peek_not(), com.cliffc.aa.type.TypeFld.Access.ReadOnly, and com.cliffc.aa.type.TypeFld.Access.RW.

Referenced by com.cliffc.aa.Parse.type0().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ token()

String com.cliffc.aa.Parse.token ( )

private

Definition at line 1072 of file Parse.java.

1072 { skipWS(); return token0(); }

References com.cliffc.aa.Parse.skipWS(), and com.cliffc.aa.Parse.token0().

Referenced by com.cliffc.aa.Parse.bal_open(), com.cliffc.aa.Parse.func(), com.cliffc.aa.Parse.stmt(), com.cliffc.aa.Parse.term(), com.cliffc.aa.Parse.tstmt(), and com.cliffc.aa.Parse.type0().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ token0()

String com.cliffc.aa.Parse.token0 ( )

private

Definition at line 1077 of file Parse.java.

                           {
     if( _x >= _buf.length ) return null;
     byte c=_buf[_x];  int x = _x;
     if(   isAlpha0(c) ) while( _x < _buf.length && isAlpha1(_buf[_x]) ) _x++;
     else if( isOp0(c) ) while( _x < _buf.length && isOp1   (_buf[_x]) ) _x++;
     else return null; // Not a token; specifically excludes e.g. all bytes >= 128, or most bytes < 32
     if( (c==':' || c==',') && _x-x==1 ) // Disallow bare ':' as a token; ambiguous with ?: and type annotations; same for ','
       { _x=x; return null; } // Unwind, not a token
     if( c=='-' && _x-x>2 && _buf[x+1]=='>' ) // Disallow leading "->", confusing with function parameter list end; eg "not={x->!x}"
       _x=x+2;                                // Just return the "->"
     return new String(_buf,x,_x-x);
   }

References com.cliffc.aa.Parse._buf, com.cliffc.aa.Parse._x, com.cliffc.aa.Parse.isAlpha0(), com.cliffc.aa.Parse.isAlpha1(), com.cliffc.aa.Parse.isOp0(), and com.cliffc.aa.Parse.isOp1().

Referenced by com.cliffc.aa.Parse.fact(), com.cliffc.aa.Parse.term(), and com.cliffc.aa.Parse.token().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ toString()

String com.cliffc.aa.Parse.toString ( )

Definition at line 1490 of file Parse.java.

1490 { return new String(_buf,_x,_buf.length-_x); }

References com.cliffc.aa.Parse._buf, and com.cliffc.aa.Parse._x.

◆ tstmt()

Node com.cliffc.aa.Parse.tstmt ( )

private

A type-statement assigns a type to a type variable.

Type variable assignments are always final, and can not exist before assignment (hence a variable cannot have a normal value and be re-assigned as a type variable). In addition to allowing 'tvar' to appear in a type expression a pair of type constructor functions are made: one taking the base type and returning the same value as the named type, and the other for Structs taking the unpacked struct fields and returning the named type. The ':type' is the type being assigned; a space is allowed between '= :type'.

tstmt = tvar = :type

Definition at line 195 of file Parse.java.

                        {
     int oldx = _x;
     String tvar = token();      // Scan for tvar
     if( tvar == null || !peek('=') || !peek(':') ) { _x = oldx; return null; }
     tvar = tvar.intern();
     // Must be a type-variable assignment
     Type t = typev();
     if( t==null ) return err_ctrl2("Missing type after ':'");
     if( peek('?') ) return err_ctrl2("Named types are never nil");
     if( lookup(tvar) != null ) return err_ctrl2("Cannot re-assign val '"+tvar+"' as a type");
     Parse bad = errMsg();
     // Single-inheritance & vtables & RTTI:
     //            "Objects know thy Class"
     // Which means a TypeObj knows its Name.  It's baked into the vtable.
     // Which means TypeObj is named and not the pointer-to-TypeObj.
     // "Point= :@{x,y}" declares "Point" to be a type Name for "@{x,y}".
     Type named = t.set_name((tvar+":").intern()); // Add a name
     ConTypeNode tn = _e.lookup_type(tvar);
     if( tn == null ) {
       // If this is a primitive type, there is no recursion and
       // no special issues.  Make a constructor and be done.
       if( !(t instanceof TypeObj) ) {
         // Make a ConType with a named Type
         tn = (ConTypeNode)gvn(new ConTypeNode(tvar,named,scope()));
         _e.add_type(tvar,tn); // Add a type mapping
         PrimNode cvt = PrimNode.convertTypeName(t,named,bad);
         return _e.add_fun(bad,tvar,gvn(cvt.as_fun(_gvn)));
       }
  
       // Always wrap Objs with a TypeMemPtr and a unique alias.
       TypeMemPtr tmp = TypeMemPtr.make(BitsAlias.type_alias(BitsAlias.REC),(TypeObj)named);
       // Make a ConType with a named Type
       tn = (ConTypeNode)gvn(new ConTypeNode(tvar,tmp,scope()));
       _e.add_type(tvar,tn); // Add a type mapping
     }
  
     // A forward-ref ConTypeNode.  Close the cycle.
     tn.def_fref(named,_e);
  
     // Add a copy of constructor functions.
  
     // Build a constructor taking a pointer-to-TypeObj - and the associated
     // memory state, i.e.  takes a ptr-to-@{x,y} and returns a ptr to
     // Named:@{x,y}.  This stores a v-table ptr into an object.  The alias#
     // does not change, but a TypeMem[alias#] would now map to the Named
     // variant.
     TypeStruct ts = (TypeStruct)((TypeMemPtr)tn._val)._obj;
     FunPtrNode epi1 = IntrinsicNode.convertTypeName(ts,bad,_gvn);
     Node rez = _e.add_fun(bad,tvar,epi1); // Return type-name constructor
     // Add a second constructor taking an expanded arg list
     FunPtrNode epi2 = IntrinsicNode.convertTypeNameStruct(ts, tn.alias(), errMsg());
     _e.add_fun(bad,tvar,epi2); // type-name constructor with expanded arg list
  
     return rez;
   }

References com.cliffc.aa.Parse._e, com.cliffc.aa.Parse._gvn, com.cliffc.aa.node.Node._val, com.cliffc.aa.Parse._x, com.cliffc.aa.Env.add_fun(), com.cliffc.aa.Env.add_type(), com.cliffc.aa.node.ConTypeNode.alias(), com.cliffc.aa.node.PrimNode.as_fun(), com.cliffc.aa.node.IntrinsicNode.convertTypeName(), com.cliffc.aa.node.PrimNode.convertTypeName(), com.cliffc.aa.node.IntrinsicNode.convertTypeNameStruct(), com.cliffc.aa.node.ConTypeNode.def_fref(), com.cliffc.aa.Parse.err_ctrl2(), com.cliffc.aa.Parse.errMsg(), com.cliffc.aa.Parse.gvn(), com.cliffc.aa.Parse.lookup(), com.cliffc.aa.Env.lookup_type(), com.cliffc.aa.type.TypeMemPtr.make(), com.cliffc.aa.Parse.peek(), com.cliffc.aa.type.BitsAlias.REC, com.cliffc.aa.Parse.scope(), com.cliffc.aa.type.Type< T extends Type< T >.set_name(), com.cliffc.aa.Parse.token(), com.cliffc.aa.type.BitsAlias.type_alias(), and com.cliffc.aa.Parse.typev().

Referenced by com.cliffc.aa.Parse.stmts().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ tuple()

Node com.cliffc.aa.Parse.tuple	(	int	oldx,
		Node	s,
		int	first_arg_start
	)

private

Parse a tuple; first stmt but not the ',' parsed.

tuple= (stmts,[stmts,]) // Tuple; final comma is optional

Definition at line 843 of file Parse.java.

                                                             {
     Parse bad = errMsg(first_arg_start);
     Ary<Parse> bads = new Ary<>(new Parse[1],1);
     Ary<Node > args = new Ary<>(new Node [1],0);
     while( s!= null ) {         // More args
       bads.push(bad);           // Collect arg & arg start
       args.push(s.keep());
       if( !peek(',') ) break;   // Final comma is optional
       skipWS();                 // Skip to arg start before recording arg start
       bad = errMsg();           // Record arg start
       s=stmts();                // Parse arg
     }
     require(')',oldx);          // Balanced closing paren
  
     // Build the tuple from gathered args
     NewObjNode nn = new NewObjNode(false,TypeStruct.open(TypeMemPtr.NO_DISP),Env.ANY);
     for( int i=0; i<args._len; i++ )
       nn.create_active((""+i).intern(),args.at(i).unkeep(),Access.Final);
     nn._fld_starts = bads.asAry();
     nn.no_more_fields();
     init(nn);
     nn.xval();
  
     // NewNode returns a TypeMem and a TypeMemPtr (the reference).
     set_mem( Env.DEFMEM.make_mem_proj(nn,mem()) );
     return gvn(new ProjNode(nn.unkeep(2),REZ_IDX));
   }

References com.cliffc.aa.node.NewObjNode._fld_starts, com.cliffc.aa.Env.ANY, com.cliffc.aa.Parse.args(), com.cliffc.aa.util.Ary< E >.asAry(), com.cliffc.aa.node.NewObjNode.create_active(), com.cliffc.aa.Env.DEFMEM, com.cliffc.aa.Parse.errMsg(), com.cliffc.aa.type.TypeFld.Access.Final, com.cliffc.aa.Parse.gvn(), com.cliffc.aa.Parse.init(), com.cliffc.aa.node.Node.keep(), com.cliffc.aa.node.DefMemNode.make_mem_proj(), com.cliffc.aa.Parse.mem(), com.cliffc.aa.type.TypeMemPtr.NO_DISP, com.cliffc.aa.node.NewObjNode.no_more_fields(), com.cliffc.aa.type.TypeStruct.open(), com.cliffc.aa.Parse.peek(), com.cliffc.aa.util.Ary< E >.push(), com.cliffc.aa.Parse.require(), com.cliffc.aa.Parse.set_mem(), com.cliffc.aa.Parse.skipWS(), com.cliffc.aa.Parse.stmts(), and com.cliffc.aa.node.Node.unkeep().

Referenced by com.cliffc.aa.Parse.fact(), and com.cliffc.aa.Parse.term().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ type()

Type com.cliffc.aa.Parse.type ( )

private

Parse a type or return null type = tcon | tfun | tary | tstruct | ttuple | tvar // Type choices tcon = int, int[1,8,16,32,64], flt, flt[32,64], real, str[?] tary = '[' type? ']' // Cannot specify type for array size tfun = {[[type]* ->]? type } // Function types mirror func decls tmod = = | := | == // '=' is r/final, ':=' is r/w, '==' is read-only tstruct = [id [tmod [type?]];]*} // Struct types are field names with optional types.

Spaces not allowed ttuple = ([type?] [,[type?]]*) // List of types, trailing comma optional tvar = A previously declared type variable

Unknown tokens when type_var is false are treated as not-a-type. When true, unknown tokens are treated as a forward-ref new type.

Definition at line 1152 of file Parse.java.

1152 { return typep(false); }

References com.cliffc.aa.Parse.typep().

Referenced by com.cliffc.aa.Parse.func(), com.cliffc.aa.Parse.stmt(), and com.cliffc.aa.Parse.tfact().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ type0()

Type com.cliffc.aa.Parse.type0 ( boolean type_var )

private

Definition at line 1185 of file Parse.java.

                                        {
     if( peek('{') ) {           // Function type
       Ary<Type> ts = new Ary<>(new Type[]{Type.CTRL,TypeMem.ALLMEM,TypeMemPtr.DISP_SIMPLE});  Type t;
       while( (t=typep(type_var)) != null && t != Type.ANY  )
         ts.add(t);              // Collect arg types
       Type ret;
       if( t==Type.ANY ) {       // Found ->, expect return type
         ret = typep(type_var);
         if( ret == null ) return null; // should return TypeErr missing type after ->
       } else {                  // Allow no-args and simple return type
         if( ts._len != ARG_IDX+1 ) return null; // should return TypeErr missing -> in tfun
         ret = ts.pop();         // e.g. { int } Get single return type
       }
       TypeTuple targs = TypeTuple.make_args(ts.asAry());
       if( !peek('}') ) return null;
       return typeq(TypeFunSig.make(TypeTuple.make_ret(ret),targs));
     }
  
     if( peek("@{") ) {          // Struct type
       Ary<TypeFld> flds = new Ary<>(new TypeFld[]{TypeMemPtr.DISP_FLD});
       while( true ) {
         String tok = token();            // Scan for 'id'
         if( tok == null ) break;         // end-of-struct-def
         final String itok = tok.intern(); // Only 1 copy
         Type t = Type.SCALAR;            // Untyped, most generic field type
         Access tmodf = tmod();           // Field access mod; trailing '=' left for us
         if( peek('=') &&                 // Has type annotation?
             (t=typep(type_var)) == null) // Parse type, wrap ptrs
           t = Type.SCALAR;               // No type found, assume default
         if( flds.find(fld -> Util.eq(fld._fld,itok) ) != -1 ) throw unimpl(); // cannot use same field name twice
         flds.add(TypeFld.make(itok,t,tmodf,flds._len));
         if( !peek(';') ) break; // Final semi-colon is optional
       }
       return peek('}') ? TypeStruct.make("",false,flds.asAry(),true) : null;
     }
  
     // "()" is the zero-entry tuple
     // "(   ,)" is a 1-entry tuple
     // "(int )" is a 1-entry tuple (optional trailing comma)
     // "(int,)" is a 1-entry tuple (optional trailing comma)
     // "(,int)" is a 2-entry tuple
     // "(, , )" is a 2-entry tuple
     if( peek('(') ) { // Tuple type
       Ary<TypeFld> flds = new Ary<>(new TypeFld[]{TypeMemPtr.DISP_FLD});
       byte c;
       while( (c=skipWS()) != ')' ) { // No more types...
         Type t = Type.SCALAR;    // Untyped, most generic field type
         if( c!=',' &&            // Has type annotation?
             (t=typep(type_var)) == null) // Parse type, wrap ptrs
           return null;                   // not a type
         flds.add(TypeFld.make_tup(t,flds._len));
         if( !peek(',') ) break; // Final comma is optional
       }
       return peek(')') ? TypeStruct.make("",false,flds.asAry(),true) : null;
     }
  
     if( peek('[') ) {
       Type e = typep(type_var);
       if( e==null ) e=Type.SCALAR;
       return peek(']') ? TypeAry.make(TypeInt.INT64,e,TypeObj.OBJ) : null;
     }
  
     // Primitive type
     int oldx = _x;
     String tok = token();
     if( tok==null ) return null;
     tok = tok.intern();
     if( Util.eq(tok,"->") ) return Type.ANY; // Found -> return sentinel
     ConTypeNode t = _e.lookup_type(tok);
     if( t==null ) {              // Not a known type var
       if( lookup(tok) != null || // Yes a known normal var; resolve as a normal var
           !type_var ) {          // Or not inside a type-var assignment
         _x = oldx;               // Unwind if not a known type var
         return null;             // Not a type
       }
       // Make a forward-ref ConType and return its type
       int alias = BitsAlias.type_alias(BitsAlias.REC);
       TypeMemPtr tmp = TypeMemPtr.make(alias,(TypeObj)TypeObj.ISUSED.set_name((tok+":").intern()));
       _e.add_type(tok,(ConTypeNode)gvn(new ConTypeNode(tok,tmp,scope())));
       return tmp;
     }
     return t._val;
   }

Referenced by com.cliffc.aa.Parse.typep(), and com.cliffc.aa.Parse.typev().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ typechk()

Node com.cliffc.aa.Parse.typechk	(	Node	x,
		Type	t,
		Node	mem,
		Parse	bad
	)

private

Definition at line 1068 of file Parse.java.

                                                             {
     return t == null || x._val.isa(t) ? x : gvn(new AssertNode(mem,x,t,bad,_e));
   }

References com.cliffc.aa.Parse._e, com.cliffc.aa.node.Node._val, com.cliffc.aa.Parse.gvn(), com.cliffc.aa.type.Type< T extends Type< T >.isa(), and com.cliffc.aa.Parse.mem().

Referenced by com.cliffc.aa.Parse.stmt(), and com.cliffc.aa.Parse.tfact().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ typep()

Type com.cliffc.aa.Parse.typep ( boolean type_var )

private

Definition at line 1161 of file Parse.java.

                                        {
     Type t = type0(type_var);
     if( t instanceof TypeMemPtr ) return typeq(t); // Named type is already a TMP
     if( !(t instanceof TypeObj) ) return t; // Primitives are not wrapped
     // Automatically convert unnamed structs to refs.
     // Make a reasonably precise alias.
     int type_alias = t instanceof TypeStruct ? BitsAlias.REC : (t instanceof TypeStr ? BitsAlias.STR : BitsAlias.AARY);
     TypeMemPtr tmp = TypeMemPtr.make(type_alias,(TypeObj)t);
     return typeq(tmp);          // And check for null-ness
   }

References com.cliffc.aa.type.BitsAlias.AARY, com.cliffc.aa.type.TypeMemPtr.make(), com.cliffc.aa.type.BitsAlias.REC, com.cliffc.aa.type.BitsAlias.STR, com.cliffc.aa.Parse.type0(), and com.cliffc.aa.Parse.typeq().

Referenced by com.cliffc.aa.Parse.type(), and com.cliffc.aa.Parse.type0().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ typeq()

Type com.cliffc.aa.Parse.typeq ( Type t )

private

Definition at line 1172 of file Parse.java.

1172 { return peek_noWS('?') ? t.meet_nil(Type.XNIL) : t; }

References com.cliffc.aa.type.Type< T extends Type< T >.meet_nil(), com.cliffc.aa.Parse.peek_noWS(), and com.cliffc.aa.type.Type< T extends Type< T >.XNIL.

Referenced by com.cliffc.aa.Parse.type0(), and com.cliffc.aa.Parse.typep().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ typev()

Type com.cliffc.aa.Parse.typev ( )

private

Definition at line 1155 of file Parse.java.

                        {
     Type t = type0(true);
     // Type.ANY is a flag for '->' which is not a type.
     return t==Type.ANY ? null : t;
   }

References com.cliffc.aa.type.Type< T extends Type< T >.ANY, and com.cliffc.aa.Parse.type0().

Referenced by com.cliffc.aa.Parse.tstmt().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

◆ _buf

final byte [] com.cliffc.aa.Parse._buf

private

Definition at line 71 of file Parse.java.

◆ _e

◆ _gvn

final GVNGCM com.cliffc.aa.Parse._gvn

Definition at line 75 of file Parse.java.

Referenced by com.cliffc.aa.Parse.fact(), com.cliffc.aa.Parse.func(), com.cliffc.aa.Parse.go(), com.cliffc.aa.Parse.gvn(), com.cliffc.aa.Parse.ifex(), com.cliffc.aa.Parse.init(), com.cliffc.aa.Parse.merge_exits(), com.cliffc.aa.Parse.Parse(), com.cliffc.aa.Parse.prog(), and com.cliffc.aa.Parse.tstmt().

◆ _lastNWS

int com.cliffc.aa.Parse._lastNWS

private

Definition at line 73 of file Parse.java.

Referenced by com.cliffc.aa.Parse.apply(), com.cliffc.aa.Parse.Parse(), and com.cliffc.aa.Parse.skipWS().

◆ _lines

final AryInt com.cliffc.aa.Parse._lines

private

Definition at line 74 of file Parse.java.

Referenced by com.cliffc.aa.Parse.apply(), com.cliffc.aa.Parse.errLocMsg(), com.cliffc.aa.Parse.Parse(), and com.cliffc.aa.Parse.skipWS().

◆ _nf

final NumberFormat com.cliffc.aa.Parse._nf

private

Definition at line 78 of file Parse.java.

Referenced by com.cliffc.aa.Parse.number(), and com.cliffc.aa.Parse.Parse().

◆ _pp

final ParsePosition com.cliffc.aa.Parse._pp

private

Definition at line 79 of file Parse.java.

Referenced by com.cliffc.aa.Parse.number(), and com.cliffc.aa.Parse.Parse().

◆ _src

final String com.cliffc.aa.Parse._src

private

Definition at line 69 of file Parse.java.

Referenced by com.cliffc.aa.Parse.compareTo(), com.cliffc.aa.Parse.equals(), com.cliffc.aa.Parse.errLocMsg(), com.cliffc.aa.Parse.hashCode(), and com.cliffc.aa.Parse.Parse().

◆ _str

final String com.cliffc.aa.Parse._str

private

Definition at line 80 of file Parse.java.

Referenced by com.cliffc.aa.Parse.number(), and com.cliffc.aa.Parse.Parse().

◆ _x

int com.cliffc.aa.Parse._x

private

Definition at line 72 of file Parse.java.

◆ args_are_mutable

final Access com.cliffc.aa.Parse.args_are_mutable =Access.Final

staticprivate

Parse an anonymous function; the opening '{' already parsed.

After the '{' comes an optional list of arguments and a '->' token, and then any number of statements separated by ';'. func = { [[id]* ->]? stmts }

Definition at line 896 of file Parse.java.

Referenced by com.cliffc.aa.Parse.func().

The documentation for this class was generated from the following file:

Parse.java

Public Attributes

Package Functions

Static Package Functions

Private Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ Parse() [1/2]

◆ Parse() [2/2]

Member Function Documentation

◆ _args()

◆ _expr()

◆ _expr_higher()

◆ _expr_higher_require()

◆ _good_prec_tok()

◆ _short_circuit_expr()

◆ apply()

◆ args() [1/3]

◆ args() [2/3]

◆ args() [3/3]

◆ bal_open()

◆ bfact()

◆ compareTo()

◆ con()

◆ create()

◆ ctrl()

◆ do_call()

◆ do_call0()

◆ do_exit()

◆ dump()

◆ dumprpo()

◆ equals()

◆ err_ctrl0()

◆ err_ctrl1()

◆ err_ctrl2()

◆ err_ctrl3()

◆ errLocMsg()

◆ errMsg() [1/2]

◆ errMsg() [2/2]

◆ errMsgs()

◆ expr()

◆ fact()

◆ field_number()

◆ func()

◆ gather_errors()

◆ get_display_ptr()

◆ go()

◆ gvn()

◆ hashCode()

◆ ifex()

◆ inc()

◆ init()

◆ isAlpha0()

◆ isAlpha1()

◆ isDigit()

◆ isOp()

◆ isOp0()

◆ isOp1()

◆ isWS()

◆ kill()

◆ lookup()

◆ lookup_scope()

◆ mem()

◆ merge_exits()

◆ number()

◆ peek() [1/3]

◆ peek() [2/3]

◆ peek() [3/3]

◆ peek1() [1/2]

◆ peek1() [2/2]

◆ peek2()

◆ peek_not()

◆ peek_noWS()

◆ prog()

◆ remove_unknown_callers()

◆ require() [1/2]

◆ require() [2/2]

◆ scope()

◆ set_ctrl()