WWWWWW

Current Directory: /usr/share/emacs/24.3/lisp
Viewing File: /usr/share/emacs/24.3/lisp/json.elc
;ELC
;;; Compiled by mockbuild@buildfarm01-new.corp.cloudlinux.com on Tue Nov 11 12:48:26 2025
;;; 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\211AA)\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\211u)\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\305C\"\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\211u)\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\211u)\210\311\312![\202b	\204A\305`f\211\206/\306)\313\"\203A\310\211u)\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\211u)\210`f\211\206\306)\211\306=\203\307\310\305\"\202$\305\211u)\210	)\211\n\236\211\2033A\202]	\311=\204=	\202]\312\313!\203X\314\315!\316\211u)\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\211u)\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\211u)\210)\nB`f\211\206d\304)\202'\311\211u)\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\305C\"\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\211u)\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\211u)\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\211u)\210\202\315\316\323`f\211\206\215\311)D\"\210\202\305\211u)\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@!\304A!#\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	\211A@)!QB	\211AA)\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\310C\"\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\211u)\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\211u)\210\202\313\314\315C\"\210\202\304\211u)\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!rq\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!rq\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!\2079\2030\305\307!!\207\247\2039\312!\207\313!\203C\314!\207\315!\203M\316!\207<\203V\317!\207\320\321C\"\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)
F1l3 Manager
