Collaboration diagram for com.cliffc.aa.HM.HM9:

[legend]

Classes
class	Apply

class	Con

class	Dec

class	EQ

class	EQ0

class	Factor

class	Field

class	Ident

class	If

class	IsEmpty

class	Lambda

class	Let

class	Mul

class	NotNil

class	Pair

class	Pair1

class	PrimSyn

class	Root

class	Str

class	Struct

class	Syntax

class	T2

class	Triple

class	VStack

class	Worklist

Public Member Functions
String	toString ()

Static Public Member Functions
static Root	hm (String sprog)

Static Package Functions
	[static initializer]

static Root	parse (String s)

static void	reset ()

static Syntax	term ()

Static Package Attributes
static final boolean	DEBUG_LEAKS =false

static final boolean	DO_GCP = true

static final boolean	DO_HM = true

static final HashMap< String, PrimSyn >	PRIMSYNS = new HashMap<>()

Static Private Member Functions
static String	id ()

static boolean	isAlpha0 (byte c)

static boolean	isAlpha1 (byte c)

static boolean	isDigit (byte c)

static boolean	isWS (byte c)

static Syntax	number ()

static void	require (char c)

static< T > T	require (char c, T t)

static void	require (String s)

static byte	skipWS ()

static Syntax	string ()

Static Private Attributes
static byte[]	BUF

static final SB	ID = new SB()

static int	X

Detailed Description

Definition at line 71 of file HM9.java.

Member Function Documentation

◆ [static initializer]()

com.cliffc.aa.HM.HM9.[static initializer]

staticpackage

◆ hm()

static Root com.cliffc.aa.HM.HM9.hm ( String sprog )

static

