| blob | 67f944a09ae107ef8991e0860b76f4e6df9a5347 |
1 ;;; semantic/lex-spp.el --- Semantic Lexical Pre-processor
3 ;; Copyright (C) 2006-2014 Free Software Foundation, Inc.
5 ;; Author: Eric M. Ludlam <zappo@gnu.org>
7 ;; This file is part of GNU Emacs.
9 ;; GNU Emacs is free software: you can redistribute it and/or modify
10 ;; it under the terms of the GNU General Public License as published by
11 ;; the Free Software Foundation, either version 3 of the License, or
12 ;; (at your option) any later version.
14 ;; GNU Emacs is distributed in the hope that it will be useful,
15 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
16 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 ;; GNU General Public License for more details.
19 ;; You should have received a copy of the GNU General Public License
20 ;; along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>.
22 ;;; Commentary:
23 ;;
24 ;; The Semantic Preprocessor works with semantic-lex to provide a phase
25 ;; during lexical analysis to do the work of a pre-processor.
26 ;;
27 ;; A pre-processor identifies lexical syntax mixed in with another language
28 ;; and replaces some keyword tokens with streams of alternate tokens.
29 ;;
30 ;; If you use SPP in your language, be sure to specify this in your
31 ;; semantic language setup function:
32 ;;
33 ;; (add-hook 'semantic-lex-reset-functions 'semantic-lex-spp-reset-hook nil t)
34 ;;
35 ;;
36 ;; Special Lexical Tokens:
37 ;;
38 ;; There are several special lexical tokens that are used by the
39 ;; Semantic PreProcessor lexer. They are:
40 ;;
41 ;; Declarations:
42 ;; spp-macro-def - A definition of a lexical macro.
43 ;; spp-macro-undef - A removal of a definition of a lexical macro.
44 ;; spp-system-include - A system level include file
45 ;; spp-include - An include file
46 ;; spp-concat - A lexical token representing textual concatenation
47 ;; of symbol parts.
48 ;;
49 ;; Operational tokens:
50 ;; spp-arg-list - Represents an argument list to a macro.
51 ;; spp-symbol-merge - A request for multiple symbols to be textually merged.
52 ;;
53 ;;; TODO:
54 ;;
55 ;; Use `semantic-push-parser-warning' for situations where there are likely
56 ;; macros that are undefined unexpectedly, or other problem.
57 ;;
58 ;; TODO:
59 ;;
60 ;; Try to handle the case of:
61 ;;
62 ;; #define NN namespace nn {
63 ;; #define NN_END }
64 ;;
65 ;; NN
66 ;; int mydecl() {}
67 ;; NN_END
68 ;;
75 ;;; Code:
77 "Table of macro keywords used by the Semantic Preprocessor.
78 These symbols will be used in addition to those in
83 "Table of macro keywords for this project.
84 These symbols will be used in addition to those in
89 "Table of macro keywords used during lexical analysis.
90 Macros are lexical symbols which are replaced by other lexical
91 tokens during lexical analysis. During analysis symbols can be
101 ;; The above is not buffer local. Some macro expansions need to be
102 ;; dumped into a secondary buffer for re-lexing.
104 ;;; NON-RECURSIVE MACRO STACK
105 ;; C Pre-processor does not allow recursive macros. Here are some utils
106 ;; for managing the symbol stack of where we've been.
109 "With the macro NAME currently being expanded, execute BODY.
110 Pushes NAME into the macro stack. The above stack is checked
111 by `semantic-lex-spp-symbol' to not return true for any symbol
112 currently being expanded."
121 'edebug-setup-hook
126 )
128 ))
130 ;;; MACRO TABLE UTILS
131 ;;
132 ;; The dynamic macro table is a buffer local variable that is modified
133 ;; during the analysis. OBARRAYs are used, so the language must
134 ;; have symbols that are compatible with Emacs Lisp symbols.
135 ;;
137 "Return spp symbol with NAME or nil if not found.
138 The search priority is:
139 1. DYNAMIC symbols
140 2. PROJECT specified symbols.
141 3. SYSTEM specified symbols."
143 ;; Only strings...
145 ;; Make sure we don't recurse.
147 ;; Do the check of the various tables.
149 ;; DYNAMIC
152 ;; PROJECT
155 ;; SYSTEM
158 ;; ...
159 )))
162 "Return non-nil if a keyword with NAME exists in any keyword table."
164 t))
167 "Return the dynamic macro map for the current buffer."
173 "Return the dynamic macro map for the current buffer."
179 "Return non-nil if VALUE is valid."
190 "Enable debugging for symbol SYM.
191 Disable debugging by entering nothing."
198 "Validate the NAME and VALUE of a macro before it is set."
199 ; `(progn
200 ; (when (not (semantic-lex-spp-value-valid-p ,value))
201 ; (error "Symbol \"%s\" with bogus value %S" ,name ,value))
202 ; (when (and semantic-lex-spp-debug-symbol
203 ; (string= semantic-lex-spp-debug-symbol name))
204 ; (debug))
205 ; )
206 nil
207 )
210 "Set value of spp symbol with NAME to VALUE and return VALUE.
211 If optional OBARRAY-IN is non-nil, then use that obarray instead of
212 the dynamic map."
217 value))
220 "Remove the spp symbol with NAME.
221 If optional OBARRAY is non-nil, then use that obarray instead of
222 the dynamic map."
227 "Push macro NAME with VALUE into the map.
228 Reverse with `semantic-lex-spp-symbol-pop'."
235 )
237 ;; Make sure there is a stack
239 ;; If there is a value to push, then push it.
241 )
242 ;; Set our new value here.
244 ))
247 "Pop macro NAME from the stackmap into the orig map.
248 Reverse with `semantic-lex-spp-symbol-pop'."
254 )
257 ;; Nothing to pop, remove it.
259 ;; If there is a value to pop, then add it to the map.
262 )))
265 "Return replacement stream of macro with NAME."
271 "Convert spp macro list SPECS into an obarray and return it.
272 SPECS must be a list of (NAME . REPLACEMENT) elements, where:
274 NAME is the name of the spp macro symbol to define.
275 REPLACEMENT a string that would be substituted in for NAME."
277 ;; Create the symbol hash table
279 spec)
280 ;; fill it with stuff
287 semantic-lex-spp-macro-symbol-obarray))
288 semantic-lex-spp-macro-symbol-obarray))
291 "Return a list of spp macros and values.
292 The return list is meant to be saved in a semanticdb table."
299 macros)))
300 semantic-lex-spp-dynamic-macro-symbol-obarray))
301 macros))
304 "Return a list of spp macros as Lisp symbols.
305 The value of each symbol is the replacement stream."
311 semantic-lex-spp-macro-symbol-obarray))
316 semantic-lex-spp-project-macro-symbol-obarray))
321 semantic-lex-spp-dynamic-macro-symbol-obarray))
322 macros))
325 "Set the dynamic symbol table to NEW-ENTRIES.
326 For use with semanticdb restoration of state."
328 ;; Default obarray for below is the dynamic map.
332 "Reset anything needed by SPP for parsing.
333 In this case, reset the dynamic macro symbol table if
334 START is (point-min).
335 END is not used."
338 semantic-lex-spp-dynamic-macro-symbol-obarray-stack nil
339 ;; This shouldn't not be nil, but reset just in case.
340 semantic-lex-spp-expanded-macro-stack nil)
341 ))
343 ;;; MACRO EXPANSION: Simple cases
344 ;;
345 ;; If a user fills in the table with simple strings, we can
346 ;; support that by converting them into tokens with the
347 ;; various analyzers that are available.
350 "Extract a regexp from an ANALYZER and use to match VALUE.
351 Return non-nil if it matches"
356 nil))))
359 ))
362 "Convert lexical macro contents VAL into a macro expansion stream.
363 These are for simple macro expansions that a user may have typed in directly.
364 As such, we need to analyze the input text, to figure out what kind of real
365 lexical token we should be inserting in its place.
367 Argument VAL is the value of some macro to be converted into a stream.
368 BEG and END are the token bounds of the macro to be expanded
369 that will somehow gain a much longer token stream.
370 ARGVALUES are values for any arg list, or nil."
372 ;; We perform a replacement. Technically, this should
373 ;; be a full lexical step over the "val" string, but take
374 ;; a guess that its just a keyword or existing symbol.
375 ;;
376 ;; Probably a really bad idea. See how it goes.
378 semantic-lex-symbol-or-keyword val)
381 beg end
382 val)))
384 ;; Ok, the rest of these are various types of syntax.
385 ;; Conveniences for users that type in their symbol table.
387 semantic-lex-punctuation val)
390 semantic-lex-number val)
393 semantic-lex-paren-or-list val)
396 semantic-lex-string val)
399 ))
401 ;;; MACRO EXPANSION : Lexical token replacement
402 ;;
403 ;; When substituting in a macro from a token stream of formatted
404 ;; semantic lex tokens, things can be much more complicated.
405 ;;
406 ;; Some macros have arguments that get set into the dynamic macro
407 ;; table during replacement.
408 ;;
409 ;; In general, the macro tokens are substituted into the regular
410 ;; token stream, but placed under the characters of the original
411 ;; macro symbol.
412 ;;
413 ;; Argument lists are saved as a lexical token at the beginning
414 ;; of a replacement value.
417 "Convert the token TOK into a string.
418 If TOK is made of multiple tokens, convert those to text. This
419 conversion is needed if a macro has a merge symbol in it that
420 combines the text of two previously distinct symbols. For
421 example, in c:
423 #define (a,b) a ## b;
425 If optional string BLOCKTOK matches the expanded value, then do not
426 continue processing recursively."
429 )
431 ;; Recursion prevention
433 blocktok)
434 ;; A complex symbol
438 )
439 ;; Now that we have a symbol,
442 ;; This is another lexical token.
446 ;; This is a list of tokens.
452 val
454 ;; If val is nil, that's probably wrong.
455 ;; Found a system header case where this was true.
457 ;; Debug weird stuff.
459 ))
461 txt)
463 ))
466 "If the macro value VAL has an argument list, return the arglist."
472 "Convert lexical macro contents VAL into a macro expansion stream.
473 Argument VAL is the value of some macro to be converted into a stream.
474 BEG and END are the token bounds of the macro to be expanded
475 that will somehow gain a much longer token stream.
476 ARGVALUES are values for any arg list, or nil.
477 See comments in code for information about how token streams are processed
478 and what valid VAL values are."
480 ;; A typical VAL value might be either a stream of tokens.
481 ;; Tokens saved into a macro stream always includes the text from the
482 ;; buffer, since the locations specified probably don't represent
483 ;; that text anymore, or even the same buffer.
484 ;;
485 ;; CASE 1: Simple token stream
486 ;;
487 ;; #define SUPER mysuper::
488 ;; ==>
489 ;;((symbol "mysuper" 480 . 487)
490 ;; (punctuation ":" 487 . 488)
491 ;; (punctuation ":" 488 . 489))
492 ;;
493 ;; CASE 2: Token stream with argument list
494 ;;
495 ;; #define INT_FCN(name) int name (int in)
496 ;; ==>
497 ;; ((spp-arg-list ("name") 558 . 564)
498 ;; (INT "int" 565 . 568)
499 ;; (symbol "name" 569 . 573)
500 ;; (semantic-list "(int in)" 574 . 582))
501 ;;
502 ;; In the second case, a macro with an argument list as the args as the
503 ;; first entry.
504 ;;
505 ;; CASE 3: Symbol text merge
506 ;;
507 ;; #define TMP(a) foo_ ## a
508 ;; ==>
509 ;; ((spp-arg-list ("a") 20 . 23)
510 ;; (spp-symbol-merge ((symbol "foo_" 24 . 28) (symbol "a" 32 . 33))
511 ;; 24 . 33))
512 ;;
513 ;; Usually in conjunction with a macro with an argument, merging symbol
514 ;; parts is a way of fabricating new symbols from pieces inside the macro.
515 ;; These macros use `spp-symbol-merge' tokens whose TEXT part is another
516 ;; token stream. This sub-stream ought to consist of only 2 SYMBOL pieces,
517 ;; though I suppose keywords might be ok. The end result of this example
518 ;; merge symbol would be (symbol "foo_A" 24 . 33) where A is the symbol
519 ;; passed in from the arg list "a".
520 ;;
521 ;; CASE 4: Nested token streams
522 ;;
523 ;; #define FOO(f) f
524 ;; #define BLA bla FOO(foo)
525 ;; ==>
526 ;; ((INT "int" 82 . 85)
527 ;; (symbol "FOO" 86 . 89)
528 ;; (semantic-list "(foo)" 89 . 94))
529 ;;
530 ;; Nested token FOO shows up in the table of macros, and gets replace
531 ;; inline. This is the same as case 2.
532 ;;
533 ;; CASE 5: Macros which open a scope without closing it
534 ;;
535 ;; #define __NAMESPACE_STD namespace std {
536 ;; #define __NAMESPACE_END }
537 ;; ==>
538 ;; ((NAMESPACE "namespace" 140 . 149)
539 ;; (symbol "std" 150 . 153)
540 ;; (open-paren "{" 154 . 155))
541 ;;
542 ;; Note that we get a single 'open-paren' instead of a
543 ;; 'semantic-list', which is because we use
544 ;; 'semantic-lex-spp-paren-or-list' instead of
545 ;; 'semantic-lex-paren-or-list' in our spp-lexer. To keep things
546 ;; reasonably simple, we assume that such an open scope will always
547 ;; be closed by another macro (see
548 ;; `semantic-lex-spp-find-closing-macro'). We generate a
549 ;; 'semantic-list' to this closing macro, and we leave an overlay
550 ;; which contains information how far we got into the macro's
551 ;; stream (since it might open several scopes).
560 ;; First, check if we were already here and left information
562 ;; Advance in the tokens as far as we got last time
567 ;; And push an open paren
572 ;; We reached the end of this macro, so delete overlay
575 ;; CASE 2: Dealing with the arg list.
577 ;; Skip the arg list.
581 ;; Push args into the replacement list.
589 )
591 ;; Set val-tmp after stripping arguments.
594 ;; CASE 1: Push everything else onto the list.
595 ;; Once the arg list is stripped off, CASE 2 is the same
596 ;; as CASE 1.
603 ;; Try to convert txt into a macro declaration. If it is
604 ;; not a macro, use nil.
606 ;; If our current token is a macro, then pull off the argument
607 ;; list.
611 )
612 ;; We need to peek at the next token when testing for
613 ;; used macros with arg lists.
615 )
618 ;; CASE 3: Merge symbols together.
623 ))
625 ;; CASE 2: Argument replacement. If a discovered symbol is in
626 ;; the active list of arguments, then we need to substitute
627 ;; in the new value.
631 )
636 ;; We used up these args. Pull from the stream.
638 )
641 ;; Don't recurse directly into this same fcn, because it is
642 ;; convenient to have plain string replacements too.
645 beg end AV))
646 ))
648 ;; This is a HACK for the C parser. The 'macros text
649 ;; property is some storage so that the parser can do
650 ;; some C specific text manipulations.
652 ;; Push our arg list onto the semantic list.
658 )
659 ;; CASE 5: Macro which opens a scope
661 ;; We assume that the scope will be closed by another macro.
662 ;; (Everything else would be a terrible idea anyway.)
668 ;; Generate a semantic-list which spans to the end of
669 ;; the closing macro
672 ;; The rest of the current macro's stream will be parsed
673 ;; next time.
675 ;; Store our current state were we are in the macro and
676 ;; the endpoint.
680 ;; Macro which closes a scope
681 ;; Just push the close paren, but also decrease depth
685 ;; CASE 1: Just another token in the stream.
687 ;; Nothing new.
690 )
691 )))
693 ;; CASE 2: The arg list we pushed onto the symbol table
694 ;; must now be removed.
697 ))
700 "Merge the tokens listed in TXT.
701 TXT might contain further 'spp-symbol-merge, which will
702 be merged recursively."
703 ;; We need to merge the tokens in the 'text segment together,
704 ;; and produce a single symbol from it.
710 ;; Call recursively for multiple merges, like
711 ;; #define FOO(a) foo##a##bar
717 txt
721 "Find next macro which closes a scope through a close-paren.
722 Returns position with the end of that macro."
726 ;; Build a regexp which search for all macros with a closing
727 ;; paren, and search for it.
735 stream nil)
744 "Return first overlay which has a 'semantic-spp property."
751 ;;; Macro Merging
752 ;;
753 ;; Used when token streams from different macros include each other.
754 ;; Merged macro streams perform in place replacements.
757 "Merge elements from the RAW-STREAM together.
758 Handle spp-concat symbol concatenation.
759 Handle Nested macro replacements.
760 Return the cooked stream."
762 ;; Merge the stream
765 ;; handle hashhash, by skipping it.
767 ;; Now merge the symbols.
772 'spp-symbol-merge
776 cooked-stream)
777 ))
780 )
782 )
785 )
787 ;;; MACRO EXPANSION
788 ;;
789 ;; There are two types of expansion.
790 ;;
791 ;; 1. Expansion using a value made up of lexical tokens.
792 ;; 2. User input replacement from a plain string.
795 "Convert lexical macro contents VAL into a macro expansion stream.
796 Argument VAL is the value of some macro to be converted into a stream.
797 BEG and END are the token bounds of the macro to be expanded
798 that will somehow gain a much longer token stream.
799 ARGVALUES are values for any arg list, or nil."
801 ;; If val is nil, then just skip it.
803 ;; If it is a token, then return that token rebuilt.
807 ;; Test for a token list.
811 ;; Test for miscellaneous strings.
814 ))
816 ;;; --------------------------------------------------------
817 ;;;
818 ;;; ANALYZERS:
819 ;;;
821 ;;; Symbol Is Macro
822 ;;
823 ;; An analyzer that will push tokens from a macro in place
824 ;; of the macro symbol.
825 ;;
827 "Do the lexical replacement for SYM with VAL.
828 Argument BEG and END specify the bounds of SYM in the buffer."
834 )
836 ;; Check for arguments.
844 ;; NOTE: This used to be (point-at-eol), but
845 ;; that was too close for multi-line arguments
846 ;; to a macro. Point max may be too far if there
847 ;; is a typo in the buffer.
848 ;;
849 ;; Look here for performance issues while a user is typing
850 ;; incomplete code.
856 ;; Use lex to split up the contents of the argument list.
858 ))
859 ))
861 ;; if we have something to sub in, then do it.
864 )
865 ))
868 "Non-nil means do replacements when finding keywords.
872 "Push lexical tokens for the symbol or keyword STR.
873 STR occurs in the current buffer between BEG and END."
876 ;;
877 ;; It is a macro. Prepare for a replacement.
885 semantic-lex-spp-expanded-macro-stack))
888 ;; Do direct replacements of single value macros of macros.
889 ;; This solves issues with a macro containing one symbol that
890 ;; is another macro, and get arg lists passed around.
897 )
901 ;; Prevent recursion
903 ;; This prevents a different kind of recursion.
905 )
909 ))
910 ;; Anything else.
912 ;; A regular keyword.
915 beg end))))
916 ))
919 "Like 'semantic-lex-symbol-or-keyword' plus preprocessor macro replacement."
924 sppov)
930 "Detect open parenthesis.
931 Contrary to `semantic-lex-paren-or-list', this will push a single
932 open-paren onto the stream if no closing paren can be found.
933 This is important for macros which open a scope which is closed
934 by another macro."
949 ;; This will throw an error if no closing paren can be found.
952 ;; If we have left the macro, this is the wrong closing
953 ;; paren, so error out as well.
959 ;; Only push a single open-paren.
964 ;;; ANALYZERS FOR NEW MACROS
965 ;;
966 ;; These utilities and analyzer declaration function are for
967 ;; creating an analyzer which produces new macros in the macro table.
968 ;;
969 ;; There are two analyzers. One for new macros, and one for removing
970 ;; a macro.
973 "If TOKEN is a semantic-list, turn it into an SPP ARG LIST."
977 ;; Convert TOKEN in place.
982 ))
985 "Lex up one token, and move to end of that token.
986 Don't go past MAX."
990 nil)
996 ))
999 "Lex up the contents of the arglist TOKEN.
1000 Parsing starts inside the parens, and ends at the end of TOKEN."
1007 ;; If the 2nd part of the token is a string, then we have
1008 ;; a token specifically extracted from a buffer. Possibly
1009 ;; a different buffer. This means we need to do something
1010 ;; nice to parse its contents.
1015 ;; This part is like the original
1017 ;; A cheat for going into the semantic list.
1021 ;; march 2011: This is too restrictive! For example "void"
1022 ;; can't get through. What elements was I trying to expunge
1023 ;; to put this in here in the first place? If I comment it
1024 ;; out, does anything new break?
1025 ;(when (memq (semantic-lex-token-class tok) '(symbol semantic-list))
1026 ;; It appears the commas need to be dumped. perhaps this is better,
1027 ;; but will it cause more problems later?
1037 "Lex the text string TEXT using the current buffer's state.
1038 Use this to parse text extracted from a macro as if it came from
1039 the current buffer. Since the lexer is designed to only work in
1040 a buffer, we need to create a new buffer, and populate it with rules
1041 and variable state from the current buffer."
1044 semantic-lex-spp-hack-depth)))
1051 semantic-lex-spp-project-macro-symbol-obarray
1052 semantic-lex-spp-dynamic-macro-symbol-obarray
1053 semantic-lex-spp-dynamic-macro-symbol-obarray-stack
1054 semantic-lex-spp-expanded-macro-stack
1055 ))
1056 )
1058 nil
1061 ;; Below is a painful hack to make sure everything is setup correctly.
1065 ;; Protect against user-hooks that throw errors.
1070 ;; Hack in mode-local
1073 ;; Call the major mode's setup function
1078 ;; CHEATER! The following 3 lines are from
1079 ;; `semantic-new-buffer-fcn', but we don't want to turn
1080 ;; on all the other annoying modes for this little task.
1086 ))
1088 ;; Second Cheat: copy key variables regarding macro state from the
1089 ;; the originating buffer we are parsing. We need to do this every time
1090 ;; since the state changes.
1104 ;;;; FIRST DRAFT
1105 ;; This is the fist version of semantic-lex-spp-stream-for-arglist
1106 ;; that worked pretty well. It doesn't work if the TOKEN was derived
1107 ;; from some other buffer, in which case it can get the wrong answer
1108 ;; or throw an error if the token location in the originating buffer is
1109 ;; larger than the current buffer.
1110 ;;(defun semantic-lex-spp-stream-for-arglist-orig (token)
1111 ;; "Lex up the contents of the arglist TOKEN.
1112 ;; Parsing starts inside the parens, and ends at the end of TOKEN."
1113 ;; (save-excursion
1114 ;; (let ((end (semantic-lex-token-end token))
1115 ;; (fresh-toks nil)
1116 ;; (toks nil))
1117 ;; (goto-char (semantic-lex-token-start token))
1118 ;; ;; A cheat for going into the semantic list.
1119 ;; (forward-char 1)
1120 ;; (setq fresh-toks (semantic-lex-spp-stream-for-macro (1- end)))
1121 ;; (dolist (tok fresh-toks)
1122 ;; (when (memq (semantic-lex-token-class tok) '(symbol semantic-list))
1123 ;; (setq toks (cons tok toks))))
1124 ;; (nreverse toks))
1125 ;; ))
1127 ;;;; USING SPLIT
1128 ;; This doesn't work, because some arguments passed into a macro
1129 ;; might contain non-simple symbol words, which this doesn't handle.
1130 ;;
1131 ;; Thus, you need a full lex to occur.
1132 ;; (defun semantic-lex-spp-stream-for-arglist-split (token)
1133 ;; "Lex up the contents of the arglist TOKEN.
1134 ;; Parsing starts inside the parens, and ends at the end of TOKEN."
1135 ;; (let* ((txt (semantic-lex-token-text token))
1136 ;; (split (split-string (substring txt 1 (1- (length txt)))
1137 ;; "(), " t))
1138 ;; ;; Hack for lexing.
1139 ;; (semantic-lex-spp-analyzer-push-tokens-for-symbol nil))
1140 ;; (dolist (S split)
1141 ;; (semantic-lex-spp-analyzer-push-tokens-for-symbol S 0 1))
1142 ;; (reverse semantic-lex-spp-analyzer-push-tokens-for-symbol)))
1146 "Lex up a stream of tokens for a #define statement.
1147 Parsing starts at the current point location.
1148 EOS is the end of the stream to lex for this macro."
1154 )
1159 str)
1160 stream)
1161 ;; Nothing to push.
1162 nil)))
1164 ;; Fix the order
1166 ))
1170 "Define a lexical analyzer for defining new MACROS.
1171 NAME is the name of the analyzer.
1172 DOC is the documentation for the analyzer.
1173 REGEXP is a regular expression for the analyzer to match.
1174 See `define-lex-regex-analyzer' for more on regexp.
1175 TOKIDX is an index into REGEXP for which a new lexical token
1176 of type `spp-macro-def' is to be created.
1177 VALFORM are forms that return the value to be saved for this macro, or nil.
1178 When implementing a macro, you can use `semantic-lex-spp-stream-for-macro'
1179 to convert text into a lexical stream for storage in the macro."
1186 ,doc
1187 ,regexp
1199 ;; Preserve setting of the end point from the calling macro.
1203 ))))
1206 "Undefine a lexical analyzer for defining new MACROS.
1207 NAME is the name of the analyzer.
1208 DOC is the documentation for the analyzer.
1209 REGEXP is a regular expression for the analyzer to match.
1210 See `define-lex-regex-analyzer' for more on regexp.
1211 TOKIDX is an index into REGEXP for which a new lexical token
1212 of type `spp-macro-undef' is to be created."
1216 ,doc
1217 ,regexp
1220 )
1226 ))))
1228 ;;; INCLUDES
1229 ;;
1230 ;; These analyzers help a language define how include files
1231 ;; are identified. These are ONLY for languages that perform
1232 ;; an actual textual inclusion, and not for imports.
1233 ;;
1234 ;; This section is supposed to allow the macros from the headers to be
1235 ;; added to the local dynamic macro table, but that hasn't been
1236 ;; written yet.
1237 ;;
1239 "*Non-nil means to pre-parse headers as we go.
1240 For languages that use the Semantic pre-processor, this can
1241 improve the accuracy of parsed files where include files
1242 can change the state of what's parsed in the current file.
1244 Note: Note implemented yet"
1249 "Extract and merge any macros from the header with NAME.
1250 Finds the header file belonging to NAME, gets the macros
1251 from that file, and then merge the macros with our current
1252 symbol table."
1254 ;; @todo - do this someday, ok?
1255 ))
1259 "Define a lexical analyzer for defining a new INCLUDE lexical token.
1260 Macros defined in the found include will be added to our running table
1261 at the time the include statement is found.
1262 NAME is the name of the analyzer.
1263 DOC is the documentation for the analyzer.
1264 REGEXP is a regular expression for the analyzer to match.
1265 See `define-lex-regex-analyzer' for more on regexp.
1266 TOKIDX is an index into REGEXP for which a new lexical token
1267 of type `spp-macro-include' is to be created.
1268 VALFORM are forms that return the name of the thing being included, and the
1269 type of include. The return value should be of the form:
1270 (NAME . TYPE)
1271 where NAME is the name of the include, and TYPE is the type of the include,
1272 where a valid symbol is 'system, or nil."
1279 ,doc
1280 ,regexp
1286 ;;(message "(car ,val) -> %S" (car ,val))
1290 'spp-system-include
1294 ;; Preserve setting of the end point from the calling macro.
1298 ))))
1300 ;;; EIEIO USAGE
1301 ;;
1302 ;; Semanticdb can save off macro tables for quick lookup later.
1303 ;;
1304 ;; These routines are for saving macro lists into an EIEIO persistent
1305 ;; file.
1309 ;;;###autoload
1311 "Write out the VALUE of a slot for EIEIO.
1312 The VALUE is a spp lexical table."
1316 ;(princ value)
1348 ;;; MACRO TABLE DEBUG
1349 ;;
1351 "Describe the current list of spp macros for BUFFER.
1352 If BUFFER is not provided, use the current buffer."
1369 ))))
1371 ;;; EDEBUG Handlers
1372 ;;
1374 'edebug-setup-hook
1379 )
1383 )
1390 ;; Local variables:
1391 ;; generated-autoload-file: "loaddefs.el"
1392 ;; generated-autoload-load-name: "semantic/lex-spp"
1393 ;; End:
1395 ;;; semantic/lex-spp.el ends here