AstLog. Outline. Microsoft Research.

Transcription

1 AstLog Microsoft Research. Outline Where does it come from? Prolog, with examples. Basic concepts of ASTLog. Simple examples in ASTLog. More complex examples. Why is this (apparently) not very widely used? 1

2 Important Prolog Ideas Terms, Facts, and rules. Unification. Backtracking. late binding. Prolog Examples. family(x,y):- unify(y,atomic(v,w,x)),dad(v,x), mom(w,x). unify(x,x). first([h _],H). rest([],[]). rest([_ T],T). append([],l,l). append([h T],L,[H R]) :- append(t,l,r). 2

3 Prolog for querying ASTs Prolog is an extension of SQL with complex terms and recursion. Easy to extend and modify. Very compact and powerful. BUT. AST s too expensive to store in Prolog. Runtime can be slow (memory). Example: Append 3 lists. append([],l,l). append([h T],L,[H R]) :- append(t,l,r). append(a,b,c,d):-append(a,b,s),append(s,c,d). append([],b,c,d):-append(b,c,d). append([h T],B,C,[H R]):-append(T,B,C,R). What is the difference? Answer: No intermediate lists! (Deforestation). 3

4 AstLog basics: There s always an implicit current node. AST s are not converted to Prolog. Matching rules are more complex. Lots of built-in predicates for matching/traversing AST nodes. Elegant, but sometimes a bit obscure (like T.S. Elliot). AstLog Elements and Constructs. Constants: #function, #lhs, #fname, etc. Variables: X, Y, Z, etc. Predicates: op(#function), kid(#lhs,y)etc. Compound: kid(#lhs, and(op(#variable), varname(y))) 4

5 AstLog simple example somekid(y):-kid(_,y). somenode(p):-or(p,kid(_,somenode(p)). defuse():- and(asym(y), if(parent(and(op(#=),kid(#left,asym(y))), emit( definition ), emit( use ))). AstLog simple example 2 cgr():-and(op(#function),fname(asym(y)), funcall(y)). funcall(y):-somenode(and(op(#funcall), kid(#callname,z), print(y,z ), or())). op(#filenode),kid(_,cgr()),or(). 5

6 Sametree sametree(node) :- op(nodeop), with (Node, op(nodeop)), not(and(with(node, kid(n, Nkid)), kid(n,not(sametree(nkid))) Follows in AstLog follows(p1,p2) Will match a node if P1 and P2 are true of consecutive nodes in an abstract syntax tree. Can this be used to generate control flow graph (all edges?) If not, why not? What exactly is meant by consecutive? cosecutive = necessary control flow. 6

7 MOST LIKELY WE LL JUST STOP HERE. THE REST WON T BE COVERED IN CLASS. Flatten flatten(test,lst): collect a list of AST nodes (children) that satisfy a particular predicate. flatten(test,head,tail): collect the list of AST nodes below current node satisfying a predicate, and hook the end of the list to the 3 rd argument; return result in argument 2. flatten(test,n,head,tail): collect the list of descendent AST nodes starting at kid n and hook 4 th argument at the end return result in arg 3. 7

8 flatten(test,lst):- flatten(test,lst,[]). flatten(test,head,tail):- if(test,and(o,unify(head,[o hrest])), unify(head,hrest)) flattenkids(test,0,hrest,tail). flattenkids(test,n,head,tail):- if(kid(n,flatten(test,kid,mid)), and(with(n,minus(nplus1,1)), flattenkids(test,nplus1,mid,tail)), unify(head,tail)). unify(x,x). Abstracted predicates. Advantage: some variables bound entirely within the scope of the predicate, and never leaked. Syntax: FN{.vars.} (anonymous-clauses). Consider: set of all (x,y) such that p(x,y). Defined using the old flatten expands to: if(p(x,y), unify(head,[(x,y) hrest]), unify(head,hrest)) flattenkids(p(x,y),0,hrest,tail). Won t work! Why? 8

9 Solution Using abstracted predicates: if((pred)(x,y), unify(head,[(x,y) hrest]), unify(head,hrest)) flattenkids(pred,0,hrest,tail). Another advantage: Sametree example: consider a predicate that involves making a complicated matching decision involving both nodes. sametree(testif, node):-. opcode(op), with(node,opcode(op)), testif(node), /* how do we say this? */. not(and(with(node,kid(n,nkid)), kid(n,not(sametree(testif, nkid))))). testif(node) :- etc, etc. Answer: Define an abstract predicate! 9

10 Examples sametree(node,equ):- op(nodeop),with(node,op(nodeop)), (equ)(node) (not(and(with(node,kid(n,nkid)) kid(n,not(sametree(nkid,equ)))))) Paper has the same done with abstraction? consteq(node):-if(aconst( c ), with(n, aconst( c)), and()) sametree(node, consteq/1) Higher order queries. WHY? Iterating /retrying over queries, and accumulating state. Set comprehension (set of all x such that P(x)). Counting elements. Is Q(x) true of all elements x : P(x), etc. HOW? Make a query into an object, with state. Provide higher-order functions that control the state of a query. But what are the states of a query? 10

11 Higher order queries Get a query under higher order control: the query(fterm, query-pred) primitive, and get it started.. Step through several evaluations: query(pred, thisquery-pred,nextquery-pred). First arg when it fails (exit), second arg otherwise, and then third arg at next evaluation.. Get bindings: qget(object-pred.). Conclusion Powerful language, full use of Prolog + higher order primitives. Sits right on top of most widely used C++ dialect Visual C++!!! Efficient execution, about 5-10 times slower than GENOA (due to Prolog) still faster than many other tools. Language design is based on abstract, difficult concepts, unfamiliar to many practioners. However, very good for study. 11