Definition at line 81 of file HM9.java.

                                         {
     Worklist work = new Worklist();
     PrimSyn.WORK=work;
  
     for( PrimSyn prim : new PrimSyn[]{new If(), new Pair1(), new Pair(), new EQ(), new EQ0(), new Mul(), new Dec(), new Str(), new Triple(), new Factor(), new IsEmpty(), new NotNil()} )
       PRIMSYNS.put(prim.name(),prim);
  
     // Parse
     Root prog = parse( sprog );
  
     // Prep for SSA: pre-gather all the (unique) ids
     int cnt_syns = prog.prep_tree(null,null,work);
     int init_T2s = T2.CNT;
  
     while( work.len()>0 ) {     // While work
       int oldcnt = T2.CNT;      // Used for cost-check when no-progress
       assert work._cnt<1000;
       Syntax syn = work.pop();  // Get work
       if( DO_HM ) {
         T2 old = syn._hmt;        // Old value for progress assert
         if( syn.hm(work) ) {
           assert !syn.debug_find().unify(old.find(),null);// monotonic: unifying with the result is no-progress
           syn.add_hm_work(work);     // Push affected neighbors on worklist
         } else {
           assert !DEBUG_LEAKS || oldcnt==T2.CNT;  // No-progress consumes no-new-T2s
         }
       }
       if( DO_GCP ) {
         Type old = syn._flow;
         Type t = syn.val(work);
         if( t!=old ) {           // Progress
           assert old.isa(t);     // Monotonic falling
           syn._flow = t;         // Update type
           if( syn._par!=null ) { // Generally, parent needs revisit
             work.push(syn._par); // Assume parent needs revisit
             syn._par.add_val_work(syn,work); // Push affected neighbors on worklist
           }
         }
       }
  
       // VERY EXPENSIVE ASSERT: O(n^2).  Every Syntax that makes progress is on the worklist
       assert prog.more_work(work);
     }
     assert prog.more_work(work);
  
     System.out.println("Initial T2s: "+init_T2s+", Prog size: "+cnt_syns+", worklist iters: "+work._cnt+", T2s: "+T2.CNT);
     return prog;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ id()

static String com.cliffc.aa.HM.HM9.id ( )

staticprivate

Definition at line 224 of file HM9.java.

                              {
     ID.clear();
     while( X<BUF.length && isAlpha1(BUF[X]) )
       ID.p((char)BUF[X++]);
     String s = ID.toString().intern();
     if( s.length()==0 ) throw unimpl("Missing id");
     return s;
   }

References com.cliffc.aa.HM.HM9.BUF, com.cliffc.aa.util.SB.clear(), com.cliffc.aa.HM.HM9.ID, com.cliffc.aa.HM.HM9.isAlpha1(), com.cliffc.aa.util.SB.p(), com.cliffc.aa.util.SB.toString(), and com.cliffc.aa.HM.HM9.X.

Referenced by com.cliffc.aa.HM.HM9.T2.add_fld(), com.cliffc.aa.HM.HM9.Field.Field(), and com.cliffc.aa.HM.HM9.term().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ isAlpha0()

static boolean com.cliffc.aa.HM.HM9.isAlpha0 ( byte c )

staticprivate

Definition at line 255 of file HM9.java.

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

Referenced by com.cliffc.aa.HM.HM9.isAlpha1(), and com.cliffc.aa.HM.HM9.term().

Here is the caller graph for this function:

◆ isAlpha1()

static boolean com.cliffc.aa.HM.HM9.isAlpha1 ( byte c )

staticprivate

Definition at line 256 of file HM9.java.

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

References com.cliffc.aa.HM.HM9.isAlpha0().

Referenced by com.cliffc.aa.HM.HM9.id().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ isDigit()

static boolean com.cliffc.aa.HM.HM9.isDigit ( byte c )

staticprivate

Definition at line 254 of file HM9.java.

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

Referenced by com.cliffc.aa.HM.HM9.T2.is_tuple(), com.cliffc.aa.HM.HM9.number(), and com.cliffc.aa.HM.HM9.term().

Here is the caller graph for this function:

◆ isWS()

static boolean com.cliffc.aa.HM.HM9.isWS ( byte c )

staticprivate

Definition at line 253 of file HM9.java.

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

Referenced by com.cliffc.aa.HM.HM9.skipWS().

Here is the caller graph for this function:

◆ number()

static Syntax com.cliffc.aa.HM.HM9.number ( )

staticprivate

Definition at line 232 of file HM9.java.

                                  {
     if( BUF[X]=='0' ) { X++; return new Con(Type.XNIL); }
     int sum=0;
     while( X<BUF.length && isDigit(BUF[X]) )
       sum = sum*10+BUF[X++]-'0';
     if( X>= BUF.length || BUF[X]!='.' )
       return new Con(TypeInt.con(sum));
     X++;
     float f = (float)sum;
     f = f + (BUF[X++]-'0')/10.0f;
     return new Con(TypeFlt.con(f));
   }

References com.cliffc.aa.HM.HM9.BUF, com.cliffc.aa.type.TypeFlt.con(), com.cliffc.aa.type.TypeInt.con(), com.cliffc.aa.HM.HM9.isDigit(), com.cliffc.aa.HM.HM9.X, and com.cliffc.aa.type.Type< T extends Type< T >.XNIL.

Referenced by com.cliffc.aa.HM.HM9.term().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ parse()

static Root com.cliffc.aa.HM.HM9.parse ( String s )

staticpackage

Definition at line 145 of file HM9.java.

                                 {
     X = 0;
     BUF = s.getBytes();
     Syntax prog = term();
     if( skipWS() != -1 ) throw unimpl("Junk at end of program: "+new String(BUF,X,BUF.length-X));
     // Inject IF at root
     return new Root(prog);
   }

References com.cliffc.aa.HM.HM9.BUF, com.cliffc.aa.HM.HM9.skipWS(), com.cliffc.aa.HM.HM9.term(), and com.cliffc.aa.HM.HM9.X.

Referenced by com.cliffc.aa.HM.HM9.hm().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ require() [1/3]

static void com.cliffc.aa.HM.HM9.require ( char c )

staticprivate

Definition at line 257 of file HM9.java.

257 { if( skipWS()!=c ) throw unimpl("Missing '"+c+"'"); X++; }

References com.cliffc.aa.HM.HM9.skipWS(), and com.cliffc.aa.HM.HM9.X.

Referenced by com.cliffc.aa.HM.HM9.string(), and com.cliffc.aa.HM.HM9.term().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ require() [2/3]

static <T> T com.cliffc.aa.HM.HM9.require	(	char	c,
		T	t
	)

staticprivate

Definition at line 258 of file HM9.java.

258 { require(c); return t; }

References com.cliffc.aa.HM.HM9.require().

Referenced by com.cliffc.aa.HM.HM9.require().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ require() [3/3]

static void com.cliffc.aa.HM.HM9.require ( String s )

staticprivate

Definition at line 259 of file HM9.java.

                                         {
     skipWS();
     for( int i=0; i<s.length(); i++ )
       if( X+i >= BUF.length || BUF[X+i]!=s.charAt(i) )
         throw unimpl("Missing '"+s+"'");
     X+=s.length();
   }

References com.cliffc.aa.HM.HM9.BUF, com.cliffc.aa.HM.HM9.skipWS(), and com.cliffc.aa.HM.HM9.X.

Here is the call graph for this function:

◆ reset()

static void com.cliffc.aa.HM.HM9.reset ( )

staticpackage

Definition at line 130 of file HM9.java.

                       {
     BitsAlias.reset_to_init0();
     BitsFun.reset_to_init0();
     PRIMSYNS.clear();
     Pair1.PAIR1S.clear();
     Lambda.FUNS.clear();
     T2.reset();
     PrimSyn.reset();
   }

References com.cliffc.aa.HM.HM9.Lambda.FUNS, com.cliffc.aa.HM.HM9.Pair1.PAIR1S, com.cliffc.aa.HM.HM9.PRIMSYNS, com.cliffc.aa.HM.HM9.PrimSyn.reset(), com.cliffc.aa.HM.HM9.T2.reset(), com.cliffc.aa.type.BitsFun.reset_to_init0(), and com.cliffc.aa.type.BitsAlias.reset_to_init0().

Here is the call graph for this function:

◆ skipWS()

static byte com.cliffc.aa.HM.HM9.skipWS ( )

staticprivate

Definition at line 249 of file HM9.java.

                                {
     while( X<BUF.length && isWS(BUF[X]) ) X++;
     return X==BUF.length ? -1 : BUF[X];
   }

References com.cliffc.aa.HM.HM9.BUF, com.cliffc.aa.HM.HM9.isWS(), and com.cliffc.aa.HM.HM9.X.

Referenced by com.cliffc.aa.HM.HM9.parse(), com.cliffc.aa.HM.HM9.require(), and com.cliffc.aa.HM.HM9.term().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ string()

static Syntax com.cliffc.aa.HM.HM9.string ( )

staticprivate

Definition at line 244 of file HM9.java.

                                  {
     int start = ++X;
     while( X<BUF.length && BUF[X]!='"' ) X++;
     return require('"', new Con(TypeMemPtr.make(BitsAlias.STRBITS,TypeStr.con(new String(BUF,start,X-start).intern()))));
   }

References com.cliffc.aa.HM.HM9.BUF, com.cliffc.aa.type.TypeStr.con(), com.cliffc.aa.type.TypeMemPtr.make(), com.cliffc.aa.HM.HM9.require(), com.cliffc.aa.type.BitsAlias.STRBITS, and com.cliffc.aa.HM.HM9.X.

Referenced by com.cliffc.aa.HM.HM9.term().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ term()

static Syntax com.cliffc.aa.HM.HM9.term ( )

staticpackage

Definition at line 153 of file HM9.java.

                        {
     if( skipWS()==-1 ) return null;
     if( isDigit(BUF[X]) ) return number();
     if( BUF[X]=='"' ) return string();
  
     if( BUF[X]=='(' ) {         // Parse an Apply
       X++;                      // Skip paren
       Syntax fun = term();
       Ary<Syntax> args = new Ary<>(new Syntax[1],0);
       while( skipWS()!= ')' && X<BUF.length ) args.push(term());
       require(')');
       // Guarding if-nil test inserts an upcast.  This is a syntatic transform only.
       if( fun instanceof If &&
           args.at(0) instanceof Ident ) {
         Ident id = (Ident)args.at(0);
         args.set(1,new Apply(new Lambda(args.at(1), id._name),
                              new Apply(new NotNil(),new Ident(id._name))));
       }
       return new Apply(fun,args.asAry());
     }
  
     if( BUF[X]=='{' ) {         // Lambda of 1 or 2 args
       X++;                      // Skip paren
       Ary<String> args = new Ary<>(new String[1],0);
       while( skipWS()!='-' ) args.push(id());
       require("->");
       Syntax body = term();
       require('}');
       return new Lambda(body,args.asAry());
     }
     // Let or Id
     if( isAlpha0(BUF[X]) ) {
       String id = id();
       if( skipWS()!='=' ) {
         PrimSyn prim = PRIMSYNS.get(id); // No shadowing primitives or this lookup returns the prim instead of the shadow
         return prim==null ? new Ident(id) : prim.make(); // Make a prim copy with fresh HM variables
       }
       // Let expression; "id = term(); term..."
       X++;                      // Skip '='
       Syntax def = term();
       require(';');
       return new Let(id,def,term());
     }
  
     // Structure
     if( BUF[X]=='@' ) {
       X++;
       require('{');
       Ary<String>  ids = new Ary<>(String.class);
       Ary<Syntax> flds = new Ary<>(Syntax.class);
       while( skipWS()!='}' && X < BUF.length ) {
         String id = require('=',id());
         Syntax fld = term();
         if( fld==null ) throw unimpl("Missing term for field "+id);
         ids .push( id);
         flds.push(fld);
         if( skipWS()==',' ) X++;
       }
       require('}');
       return new Struct(ids.asAry(),flds.asAry());
     }
  
     // Field lookup is prefix or backwards: ".x term" instead of "term.x"
     if( BUF[X]=='.' ) {
       X++;
       return new Field(id(),term());
     }
  
     throw unimpl("Unknown syntax");
   }