evaluate the type and one or more variable declarations, e.g.:
int a, b=5, c;
493249
public Object eval( CallStack callstack, Interpreter interpreter)
        throws EvalError
    {
        Object value = Primitive.VOID;
        try {
            NameSpace namespace = callstack.top();
            BSHType typeNode = getTypeNode();
            Class<?> type = typeNode.getType( callstack, interpreter );

            BSHVariableDeclarator [] bvda = getDeclarators();
            for (int i = 0; i < bvda.length; i++)
            {
                BSHVariableDeclarator dec = bvda[i];

                // Type node is passed down the chain for array initializers
                // which need it under some circumstances
                value = dec.eval( typeNode, modifiers, callstack, interpreter);
                try {
                    LHS lhs = null;
                    if ( namespace.isClass )
                        if ( null != namespace.classInstance )
                            lhs = new LHS(namespace.classInstance,
                                Reflect.resolveJavaField(
                                    namespace.classInstance.getClass(),
                                dec.name, modifiers.hasModifier("static")));
                        else
                            lhs = new LHS(namespace.classStatic,
                                Reflect.resolveJavaField(namespace.classStatic,
                                dec.name, modifiers.hasModifier("static")));

                    if ( null != lhs && null != lhs.field ) {
                        Variable var = new Variable(dec.name, type, lhs);
                        var.modifiers = modifiers;
                        var.setValue(value, Variable.ASSIGNMENT);
                        namespace.setVariableImpl(var);
                    } else {
                        if (interpreter.getStrictJava()
                                && value instanceof Primitive
                                && ((Primitive) value).isNumber())
                            value = Primitive.castNumberStrictJava(type,
                                    ((Primitive) value).numberValue());
                        namespace.setTypedVariable(
                                dec.name, type, value, modifiers );
                    }
                    value = namespace.getVariable(dec.name);
                } catch ( UtilEvalError e ) {
                    throw e.toEvalError( this, callstack );
                }
            }
        } catch ( EvalError e ) {
            e.reThrow( "Typed variable declaration" );
        }
        return value;
    }
1119404
def var(self):
        """"""
        if self._var is None:
            self._var = symbol.var(self.name, shape=self.shape, dtype=self.dtype,
                                   lr_mult=self.lr_mult, wd_mult=self.wd_mult,
                                   init=self.init, stype=self._stype)
        return self._var
1086324
def p_type_def_2(t):
    """"""
    id = t[2]
    body = t[3]
    lineno = t.lineno(1)
    sortno = t.lineno(4) + 0.5
    if id_unique(id, 'enum', lineno):
        name_dict[id] = enum_info(id, body, lineno, sortno)
950747
def _compile_int(self):
        """"""
        string = '"""\n'

        # evaluate the algebraic equations g
        string += 'system.dae.init_fg(resetz=False)\n'
        for gcall, call in zip(self.gcall, self.gcalls):
            if gcall:
                string += call
        string += '\n'
        string += 'system.dae.reset_small_g()\n'

        # handle islands
        string += self.gisland

        # evaluate differential equations f
        for fcall, call in zip(self.fcall, self.fcalls):
            if fcall:
                string += call
        string += 'system.dae.reset_small_f()\n'
        string += '\n'

        fg_string = string + '"""'
        self.int_fg = compile(eval(fg_string), '', 'exec')

        # rebuild constant Jacobian elements if needed
        string += 'if system.dae.factorize:\n'
        string += '    system.dae.init_jac0()\n'
        for jac0, call in zip(self.jac0, self.jac0s):
            if jac0:
                string += '    ' + call
        string += '    system.dae.temp_to_spmatrix(\'jac0\')\n'

        # evaluate Jacobians Gy and Fx
        string += 'system.dae.setup_FxGy()\n'
        for gycall, call in zip(self.gycall, self.gycalls):
            if gycall:
                string += call
        string += '\n'
        for fxcall, call in zip(self.fxcall, self.fxcalls):
            if fxcall:
                string += call
        string += self.gyisland
        string += 'system.dae.temp_to_spmatrix(\'jac\')\n'

        string += '"""'
        if SHOW_INT_CALL:
            logger.debug(string)

        self.int = compile(eval(string), '', 'exec')
653694
def parseCCUSysVar(self, data):
        """"""
        if data['type'] == 'LOGIC':
            return data['name'], data['value'] == 'true'
        elif data['type'] == 'NUMBER':
            return data['name'], float(data['value'])
        elif data['type'] == 'LIST':
            return data['name'], int(data['value'])
        else:
            return data['name'], data['value']
1216489
def p_var_decl_at(p):
    
    p[0] = None

    if len(p[2]) != 1:
        syntax_error(p.lineno(1),
                     'Only one variable at a time can be declared this way')
        return

    idlist = p[2][0]

    entry = SYMBOL_TABLE.declare_variable(idlist[0], idlist[1], p[3])
    if entry is None:
        return

    if p[5].token == 'CONST':
        tmp = p[5].expr
        if tmp.token == 'UNARY' and tmp.operator == 'ADDRESS':  # Must be an ID
            if tmp.operand.token == 'VAR':
                entry.make_alias(tmp.operand)
            elif tmp.operand.token == 'ARRAYACCESS':
                if tmp.operand.offset is None:
                    syntax_error(p.lineno(4), 'Address is not constant. Only constant subscripts are allowed')
                    return

                entry.make_alias(tmp.operand)
                entry.offset = tmp.operand.offset
            else:
                syntax_error(p.lineno(4), 'Only address of identifiers are allowed')
                return

    elif not is_number(p[5]):
        syntax_error(p.lineno(4), 'Address must be a numeric constant expression')
        return
    else:
        entry.addr = str(make_typecast(_TYPE(gl.STR_INDEX_TYPE), p[5], p.lineno(4)).value)
        entry.accessed = True
        if entry.scope == SCOPE.local:
            SYMBOL_TABLE.make_static(entry.name)
