# Class type Cil.cilVisitor

    class type cilVisitor = object .. end

A visitor interface for traversing CIL trees. Create instantiations of this type by specializing the class `Cil.nopCilVisitor`. Each of the specialized visiting functions can also call the `queueInstr` to specify that some instructions should be inserted before the current instruction or statement. Use syntax like `self#queueInstr` to call a method associated with the current object.

    method vvdec : varinfo -> varinfo visitAction

Invoked for each variable declaration. The subtrees to be traversed are those corresponding to the type and attributes of the variable. Note that variable declarations are all the `GVar`, `GVarDecl`, `GFun`, all the `varinfo` in formals of function types, and the formals and locals for function definitions. This means that the list of formals in a function definition will be traversed twice, once as part of the function type and second as part of the formals in a function definition.

    method vvrbl : varinfo -> varinfo visitAction

Invoked on each variable use. Here only the `SkipChildren` and `ChangeTo` actions make sense since there are no subtrees. Note that the type and attributes of the variable are not traversed for a variable use

    method vexpr : exp -> exp visitAction

Invoked on each expression occurrence. The subtrees are the subexpressions, the types (for a `Cast` or `SizeOf` expression) or the variable use.

    method vlval : lval -> lval visitAction

Invoked on each lvalue occurrence

    method voffs : offset -> offset visitAction

Invoked on each offset occurrence that is *not* as part of an initializer list specification, i.e. in an lval or recursively inside an offset.

    method vinitoffs : offset -> offset visitAction

Invoked on each offset appearing in the list of a CompoundInit initializer.

    method vinst : instr -> instr list visitAction

Invoked on each instruction occurrence. The `ChangeTo` action can replace this instruction with a list of instructions

    method vstmt : stmt -> stmt visitAction

Control-flow statement. The default `DoChildren` action does not create a new statement when the components change. Instead it updates the contents of the original statement. This is done to preserve the sharing with `Goto` and `Case` statements that point to the original statement. If you use the `ChangeTo` action then you should take care of preserving that sharing yourself.

    method vblock : block -> block visitAction

Block.

    method vfunc : fundec -> fundec visitAction

Function definition. Replaced in place.

    method vglob : global -> global list visitAction

Global (vars, types, etc.)

    method vinit : varinfo -> offset -> init -> init visitAction

Initializers for static, const and global variables, pass the variable where this occurs, and the offset

    method vtype : typ -> typ visitAction

Use of some type. Note that for structure/union and enumeration types the definition of the composite type is not visited. Use `vglob` to visit it.

    method vattr : attribute -> attribute list visitAction

Attribute. Each attribute can be replaced by a list

    method vattrparam : attrparam -> attrparam visitAction

Attribute parameters.

    method queueInstr : instr list -> unit

Add here instructions while visiting to queue them to preceede the current statement or instruction being processed. Use this method only when you are visiting an expression that is inside a function body, or a statement, because otherwise there will no place for the visitor to place your instructions.

    method unqueueInstr : unit -> instr list

Gets the queue of instructions and resets the queue. This is done automatically for you when you visit statments.