Lines Matching +defs:key +defs:types
127 ;; 'c-decl-type-start is used when the declarators are types,
170 ;; Internal state of hungry delete key feature
171 (defvar c-hungry-delete-key nil)
172 (make-variable-buffer-local 'c-hungry-delete-key)
177 ;; key like `{' is pressed (or an electric keyword like `else').
579 ;; boundaries and the tokens (such as "while") in c-opt-block-stmt-key. Its
683 ;; `c-nonlabel-token-key'. It's `start' if no valid label
697 (cond-key (or c-opt-block-stmt-key
775 (and (looking-at cond-key)
986 (when (and c-opt-method-key
998 (if (or (not (looking-at c-nonlabel-token-key)) ; proper label
1014 (looking-at c-nonlabel-token-key)) ; e.g. "while :"
1038 (if (setq saved (if (looking-at c-block-stmt-1-key)
2240 ;; Check for known types of parens that we
2479 (looking-at c-symbol-key)
2514 (looking-at c-symbol-key)
3984 ;; A cache for found types.
3986 ;; Buffer local variable that contains an obarray with the types we've
3996 ;; ceased to be types must be removed from it.
3998 ;; Template types in C++ are added here too but with the template
4005 ;; recognizing types, not telling distinct types apart). Note that
4006 ;; template types in references are added here too; from the example
4008 (defvar c-found-types nil)
4009 (make-variable-buffer-local 'c-found-types)
4011 (defsubst c-clear-found-types ()
4012 ;; Clears `c-found-types'.
4013 (setq c-found-types (make-vector 53 0)))
4016 ;; Add the given region as a type in `c-found-types'. If the region
4027 (unless (intern-soft type c-found-types)
4028 (unintern (substring type 0 -1) c-found-types)
4029 (intern type c-found-types))))
4032 ;; Remove the "NAME" from c-found-types, if present.
4033 (unintern name c-found-types))
4037 ;; `c-found-types'.
4041 c-found-types))
4043 (defun c-list-found-types ()
4044 ;; Return all the types in `c-found-types' as a sorted list of
4050 c-found-types)
4053 (defun c-trim-found-types (beg end old-len)
4056 ;; from `c-found-types', should this type have become stale. For
4058 ;; "foo(); \n bar();". Such stale types, if not removed, foul up
4097 ;; Handling of small scale constructs like types and names.
4138 ;; treat possible types (i.e. those that it normally returns 'maybe or
4139 ;; 'found for) as actual types (and always return 'found for them).
4141 ;; that is set, and that it adds them to `c-found-types'.
4142 (defvar c-promote-possible-types nil)
4150 ;; all arglists for side effects (i.e. recording types), otherwise it
4183 ;; All known types that can't be identifiers are recorded, and also
4184 ;; other possible types if `c-promote-possible-types' is set.
4227 ;; record the ranges of types that only are found. Behaves otherwise
4229 (defvar c-record-found-types nil)
4257 ;; over a comma separated list of types or names using
4328 ;; inside the paren, to record the types.
4332 (looking-at c-symbol-key) ; Always matches.
4365 ;; If a keyword matched both one of the types above and
4381 (defun c-forward-<>-arglist (all-types)
4387 ;; the arglist that might be types are treated as found types.
4404 ;; recording of any found types that constitute an argument in
4406 (c-record-found-types (if c-record-type-identifiers t)))
4408 (setq c-record-found-types
4409 (c-forward-<>-arglist-recur all-types)))
4411 (when (consp c-record-found-types)
4414 ;; `c-record-found-types' is t.
4415 (nconc c-record-found-types c-record-type-identifiers)))
4421 (defun c-forward-<>-arglist-recur (all-types)
4431 (c-record-found-types c-record-found-types)
4461 (if all-types
4463 ;; All encountered identifiers are types, so set the
4468 (let ((c-promote-possible-types t))
4474 ;; then it's recorded in `c-record-found-types' which we
4478 (let ((orig-record-found-types c-record-found-types))
4484 ;; `c-record-found-types'.
4485 (setq c-record-found-types
4486 orig-record-found-types))))))
4559 (looking-at c-opt-<>-sexp-key))
4565 (c-record-found-types nil))
4577 (setq c-record-found-types subres)
4584 (if (and c-opt-identifier-concat-key
4587 (looking-at c-opt-identifier-concat-key)))
4607 (or c-record-found-types t)))))
4609 (defun c-backward-<>-arglist (all-types &optional limit)
4655 (if (c-forward-<>-arglist all-types)
4695 ;; Turn off `c-promote-possible-types' here since we might
4701 c-promote-possible-types)
4704 (looking-at c-identifier-key)
4708 ;; `c-identifier-key' first.
4718 "\\(" (c-lang-const c-nonsymbol-key c++)
4747 ;; of `c-opt-type-modifier-key'.
4764 (looking-at c-opt-type-modifier-key))
4792 (when (or c-opt-identifier-concat-key
4796 ((and c-opt-identifier-concat-key
4797 (looking-at c-opt-identifier-concat-key))
4800 ;; covered in `c-identifier-key'.
4810 c-record-found-types)
4818 (if (and c-opt-identifier-concat-key
4819 (looking-at c-opt-identifier-concat-key))
4843 ;; otherwise known type (according to `*-font-lock-extra-types'),
4845 ;; that matches one in `c-found-types', 'maybe if it's an identfier
4864 (when c-opt-type-modifier-key
4865 (while (looking-at c-opt-type-modifier-key)
4871 ((looking-at c-type-prefix-key)
4881 ;; prefix, so we add it to `c-found-types'.
4900 (and (cond ((looking-at c-primitive-type-key)
4903 (looking-at c-known-type-key))
4920 (or c-promote-possible-types (eq res t)))
4923 (if (and c-opt-type-component-key
4925 (looking-at c-opt-type-component-key)))
4931 (looking-at c-opt-type-component-key))
4933 (looking-at c-primitive-type-key))
4937 (if (looking-at c-primitive-type-key)
4956 (if (or res c-promote-possible-types)
4981 (when c-opt-type-modifier-key
4982 (while (looking-at c-opt-type-modifier-key)
4991 (when c-opt-type-suffix-key
4992 (while (looking-at c-opt-type-suffix-key)
4996 (when c-opt-type-concat-key
5000 ;; types in `c-found-types' - it's the component types that
5003 (let* ((c-promote-possible-types (or (memq res '(t known))
5004 c-promote-possible-types))
5005 ;; If we can't promote then set `c-record-found-types' so that
5006 ;; we can merge in the types from the second part afterwards if
5008 (c-record-found-types (and c-record-type-identifiers
5009 (not c-promote-possible-types)))
5011 (if (and (looking-at c-opt-type-concat-key)
5021 ;; uncertain types to a certain one.
5039 (consp c-record-found-types))
5040 ;; Merge in the ranges of any types found by the second
5044 ;; `c-record-found-types' is t.
5045 (nconc c-record-found-types
5050 (when (and c-record-found-types (memq res '(known found)) id-range)
5051 (setq c-record-found-types
5052 (cons id-range c-record-found-types))))
5067 ;; of types when parsing a declaration, which means that it
5138 ;; i.e. the declared identifier(s) are types.
5197 ;; identifier(s) types.
5227 ;; types, but they could also be specifiers disguised through
5228 ;; macros like __INLINE__, so we recognize both types and known
5254 (let ((c-promote-possible-types t))
5273 ;; types.
5327 (while (looking-at c-decl-hangon-key)
5367 ;; identifier(s) that we might have taken as types.
5379 ;; `c-type-decl-prefix-key'.
5386 ;; `c-type-decl-suffix-key'.
5413 (while (and (looking-at c-type-decl-prefix-key)
5448 (while (if (looking-at c-type-decl-suffix-key)
5595 ;; (primitive types are handled above).
5601 ;; types; other identifiers could just as well be
5620 c-after-suffixed-type-maybe-decl-key))))))
5624 ;; "backtracking" done inside the `c-type-decl-suffix-key' loop
5629 ;; looking at either `c-after-suffixed-type-decl-key' or "[;,]".
5668 (looking-at c-after-suffixed-type-decl-key)
5678 ;; `c-after-suffixed-type-decl-key' has matched.
5681 ;; A declaration according to `c-after-suffixed-type-decl-key'.
5730 ;; known types, so do a check without that
5737 (looking-at c-known-type-key)))
5787 ;; `c-found-types') we should return t due to the disambiguation rule
5851 (looking-at c-simple-stmt-key)
5861 (let ((c-promote-possible-types t))
5882 (let ((c-promote-possible-types t))
5911 ;; (v) One of the keywords matched by `c-opt-extra-label-key' (without any
5919 ;; the first submatch in `c-opt-extra-label-key'. The point is directly
5980 ((and c-opt-extra-label-key
5981 (looking-at c-opt-extra-label-key))
5982 ;; For a `c-opt-extra-label-key' match, we record the whole
6021 (looking-at c-block-stmt-1-key)))
6031 (looking-at c-block-stmt-1-key)))
6112 ;; Check that `c-nonlabel-token-key' doesn't match anywhere.
6116 (when (looking-at c-nonlabel-token-key)
6132 (while (c-syntactic-re-search-forward c-symbol-key nil t)
6160 (c-promote-possible-types t)
6162 ;; types here since the protocol reference list might then be
6239 (and c-opt-method-key
6240 (looking-at c-opt-method-key)
6256 (and c-opt-asm-stmt-key
6261 (looking-at c-opt-asm-stmt-key))))
6463 (or (looking-at c-block-stmt-1-key)
6466 (looking-at c-block-stmt-2-key)))
6577 ;; Must check with c-opt-method-key in ObjC mode.
6578 (not (and c-opt-method-key
6579 (looking-at c-opt-method-key)))
6688 (if (or (not c-opt-block-decls-with-vars-key)
6694 ;; Check for `c-opt-block-decls-with-vars-key'
6698 c-opt-block-decls-with-vars-key
6727 ;; what `c-decl-block-key' matched. Also, if GOTO-START is set then
6766 ;; The `c-decl-block-key' search continues from there since
6776 ((c-syntactic-re-search-forward c-decl-block-key open-brace t t t)
6799 (looking-at c-type-decl-prefix-key)))))
6808 (looking-at c-specifier-key)
6826 (if (looking-at c-symbol-key)
6857 ;; contains the bufpos at boi of the class key line, and aref 1
6892 (if (and (or (looking-at c-brace-list-key)
6894 (looking-at c-brace-list-key)))
6901 (let ((class-key
6903 ;; check for the class key here.
6905 c-decl-block-key))
6929 (when (and c-opt-inexpr-brace-list-key
6937 ((looking-at c-opt-inexpr-brace-list-key) t)
6949 ((and class-key
6950 (looking-at class-key))
7125 (or (not (looking-at c-class-key))
7238 ;; needed with further syntax elements of the types `substatement',
7774 (and c-opt-block-stmt-key
7792 (not (looking-at c-opt-block-stmt-key)))
7805 (if (looking-at c-block-stmt-2-key)
7812 (looking-at c-opt-block-stmt-key))))
7939 (looking-at c-symbol-key))
7963 (while (looking-at c-specifier-key)
7974 (and c-opt-inexpr-brace-list-key
7976 (looking-at c-opt-inexpr-brace-list-key)
7979 (looking-at c-brace-list-key))
8071 (looking-at c-opt-postfix-decl-spec-key)))
8086 (looking-at c-class-key)))
8095 (cond ((looking-at c-opt-postfix-decl-spec-key)
8219 (and (looking-at c-class-key)
8287 (not (and c-opt-block-stmt-key
8288 (looking-at c-opt-block-stmt-key)))))
8294 ((and c-opt-method-key
8295 (looking-at c-opt-method-key))
8408 ((and c-opt-method-key
8412 (when (looking-at c-opt-method-key)
8529 ((and c-opt-method-key
8534 (if (not (looking-at c-symbol-key))
8572 (looking-at c-opt-postfix-decl-spec-key)))
8617 (while (looking-at c-specifier-key)
8754 (looking-at c-other-decl-block-key))
8953 (when (and c-opt-friend-key
8954 (looking-at c-opt-friend-key))