Get a list of variables in a given expression

Hi Andrew,

Its a SKILL expression.

Thanks.

This code should work if the expression only contains lambda forms. If you use any syntax forms or macros, it may misinterpret symbols which are implicitly quoted as variables. For normal arithmetic expressions it will work fine though - it's only if you include things like ->,~> let, procedure, ' and so on that it will give the wrong result (it would add quite a bit of complexity to handle all of those).

/* abVarsUsed.il

Author     A.D.Beckett
Group      Custom IC (UK), Cadence Design Systems Ltd.
Language   SKILL
Date       Dec 09, 2011 
Modified   
By         

Examples of usage:

> abVarsUsed("1+2*(a+3*b)")
(b a)
> abVarsUsed("a+b+c+d*e+expt(f g)")
(g f e d c b a)

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

SCCS Info: @(#) abVarsUsed.il 12/09/11.09:10:28 1.1

*/

/***************************************************************
*                                                              *
*              abVarsUsed(expression [varsUsed])               *
*                                                              *
* When called with an expression in a string or list, returns  *
*  a list of the variable names used in the expression. Makes  *
*    the assumption that all functions are lambda functions    *
*                                                              *
***************************************************************/

procedure(abVarsUsed(expression @optional varsUsed)
    case(type(expression) 
        (string
            foreach(subExpr linereadstring(expression)
                varsUsed=abVarsUsed(subExpr varsUsed)
            )
        )
        (list
            ;------------------------------------------------------------
            ; ignore the car of the list because that's the
            ; function name
            ;------------------------------------------------------------
            foreach(elem cdr(expression)
                case(type(elem)
                    (symbol
                        unless(member(elem varsUsed)
                            varsUsed=cons(elem varsUsed)
                        )
                    )
                    (list
                        varsUsed=abVarsUsed(elem varsUsed)
                    )
                )
            )
        )
        (t
            (error "abVarsUsed: expecting string or list: %L\n" expression)
        )
    )
    varsUsed
)

Regards,

Andrew

Thank you Andrew for helping me.

The linereadstring is my starting point. I will just change the linereadstring(expression) to flattenList(linereadstring(BLOCKED EXPRESSION. flattenList is a user-defined function, then after that I can make the conditional statements to filter-out the the ~>,->,let,procedure, etc.

Flattening the list would be the wrong way to do this, because you lose all context. That's why a recursive function is used. To handle this you'd want to do something clever in the bit where the comment saying "ignore the car" is. Depending on the function, you'd recursively call with selective arguments. For example, with these functions:

getSGq (~>)/getq/dbGetq (->): 1st arg (not 2nd)
setSGq (~>)/putpropq/dbSetq(->): 1st and 2nd arg (not 3rd)
setq (=): 2nd arg (not 1st)
let/procedure/prog/ - rather more complex!

Why are you doing this anyway? If you're trying to identify (say) global variables, this is something SKILL Lint will do for you - this has the rules about such syntax forms built in to allow it to identify variables.

Regards,

Andrew.

Hi Andrew,

I doing this for sorting the the multiple lines of expression based on the usage/position of variables.

So far I don't have any complicated variable naming in my application, so I solved my problem at this moment.

Please see the snapshot of my code. I know this one still need some improvement as what you have said before to become fully functional.

procedure(sgGetVar(expr)
  let((varList propName propNameAssoc propOn propOnAssoc (propL 0) (propLAssoc 0) (propCtr 0) (propCtrAssoc 0))
 
    foreach(x flattenList(linereadstring(expr))

      ;for obj~>prop, gets how many getSGq are there
      if(x=='getSGq then
        propOn=t
        propL=propL+1
      )
      ;count only symbol but not a function when propOn==t.
      if(symbolp(x) && !fboundp(x) && propOn then
        unless(propName propName=x)
        propCtr=propCtr+1
      )
      ; for obj->prop, gets how many getq are there
      if(x=='getq then
        propOnAssoc=t
        propLAssoc=propLAssoc+1
      )
      ;count only symbol but not a function if propAssoc==t.
      if(symbolp(x) && !fboundp(x) && propOnAssoc then
        unless(propNameAssoc propNameAssoc=x)
        propCtrAssoc=propCtrAssoc+1
      )
      ;; gets variable name if symbol but not function, and propOn=nil and propOnAssoc=nil

      if(symbolp(x) && !fboundp(x) && !propOn && !propOnAssoc varList=cons(symbolToString(x) varList))

      ;;; adding the object name (with prop) if getSGq's total==propL+1
      if(propCtr==propL+1 then
       varList=cons(symbolToString(propName) varList)
       propName=nil propOn=nil propL=0 propCtr=0
      )
      ;adding the object name (with assoc) if getq's total== propLAssoc+1
      if(propCtrAssoc==propLAssoc+1 then
       varList=cons(symbolToString(propNameAssoc) varList)
       propNameAssoc=nil propOnAssoc=nil propLAssoc=0 propCtrAssoc=0
      )

    )
    varList
  )
)