1297001
def _expect_vars(vs=None):
        """"""
        if vs is None:
            return list()
        elif isinstance(vs, Variable):
            return [vs]
        else:
            checked = list()
            # Will raise TypeError if vs is not iterable
            for v in vs:
                if isinstance(v, Variable):
                    checked.append(v)
                else:
                    fstr = "expected Variable, got {0.__name__}"
                    raise TypeError(fstr.format(type(v)))
            return checked
1297804
def p_variable(p):
    ''''''
    if len(p) == 6:
        name, dims = p[3]
        params = p[4]
        if params is not None:
            p[0] = ast.MethodCall(p[1], name, params, lineno=p.lineno(2))
        else:
            p[0] = ast.ObjectProperty(p[1], name, lineno=p.lineno(2))
        for class_, dim, lineno in dims:
            p[0] = class_(p[0], dim, lineno=lineno)
        for (name, dims), params in p[5]:
            if params is not None:
                p[0] = ast.MethodCall(p[0], name, params, lineno=p.lineno(2))
            else:
                p[0] = ast.ObjectProperty(p[0], name, lineno=p.lineno(2))
            for class_, dim, lineno in dims:
                p[0] = class_(p[0], dim, lineno=lineno)
    else:
        p[0] = p[1]
673132
def c_var_decls(self):
        """"""
        if self.opts.no_structs:
            mod_decl = 'HMODULE {} = NULL;\n'.format(self.name)
            return [mod_decl] + [
                '{} *{} = NULL;\n'.format(
                    self._c_type_name(name), name
                )
                for name, dummy_args in self.funcs
            ]
        if self.opts.windll:
            return ''
        return [
            '{} _{} = {{ 0 }};\n'.format(
                self._c_struct_names()[1], self.name
            )
        ]
1276047
private boolean eachVariableOccursOnlyOnce() {
        int lit;
        for (int i = 0; i < this.addedlits.size(); i++) {
            lit = this.addedlits.get(i);
            assert marked(lit) == 0;
            assert marked(-lit) == 0;
        }
        boolean res = true;
        for (int i = 0; i < this.addedlits.size(); i++) {
            lit = this.addedlits.get(i);
            if (marked(lit) != 0 || marked(-lit) != 0) { res = false; } else { mark(lit); }
        }
        unmark();
        return res;
    }
686588
def p_typed_var_list(self, p):
        ''''''
        if len(p) == 4:
            p[1].append(p[3])
            p[0] = p[1]
        elif len(p) == 2:
            p[0] = [p[1]]
498597
def p_types(self, p):
        ''''''
        if len(p) == 2:
            p[0] = tuple((t,) for t in p[1])
        else:
            p[0] = tuple((t,) + ts for t in p[1] for ts in p[3])
631294
private Variable createVariableInferred(TokenList.Token t0, Variable variableRight) {
        Variable result;

        if( t0.getType() == Type.WORD ) {
            switch( variableRight.getType()) {
                case MATRIX:
                    alias(new DMatrixRMaj(1,1),t0.getWord());
                    break;

                case SCALAR:
                    if( variableRight instanceof VariableInteger) {
                        alias(0,t0.getWord());
                    } else {
                        alias(1.0,t0.getWord());
                    }
                    break;

                case INTEGER_SEQUENCE:
                    alias((IntegerSequence)null,t0.getWord());
                    break;

                default:
                    throw new RuntimeException("Type not supported for assignment: "+variableRight.getType());
            }

            result = variables.get(t0.getWord());
        } else {
            result = t0.getVariable();
        }
        return result;
    }
195517
static void checkTypes(ImmutableList<Type> types, Iterable<? extends Expression> exprs) {
    int size = Iterables.size(exprs);
    checkArgument(
        size == types.size(),
        "Supplied the wrong number of parameters. Expected %s, got %s",
        types.size(),
        size);
    // checkIsAssignableTo is an no-op if DEBUG is false
    if (Flags.DEBUG) {
      int i = 0;
      for (Expression expr : exprs) {
        expr.checkAssignableTo(types.get(i), "Parameter %s", i);
        i++;
      }
    }
  }
1318698
def VAR_DECL(self, cursor):
        """"""
        # get the name
        name = self.get_unique_name(cursor)
        log.debug('VAR_DECL: name: %s', name)
        # Check for a previous declaration in the register
        if self.is_registered(name):
            return self.get_registered(name)
        # get the typedesc object
        _type = self._VAR_DECL_type(cursor)
        # transform the ctypes values into ctypeslib
        init_value = self._VAR_DECL_value(cursor, _type)
        # finished
        log.debug('VAR_DECL: _type:%s', _type.name)
        log.debug('VAR_DECL: _init:%s', init_value)
        log.debug('VAR_DECL: location:%s', getattr(cursor, 'location'))
        obj = self.register(name, typedesc.Variable(name, _type, init_value))
        self.set_location(obj, cursor)
        self.set_comment(obj, cursor)
        return True
906178
function parseConstLetDeclaration(kind) {
        var declarations;

        expectKeyword(kind);

        declarations = parseVariableDeclarationList(kind);

        consumeSemicolon();

        return {
            type: Syntax.VariableDeclaration,
            declarations: declarations,
            kind: kind
        };
    }
297284
def p_variable_declaration_noin(self, p):
        
        if len(p) == 2:
            p[0] = ast.VarDecl(p[1])
        else:
            p[0] = ast.VarDecl(p[1], p[2])