| Current Path : /usr/share/emacs/24.3/lisp/ |
Linux gator3171.hostgator.com 4.19.286-203.ELK.el7.x86_64 #1 SMP Wed Jun 14 04:33:55 CDT 2023 x86_64 |
| Current File : //usr/share/emacs/24.3/lisp/json.elc |
;ELC
;;; Compiled by mockbuild@buildfarm06-new.corp.cloudlinux.com on Fri Oct 11 10:06:24 2024
;;; from file /builddir/build/BUILD/emacs-24.3/lisp/json.el
;;; in Emacs version 24.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.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(byte-code "\300\301\302\"\210\300\303\304\"\207" [defalias json-encode-char0 encode-char json-decode-char0 decode-char] 3)
#@168 Type to convert JSON objects to.
Must be one of `alist', `plist', or `hash-table'. Consider let-binding
this around your call to `json-read' instead of `setq'ing it.
(defvar json-object-type 'alist (#$ . 672))
#@152 Type to convert JSON arrays to.
Must be one of `vector' or `list'. Consider let-binding this around
your call to `json-read' instead of `setq'ing it.
(defvar json-array-type 'vector (#$ . 890))
#@533 Type to convert JSON keys to.
Must be one of `string', `symbol', `keyword', or nil.
If nil, `json-read' will guess the type based on the value of
`json-object-type':
If `json-object-type' is: nil will be interpreted as:
`hash-table' `string'
`alist' `symbol'
`plist' `keyword'
Note that values other than `string' might behave strangely for
Sufficiently Weird keys. Consider let-binding this around your call to
`json-read' instead of `setq'ing it.
(defvar json-key-type nil (#$ . 1092))
#@241 Value to use when reading JSON `false'.
If this has the same value as `json-null', you might not be able to tell
the difference between `false' and `null'. Consider let-binding this
around your call to `json-read' instead of `setq'ing it.
(defvar json-false :json-false (#$ . 1670))
#@241 Value to use when reading JSON `null'.
If this has the same value as `json-false', you might not be able to
tell the difference between `false' and `null'. Consider let-binding
this around your call to `json-read' instead of `setq'ing it.
(defvar json-null nil (#$ . 1961))
#@30 Join STRINGS with SEPARATOR.
(defalias 'json-join #[(strings separator) "\302\303 #\207" [strings separator mapconcat identity] 4 (#$ . 2242)])
#@43 Non-null if and only if LIST is an alist.
(defalias 'json-alist-p #[(list) ":\203 @:\203 A\202 \301\211\202 ?\207" [list not-alist] 2 (#$ . 2393)])
#@42 Non-null if and only if LIST is a plist.
(defalias 'json-plist-p #[(list) ":\203! \302@!\203 A:\203 \211AA)\202 \303\211\202 ?\207" [list x keywordp not-plist] 3 (#$ . 2556)])
#@39 Skip past the following N characters.
(defalias 'json-advance #[(&optional n) "u\207" [n] 1 (#$ . 2749)])
(put 'json-advance 'byte-optimizer 'byte-compile-inline-expand)
#@32 Return the character at point.
(defalias 'json-peek #[nil "`f\211\206 \301)\207" [char :json-eof] 2 (#$ . 2926)])
(put 'json-peek 'byte-optimizer 'byte-compile-inline-expand)
#@52 Advance past the character at point, returning it.
(defalias 'json-pop #[nil "`f\211\206 \302)\211\302=\203 \303\304\305\"\202 \305\211u)\210)\207" [char n :json-eof signal end-of-file nil] 4 (#$ . 3109)])
(put 'json-pop 'byte-optimizer 'byte-compile-inline-expand)
#@36 Skip past the whitespace at point.
(defalias 'json-skip-whitespace #[nil "\300\301w\207" ["
\n\f " nil] 2 (#$ . 3388)])
(byte-code "\300\301\302\303#\210\300\301\304\305#\210\300\306\302\307#\210\300\306\304\310#\210\300\311\302\312#\210\300\311\304\313#\210\300\314\302\315#\210\300\314\304\316#\210\300\317\302\320#\210\300\317\304\321#\210\300\322\302\323#\210\300\322\304\324#\210\300\325\302\326#\210\300\325\304\327#\210\300\330\302\331#\210\300\330\304\332#\207" [put json-error error-message "Unknown JSON error" error-conditions (json-error error) json-readtable-error "JSON readtable error" (json-readtable-error json-error error) json-unknown-keyword "Unrecognized keyword" (json-unknown-keyword json-error error) json-number-format "Invalid number format" (json-number-format json-error error) json-string-escape "Bad Unicode escape" (json-string-escape json-error error) json-string-format "Bad string format" (json-string-format json-error error) json-key-format "Bad JSON object key" (json-key-format json-error error) json-object-format "Bad JSON object" (json-object-format json-error error)] 4)
#@24 List of JSON keywords.
(defvar json-keywords '("true" "false" "null") (#$ . 4509))
#@64 Read a JSON keyword at point.
KEYWORD is the keyword expected.
(defalias 'json-read-keyword #[(keyword) " \235\204\f \304\305C\"\210\306\307\"\210\310\311!\204$ \304\305\212\312v\210\313\314!)C\"\210\315\230\203, \316\207\317\230\2034 \n\207\320\230\205; \207" [keyword json-keywords json-false json-null signal json-unknown-keyword mapc #[(char) "\302`f\211\206\n \303)\"\204 \304\305\212\306v\210\307\310!)C\"\210\311\211u)\207" [char n char-equal :json-eof signal json-unknown-keyword -1 thing-at-point word nil] 5] looking-at "\\(\\s-\\|[],}]\\|$\\)" -1 thing-at-point word "true" t "false" "null"] 4 (#$ . 4598)])
#@33 Encode KEYWORD as a JSON value.
(defalias 'json-encode-keyword #[(keyword) "\303=\203 \304\207 =\203 \305\207\n=\205 \306\207" [keyword json-false json-null t "true" "false" "null"] 2 (#$ . 5234)])
#@192 Read the JSON number following point.
The optional SIGN argument is for internal use.
N.B.: Only numbers which can fit in Emacs Lisp's native number
representation will be parsed correctly.
(defalias 'json-read-number #[(&optional sign) "\304 \204\" \305`f\211\206 \306)\307\"\203\" \310\211u)\210\311\312![\202b \204A \305`f\211\206/ \306)\313\"\203A \310\211u)\210\311\312!\202b \314!\203] \315\224\204Q \316\224\203] \317\225b\210\320\321\317!!\202b \322\323`C\")\207" [number-regexp sign char n "\\([0-9]+\\)?\\(\\.[0-9]+\\)?\\([Ee][+-]?[0-9]+\\)?" char-equal :json-eof 45 nil json-read-number t 43 looking-at 1 2 0 string-to-number match-string signal json-number-format] 4 (#$ . 5445)])
#@41 Return a JSON representation of NUMBER.
(defalias 'json-encode-number #[(number) "\301\302\"\207" [number format "%s"] 3 (#$ . 6153)])
#@70 Characters which are escaped in JSON, with their elisp counterparts.
(defvar json-special-chars '((34 . 34) (92 . 92) (47 . 47) (98 . 8) (102 . 12) (110 . 10) (114 . 13) (116 . 9)) (#$ . 6295))
#@50 Read the JSON string escaped character at point.
(defalias 'json-read-escaped-char #[nil "\305\211u)\210`f\211\206 \306)\211\306=\203 \307\310\305\"\202$ \305\211u)\210 )\211\n\236\211\2033 A\202] \311=\204= \202] \312\313!\203X \314\315! \316\211u)\210\317\320\321\f\322\"\")\202] \307\323`C\"*\207" [n char json-special-chars special hex nil :json-eof signal end-of-file 117 looking-at "[0-9A-Fa-f][0-9A-Fa-f][0-9A-Fa-f][0-9A-Fa-f]" match-string 0 4 json-decode-char0 ucs string-to-number 16 json-string-escape] 6 (#$ . 6495)])
#@32 Read the JSON string at point.
(defalias 'json-read-string #[nil "\303`f\211\206 \304)\305\"\204 \306\307\310C\"\210\311\211u)\210\311`f\211\206$ \304)\303\305\"\204i \303\312\"\203: \313 \202Y `f\211\206B \304)\211\304=\203Q \306\314\311\"\202X \311\211u)\210)\nB`f\211\206d \304)\202' \311\211u)\210\n\203{ \315\316\n\237\"\202| \317*\207" [char n characters char-equal :json-eof 34 signal json-string-format "doesn't start with '\"'!" nil 92 json-read-escaped-char end-of-file apply string ""] 4 (#$ . 7043)])
#@31 Encode CHAR as a JSON string.
(defalias 'json-encode-char #[(char) "\303\304\"\305 \"@\211\203 \306\307\n\"\202- \310V\203) \311W\203) \306\312\"\202- \306\313\")\207" [char json-special-chars control-char json-encode-char0 ucs rassoc format "\\%c" 31 127 "%c" "\\u%04x"] 4 (#$ . 7579)])
#@41 Return a JSON representation of STRING.
(defalias 'json-encode-string #[(string) "\301\302\303\304\305#\"\207" [string format "\"%s\"" mapconcat json-encode-char ""] 6 (#$ . 7882)])
#@133 Return a JSON representation of OBJECT.
If the resulting JSON object isn't a valid JSON object key,
this signals `json-key-format'.
(defalias 'json-encode-key #[(object) "\302!\303 !;\204 \304\305C\"\210 )\207" [object encoded json-encode json-read-from-string signal json-key-format] 3 (#$ . 8072)])
#@111 Create a new Elisp object corresponding to a JSON object.
Please see the documentation of `json-object-type'.
(defalias 'json-new-object #[nil "\301=\203 \302\303\304\"\207\305\207" [json-object-type hash-table make-hash-table :test equal nil] 3 (#$ . 8384)])
#@228 Add a new KEY -> VALUE association to OBJECT.
Returns the updated object, which you should save, e.g.:
(setq obj (json-add-to-object obj "foo" "bar"))
Please see the documentation of `json-object-type' and `json-key-type'.
(defalias 'json-add-to-object #[(object key value) "\305=\203
\306\236A\202 \211\307=\203 \n\2020 \310=\203% \311\n!\2020 \312=\2050 \311\313\nP! \314=\203A \315\n \f#\210\f\202Z \316=\203O \n B\fB\202Z \317=\205Z \n \fBB)\207" [json-key-type json-object-type key value object nil ((hash-table . string) (alist . symbol) (plist . keyword)) string symbol intern keyword ":" hash-table puthash alist plist] 5 (#$ . 8653)])
#@32 Read the JSON object at point.
(defalias 'json-read-object #[nil "\305\211u)\210\306 \210\307 \305\211\310`f\211 \206 \311)\312\"\204\224 \306 \210\313 \306 \210\310`f\211 \2061 \311)\314\"\203@ \305\211u)\210\202O \315\316\317`f\211 \206K \311)D\"\210\320 \321 \n #\306 \210\310`f\211 \206d \311)\312\"\204 \310`f\211 \206s \311)\322\"\203\202 \305\211u)\210\202 \315\316\323`f\211 \206\215 \311)D\"\210\202 \305\211u)\210 +\207" [n value key elements char nil json-skip-whitespace json-new-object char-equal :json-eof 125 json-read-string 58 signal json-object-format ":" json-read json-add-to-object 44 ","] 6 (#$ . 9319)])
#@45 Return a JSON representation of HASH-TABLE.
(defalias 'json-encode-hash-table #[(hash-table) "\302\303\304\305\306\307 \"\210)\310\"\"\207" [r hash-table format "{%s}" json-join nil maphash #[(k v) "\303\304\305!\306 !#\nB\211\207" [k v r format "%s:%s" json-encode-key json-encode] 5] ", "] 6 (#$ . 9966)])
#@40 Return a JSON representation of ALIST.
(defalias 'json-encode-alist #[(alist) "\301\302\303\304\305\"\306\"\"\207" [alist format "{%s}" json-join mapcar #[(cons) "\301\302\303@!\304A!#\207" [cons format "%s:%s" json-encode-key json-encode] 5] ", "] 6 (#$ . 10284)])
#@40 Return a JSON representation of PLIST.
(defalias 'json-encode-plist #[(plist) "\303 \203\" \304 @!\305\306 \211A@)!QB \211AA)\211\204 \307\310\237\311\"\312Q)\207" [result plist x nil json-encode-key ":" json-encode "{" json-join ", " "}"] 5 (#$ . 10559)])
#@132 Return a JSON representation of LIST.
Tries to DWIM: simple lists become JSON arrays, while alists and plists
become JSON objects.
(defalias 'json-encode-list #[(list) "\204 \301\207\302!\203 \303!\207\304!\203 \305!\207<\203# \306!\207\307\310C\"\207" [list "null" json-alist-p json-encode-alist json-plist-p json-encode-plist json-encode-array signal json-error] 3 (#$ . 10831)])
#@31 Read the JSON array at point.
(defalias 'json-read-array #[nil "\304\211u)\210\305 \210\304\306`f\211\206 \307)\310\"\204R \311 B\305 \210\306`f\211\206+ \307)\310\"\204 \306`f\211\206: \307)\312\"\203I \304\211u)\210\202 \313\314\315C\"\210\202 \304\211u)\210\316 \237\")\207" [n elements char json-array-type nil json-skip-whitespace char-equal :json-eof 93 json-read 44 signal json-error bleah apply] 4 (#$ . 11230)])
#@40 Return a JSON representation of ARRAY.
(defalias 'json-encode-array #[(array) "\301\302\303\304#\305Q\207" [array "[" mapconcat json-encode ", " "]"] 5 (#$ . 11671)])
#@28 Readtable for JSON reader.
(defvar json-readtable (byte-code "\301\302\303\304\"\210)\207" [table ((116 json-read-keyword "true") (102 json-read-keyword "false") (110 json-read-keyword "null") (123 json-read-object) (91 json-read-array) (34 json-read-string)) mapc #[(char) "\302D B\211\207" [char table json-read-number] 2] (45 43 46 48 49 50 51 52 53 54 55 56 57)] 3) (#$ . 11845))
#@89 Parse and return the JSON object following point.
Advances point just past JSON object.
(defalias 'json-read #[nil "\303 \210`f\211\206 \304)\211\304=\2040 \236A\305\n@!\203( \306\n@\nA\"\202, \307\310\n\")\2024 \307\311\312\")\207" [char json-readtable record json-skip-whitespace :json-eof functionp apply signal json-readtable-error end-of-file nil] 4 (#$ . 12239)])
#@57 Read the JSON object contained in STRING and return it.
(defalias 'json-read-from-string #[(string) "\302\303!rq\210\304\216 c\210eb\210\305 +\207" [#1=#:temp-buffer string generate-new-buffer " *temp*" ((byte-code "\301!\203\n \302!\210\301\207" [#1# buffer-name kill-buffer] 2)) json-read] 2 (#$ . 12621)])
#@61 Read the first JSON object contained in FILE and return it.
(defalias 'json-read-file #[(file) "\302\303!rq\210\304\216\305 !\210eb\210\306 +\207" [#1=#:temp-buffer file generate-new-buffer " *temp*" ((byte-code "\301!\203\n \302!\210\301\207" [#1# buffer-name kill-buffer] 2)) insert-file-contents json-read] 2 (#$ . 12940)])
#@53 Return a JSON representation of OBJECT as a string.
(defalias 'json-encode #[(object) "\303 \nE>\203
\304!\207;\203 \305!\207\306!\203% \305\307!\310\311O!\2079\2030 \305\307!!\207\247\2039 \312!\207\313!\203C \314!\207\315!\203M \316!\207<\203V \317!\207\320\321C\"\207" [object json-null json-false t json-encode-keyword json-encode-string keywordp symbol-name 1 nil json-encode-number arrayp json-encode-array hash-table-p json-encode-hash-table json-encode-list signal json-error] 4 (#$ . 13277)])
(provide 'json)