;ELC ;;; Compiled ;;; in Emacs version 25.3.1 ;;; with all optimizations. ;;; This file uses dynamic docstrings, first added in Emacs 19.29. ;;; This file does not contain utf-8 non-ASCII characters, ;;; and so can be loaded in Emacs versions earlier than 23. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; #@51 The current character in the buffer being parsed. (defvar jsons-curr-token 0 (#$ . 410)) #@60 Hashes each open buffer to the parse tree for that buffer. (defvar jsons-parsed (make-hash-table :test 'equal) (#$ . 505)) #@88 Hashes each open buffer to the ranges in the buffer for each of the parse trees nodes. (defvar jsons-parsed-regions (make-hash-table :test 'equal) (#$ . 634)) #@40 The node ranges in the current buffer. (defvar jsons-curr-region nil (#$ . 799)) #@28 Default jsons path printer (defvar jsons-path-printer 'jsons-print-path-python (#$ . 886)) (add-hook 'kill-buffer-hook 'jsons-remove-buffer) #@38 Return the next token in the stream. (defalias 'jsons-consume-token #[0 "b\210\301\302\303\304\305\306\306\306\307\260 \310d\311#\203(\312\225\313\312\224\312\225\"\202+\314\315!\207" [jsons-curr-token "\\([][\\{\\}:,]\\)" "\\(\"\\(\\([^\"\\\\ \n]\\)*\\([ \n]\\)*\\|\\(\\(\\\\\\\\\\)*\\\\\\(\\([^ \n]\\|\\(u[0-9A-Fa-f]\\{4\\}\\)\\)\\)\\)\\)+\"\\)" "\\(-?\\(0\\|\\([1-9][[:digit:]]*\\)\\)\\(\\.[[:digit:]]+\\)?\\([eE][-+]?[[:digit:]]+\\)?\\)" "\\(true\\|false\\|null\\)" "\\(" "\\|" "\\)" re-search-forward "Not nil" 0 buffer-substring-no-properties message "Reached EOF. Possibly invalid JSON."] 13 (#$ . 1033)]) #@159 Create a new json array object that contain the identifier "json-array". a list of the elements contained in the array, and the PATH to the array. (fn PATH) (defalias 'jsons-array #[257 "\300 \301\302\303\304\230\204/\305\230\204(\306#T\262\211B\262\300 \262\210\202\300 \262\202\307!E\207" [jsons-consume-token "json-array" nil 0 "]" "," jsons-value reverse] 9 (#$ . 1670)]) #@88 Given a TOKEN and PATH, this function return the PATH to the literal. (fn TOKEN PATH) (defalias 'jsons-literal #[514 "\301\224\301\225\302EC\"\303DF\207" [jsons-curr-region 0 append "json-literal"] 9 (#$ . 2075)]) #@147 This function is called when a member in a JSON object needs to be parsed. Given the current TOKEN, and the PATH to this member. (fn TOKEN PATH) (defalias 'jsons-member #[514 "\301\302\224\302\225\303D\262\304 \305\230\204\306\307!\210\310\304 B\301#\311D\"D\262\311\312\234EC\"\262\207" [jsons-curr-region nil 0 "json-member" jsons-consume-token ":" error "Encountered token other than : in jsons-member" jsons-value append 2] 12 (#$ . 2306)]) #@209 This function will return a json-number given by the current TOKEN. PATH points to the path to this number. A json-number is defined as per the num_regex in the `jsons-get-tokens' function. (fn TOKEN PATH) (defalias 'jsons-number #[514 "\301\302\224\302\225EC\"\303E\207" [jsons-curr-region append 0 "json-number"] 6 (#$ . 2780)]) #@120 This function is called when a { is encountered while parsing. PATH is the path in the tree to this object. (fn PATH) (defalias 'jsons-object #[257 "\300 \301\302\303\"\304E\305\230\2047\306\230\2040\307\"\310\311\234\312\234\312\234\312\234#\210\300 \262\210\202\n\300 \262\202\n\207" [jsons-consume-token make-hash-table :test equal "json-object" "}" "," jsons-member puthash 0 1] 10 (#$ . 3125)]) #@170 This function is called when a string is encountered while parsing. The TOKEN is the current token being examined. The PATH is the path to this string. (fn TOKEN PATH) (defalias 'jsons-string #[514 "\301\224\301\225\302EC\"\303DF\207" [jsons-curr-region 0 append "json-string"] 9 (#$ . 3548)]) #@396 A value, which is either an object, array, string, number, or literal. The is-array variable is nil if inside an array, or the index in the array that it occupies. TOKEN is the current token being parsed. PATH is the path to this value. ARRAY-INDEX is non-nil if the value is contained within an array, and points to the index of this value in the containing array. (fn TOKEN PATH ARRAY-INDEX) (defalias 'jsons-value #[771 "\211\203G\300!\203\301\302B\"\303\224\303\225DE\207\304\230\203$\305B!\207\306\230\2030\307B!\207\303\310O\311\230\203@\312B\"\207\313B\"\207\300!\203Z\301\302\"\303\224\303\225DF\207\304\230\203d\305!\207\306\230\203n\307!\207\303\310O\311\230\203|\312\"\207\313\"\207" [jsons-is-number "json-value" jsons-number 0 "{" jsons-object "[" jsons-array 1 "\"" jsons-string jsons-literal] 8 (#$ . 3859)]) #@96 Function to check whether we can grab the json path from the cursor position in the json file. (defalias 'jsons-get-path #[0 "\303\304\305p\"\305p\n\"\204\306 \210 GW\203; \234\211\303\234\307\234`V\2032`W\2032\310\234\262\266T\262\202\207" [jsons-parsed-regions jsons-curr-region jsons-parsed 0 nil gethash jsons-parse 1 2] 7 (#$ . 4730)]) #@59 Test to see whether STR is a valid JSON number. (fn STR) (defalias 'jsons-is-number #[257 "\300\225\210\301 \302\300\303\304\305!\306\"\307$\216\310\311\"\205\300\225\210\312)\207" [0 match-data make-byte-code "\301\300\302\"\207" vconcat vector [set-match-data evaporate] 3 string-match "^\\(-?\\(0\\|\\([1-9][[:digit:]]*\\)\\)\\(\\.[[:digit:]]+\\)?\\([eE][-+]?[[:digit:]]+\\)?\\)$" t] 8 (#$ . 5096)]) #@77 Parse the file given in file, return a list of nodes representing the file. (defalias 'jsons-parse #[0 "\212\304\305\306p\n\"\2049\307 \305\310\230\203\311\305!\262\202(\312\230\203(\313\305!\262\314p\n#\210\314p #\210\262\202=\306p\n\")\207" [jsons-curr-token jsons-curr-region jsons-parsed jsons-parsed-regions 0 nil gethash jsons-consume-token "{" jsons-object "[" jsons-array puthash] 6 (#$ . 5510)]) #@177 Prints the given NODE to the BUFFER specified in buffer argument. TODO: Remove extra comma printed after lists of object members, and lists of array members. (fn NODE BUFFER) (defalias 'jsons-print-to-buffer #[514 "\300\234\211\301\230\203(\302\303\"\210\304\305\306\307\310\311!\312\"\313\314%\315\234\"\210\302\316\"\202\245\211\317\230\2037\302\315\234\"\202\245\211\320\230\203R\302\315\234\"\210\302\321\"\210\322\323\234\"\202\245\211\324\230\203a\302\315\234\"\202\245\211\325\230\203\206\302\326\"\210\327\305\330\331\310\311!\332\"\333\334%\315\234\"\210\302\335\"\202\245\211\336\230\203\225\302\315\234\"\202\245\211\337\230\203\244\322\315\234\"\202\245\340\207" [0 "json-array" jsons-put-string "[" mapc make-byte-code 257 "\301\300\"\210\302\300\303\"\207" vconcat vector [jsons-print-to-buffer jsons-put-string ","] 4 "\n\n(fn X)" 1 "]" "json-literal" "json-member" ": " jsons-print-to-buffer 2 "json-number" "json-object" "{" maphash 514 "\301\300\"\210\301\300\302\"\210\303\300\"\210\301\300\304\"\207" [jsons-put-string ":" jsons-print-to-buffer ","] 5 "\n\n(fn KEY VALUE)" "}" "json-string" "json-value" nil] 10 (#$ . 5937)]) #@80 Print the jq path to the JSON value under point, and save it in the kill ring. (defalias 'jsons-print-path-jq #[0 "\300 \301\302\303\304!\262GW\203T\234\247\203,\305\306\234!\307R\262T\262\202?\234\262\310GSOP\262T\262\234\203\n\234\247\204\n\302P\262\202\n\311!\210\312!\207" [jsons-get-path 0 "." nil reverse "[" number-to-string "]" 1 kill-new princ] 9 (#$ . 7131)]) #@84 Print the python path to the JSON value under point, and save it in the kill ring. (defalias 'jsons-print-path-python #[0 "\300 \301\302\303!\262GW\2039\234\247\203)\211\304\305\234!\306R\262T\262\202 \211\304\234\306R\262T\262\202 \307!\210\310!\207" [jsons-get-path 0 "" reverse "[" number-to-string "]" kill-new princ] 8 (#$ . 7544)]) #@77 Print the path to the JSON value under point, and save it in the kill ring. (defalias 'jsons-print-path #[0 " \207" [jsons-path-printer] 1 (#$ . 7910) nil]) #@70 Append STR to the BUFFER specified in the argument. (fn BUFFER STR) (defalias 'jsons-put-string #[514 "r\300!q\210\301\302\"c)\207" [get-buffer-create prin1-to-string t] 5 (#$ . 8074)]) #@72 Used to clean up the token regions, and parse tree used by the parser. (defalias 'jsons-remove-buffer #[0 "\302p\"\210\302p \"\207" [jsons-parsed jsons-parsed-regions remhash] 3 (#$ . 8269)]) (provide 'json-snatcher)