ikan Uploader :
Directory : /usr/share/emacs/25.2/lisp/
Upload File : |
| Current File : //usr/share/emacs/25.2/lisp/json.elc |
;ELC
;;; Compiled
;;; in Emacs version 25.2.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.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(require 'map)
#@243 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. Ordering
is maintained for `alist' and `plist', but not for `hash-table'.
(defvar json-object-type 'alist (#$ . 426))
#@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 (#$ . 719))
#@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 (#$ . 921))
#@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 (#$ . 1498))
#@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 (#$ . 1789))
#@53 Value to use as an element separator when encoding.
(defvar json-encoding-separator "," (#$ . 2070))
#@101 The default indentation level for encoding.
Used only when `json-encoding-pretty-print' is non-nil.
(defvar json-encoding-default-indentation " " (#$ . 2178))
#@133 Internally used to keep track of the current indentation level of encoding.
Used only when `json-encoding-pretty-print' is non-nil.
(defvar json--encoding-current-indentation "\n" (#$ . 2345))
#@70 If non-nil, then the output of `json-encode' will be pretty-printed.
(defvar json-encoding-pretty-print nil (#$ . 2544))
#@81 If non-nil, ] and } closings will be formatted lisp-style,
without indentation.
(defvar json-encoding-lisp-style-closings nil (#$ . 2671))
#@267 Sorting predicate for JSON object keys during encoding.
If nil, no sorting is performed. Else, JSON object keys are
ordered by the specified sort predicate during encoding. For
instance, setting this to `string<' will have JSON object keys
ordered alphabetically.
(defvar json-encoding-object-sort-predicate nil (#$ . 2817))
#@207 Function called (if non-nil) by `json-read-array' and
`json-read-object' right before reading a JSON array or object,
respectively. The function is called with one argument, which is
the current JSON key.
(defvar json-pre-element-read-function nil (#$ . 3151))
#@132 Function called (if non-nil) by `json-read-array' and
`json-read-object' right after reading a JSON array or object,
respectively.
(defvar json-post-element-read-function nil (#$ . 3420))
#@30 Join STRINGS with SEPARATOR.
(defalias 'json-join #[(strings separator) "\302\303 #\207" [strings separator mapconcat identity] 4 (#$ . 3614)])
#@60 Non-null if and only if LIST is an alist with simple keys.
(defalias 'json-alist-p #[(list) ":\203 @:\203 @@:\204 A\202 \301\211\202 ?\207" [list not-alist] 2 (#$ . 3765)])
#@60 Non-null if and only if LIST is a plist with keyword keys.
(defalias 'json-plist-p #[(list) ":\203 \301@!\203 A:\203 AA\202 \302\211\202 ?\207" [list keywordp not-plist] 3 (#$ . 3955)])
#@104 Return a copy of PLIST in reverse order.
Unlike `reverse', this keeps the property-value pairs intact.
(defalias 'json--plist-reverse #[(plist) "\304 \203 \211A\242 \211A\242\nB B*\202 )\207" [res plist val prop nil] 3 (#$ . 4159)])
#@55 Return an alist of the property-value pairs in PLIST.
(defalias 'json--plist-to-alist #[(plist) "\304 \203 \211A\242 \211A\242\211\nBB*\202 \237)\207" [res plist val prop nil] 4 (#$ . 4411)])
(defalias 'json--with-indentation '(macro . #[(body) "\301\302E\207" [body let ((json--encoding-current-indentation (if json-encoding-pretty-print (concat json--encoding-current-indentation json-encoding-default-indentation) "")))] 3]))
#@39 Skip past the following N characters.
(defalias 'json-advance #[(&optional n) "u\207" [n] 1 (#$ . 4858)])
(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 (#$ . 5035)])
(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 json-end-of-file nil] 4 (#$ . 5218)])
(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 (#$ . 5502)])
(byte-code "\300\301\302\"\210\300\303\304\301#\210\300\305\306\301#\210\300\307\310\301#\210\300\311\312\301#\210\300\313\314\301#\210\300\315\316\301#\210\300\317\320\301#\210\300\321\322\323#\207" [define-error json-error "Unknown JSON error" json-readtable-error "JSON readtable error" json-unknown-keyword "Unrecognized keyword" json-number-format "Invalid number format" json-string-escape "Bad Unicode escape" json-string-format "Bad string format" json-key-format "Bad JSON object key" json-object-format "Bad JSON object" json-end-of-file "End of file while parsing JSON" (end-of-file json-error)] 4)
#@109 Used internally by `json-path-to-position' to keep track of
the path during recursive calls to `json-read'.
(defvar json--path nil (#$ . 6241))
#@86 Record the KEY to the current JSON path.
Used internally by `json-path-to-position'.
(defalias 'json--record-path #[(key) "`B B\211\207" [key json--path] 2 (#$ . 6391)])
#@102 Check if the last parsed JSON structure passed POSITION.
Used internally by `json-path-to-position'.
(defalias 'json--check-position #[(position) "@@\303 \n`T#\203 \304\305\306\307\310\"\237\311 \312`\257\"\210)\211A\242\207" [json--path start position < throw :json-path :path mapcar cdr :match-start :match-end] 8 (#$ . 6570)])
#@687 Return the path to the JSON element at POSITION.
When STRING is provided, return the path to the position in the
string, else to the position in the current buffer.
The return value is a property list with the following
properties:
:path -- A list of strings and numbers forming the path to
the JSON element at the given position. Strings
denote object names, while numbers denote array
indexes.
:match-start -- Position where the matched JSON element begins.
:match-end -- Position where the matched JSON element ends.
This can for instance be useful to determine the path to a JSON
element in a deeply nested structure.
(defalias 'json-path-to-position #[(position &optional string) "\212\204 eb\210\306\307\310\311 \" \3122\" \203 \313!\202! \314 0 \315
\316\"\205+
-\207" [string json--path json-pre-element-read-function position json-post-element-read-function path nil json--record-path apply-partially json--check-position :json-path json-read-from-string json-read plist-get :path] 3 (#$ . 6914)])
#@24 List of JSON keywords.
(defvar json-keywords '("true" "false" "null") (#$ . 7999))
#@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\312\313!\210\314\315!)C\"\210\316\230\203- \317\207\320\230\2035 \n\207\321\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\306\307!\210\310\311!)C\"\210\312\211u)\207" [char n char-equal :json-eof signal json-unknown-keyword backward-word-strictly 1 thing-at-point word nil] 5] looking-at "\\(\\s-\\|[],}]\\|$\\)" backward-word-strictly 1 thing-at-point word "true" t "false" "null"] 4 (#$ . 8088)])
#@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 (#$ . 8776)])
#@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 (#$ . 8987)])
#@41 Return a JSON representation of NUMBER.
(defalias 'json-encode-number #[(number) "\301\302\"\207" [number format "%s"] 3 (#$ . 9695)])
#@70 Characters which are escaped in JSON, with their elisp counterparts.
(defvar json-special-chars '((34 . 34) (92 . 92) (98 . 8) (102 . 12) (110 . 10) (114 . 13) (116 . 9)) (#$ . 9837))
#@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\202Z \311=\204= \202Z \312\313!\203U \314\315! \316\211u)\210\317\f\320\")\202Z \307\321`C\"*\207" [n char json-special-chars special hex nil :json-eof signal json-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 string-to-number 16 json-string-escape] 4 (#$ . 10027)])
#@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 json-end-of-file apply string ""] 4 (#$ . 10549)])
#@41 Return a JSON representation of STRING.
(defalias 'json-encode-string #[(string) "G\306\307\211 \310\311 #\211\203A H \312
\" O\nB\2033 \300\313@\"\2027 \314\315
\"\nB T*\202 \fO\nB\316\nB\317\320\316\n\237#,\207" [string mb res start l c 0 nil string-match "[\"\\[:cntrl:]]" rassq 92 format "\\u%04x" "\"" apply concat json-special-chars special] 4 (#$ . 11091)])
#@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 (#$ . 11489)])
#@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 (#$ . 11802)])
#@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 (#$ . 12072)])
#@32 Read the JSON object at point.
(defalias 'json-read-object #[nil "\306\211u)\210\307 \210\310 \306\211\311`f\211 \206 \312)\313\"\204\250 \307 \210\314 \307 \210\311`f\211 \2061 \312)\315\"\203@ \306\211u)\210\202O \316\317\320`f\211 \206K \312)D\"\210\307 \210
\203Z
\n!\210\321 \203f \210\322 \n #\307 \210\311`f\211 \206x \312)\313\"\204 \311`f\211 \206\207 \312)\323\"\203\226 \306\211u)\210\202 \316\317\324`f\211 \206\241 \312)D\"\210\202 \306\211u)\210\325=\203\272 \237\202\310 \326=\203\307 \327 !\202\310 +\207" [n value key elements char json-pre-element-read-function 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 "," alist plist json--plist-reverse json-post-element-read-function json-object-type] 6 (#$ . 12739)])
#@45 Return a JSON representation of HASH-TABLE.
(defalias 'json-encode-hash-table #[(hash-table) "\203 \306\307 \310\"!\207\311\312\313\314 \203 \f
P\202 \315 \316\317 \"\210)\n)\" \2030 \2034 \315\2025 \f#\207" [json-encoding-object-sort-predicate hash-table r json-encoding-pretty-print json--encoding-current-indentation json-encoding-default-indentation json-encode-alist map-into list format "{%s%s}" json-join nil "" maphash #[(k v) "\305\203 \306\202\n \307 \310\n!\311 !$\fB\211\207" [json-encoding-pretty-print json--encoding-current-indentation k v r format "%s%s: %s" "%s%s:%s" json-encode-key json-encode] 6] json-encoding-separator json-encoding-lisp-style-closings] 6 (#$ . 13602)])
#@40 Return a JSON representation of ALIST.
(defalias 'json-encode-alist #[(alist) "\203 \306 \307\"\310\311\312\n\203 \fP\202 \313\314\315 \")
\"\n\203( \203, \313\202- #\207" [json-encoding-object-sort-predicate alist json-encoding-pretty-print json--encoding-current-indentation json-encoding-default-indentation json-encoding-separator sort #[(a b) " @\n@\"\207" [json-encoding-object-sort-predicate a b] 3] format "{%s%s}" json-join "" mapcar #[(cons) "\303\203 \304\202\n \305 \306\n@!\307\nA!$\207" [json-encoding-pretty-print json--encoding-current-indentation cons format "%s%s: %s" "%s%s:%s" json-encode-key json-encode] 6] json-encoding-lisp-style-closings] 6 (#$ . 14313)])
#@40 Return a JSON representation of PLIST.
(defalias 'json-encode-plist #[(plist) "\203\n \306\307 !!\207\310 \203 \f
P\202 \311 \203; \f\312 @! \203) \313\202* \314\315 A@!R\nB AA\211\204 )\316\317\n\237\" \203P \204P \f\202Q \311\320R)\207" [json-encoding-object-sort-predicate plist result json-encoding-pretty-print json--encoding-current-indentation json-encoding-default-indentation json-encode-alist json--plist-to-alist nil "" json-encode-key ": " ":" json-encode "{" json-join "}" json-encoding-separator json-encoding-lisp-style-closings] 6 (#$ . 15013)])
#@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 (#$ . 15594)])
#@31 Read the JSON array at point.
(defalias 'json-read-array #[nil "\306\211u)\210\307 \210\306\310`f\211\206 \311)\312\"\204e \307 \210 \203& G!\210\313 B\f\2032 \f \210\307 \210\310`f\211\206> \311)\312\"\204 \310`f\211\206M \311)\314\"\203\\ \306\211u)\210\202 \315\316\317C\"\210\202 \306\211u)\210\320
\237\")\207" [n elements char json-pre-element-read-function json-post-element-read-function json-array-type nil json-skip-whitespace char-equal :json-eof 93 json-read 44 signal json-error bleah apply] 4 (#$ . 15993)])
#@40 Return a JSON representation of ARRAY.
(defalias 'json-encode-array #[(array) "\2036 G\306V\2036 \203 \n P\202 \307\310\311\n\"\312\313\314 \"\310\315\f\n#\"P)\310\316
\2032 \307\2023 \n\"P\207\317\320\314 \f#\321Q\207" [json-encoding-pretty-print array json--encoding-current-indentation json-encoding-default-indentation json-encoding-separator json-encoding-lisp-style-closings 0 "" format "[%s" json-join mapcar json-encode "%s%s" "%s]" "[" mapconcat "]"] 7 (#$ . 16537)])
#@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) (#$ . 17026))
#@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 json-end-of-file nil] 4 (#$ . 17420)])
#@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*" #[nil "\301!\205 \302!\207" [#1# buffer-name kill-buffer] 2] json-read] 2 (#$ . 17807)])
#@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*" #[nil "\301!\205 \302!\207" [#1# buffer-name kill-buffer] 2] insert-file-contents json-read] 2 (#$ . 18110)])
#@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 (#$ . 18431)])
#@30 Pretty-print current buffer.
(defalias 'json-pretty-print-buffer #[nil "\300ed\"\207" [json-pretty-print] 3 (#$ . 18958) nil])
#@31 Pretty-print selected region.
(defalias 'json-pretty-print #[(begin end) "\306 \307\211\307 \310\216\311
!\210\312\313\314\" \315\316!!c\210+\312\211.\207" [most-positive-fixnum #1=#:--change-group-success-- undo-strong-limit undo-limit undo-outer-limit #2=#:--change-group-handle-- prepare-change-group nil #[nil "\203 \302 !\207\303 !\207" [#1# #2# accept-change-group cancel-change-group] 2] activate-change-group t alist delete-and-extract-region json-encode json-read-from-string begin end txt json-object-type json-encoding-pretty-print] 5 (#$ . 19091) "r"])
#@55 Pretty-print current buffer with object keys ordered.
(defalias 'json-pretty-print-buffer-ordered #[nil "\301\302 )\207" [json-encoding-object-sort-predicate string< json-pretty-print-buffer] 1 (#$ . 19682) nil])
#@51 Pretty-print the region with object keys ordered.
(defalias 'json-pretty-print-ordered #[(begin end) "\303\304 \n\")\207" [json-encoding-object-sort-predicate begin end string< json-pretty-print] 3 (#$ . 19902) "r"])
(provide 'json)
Kontol Shell Bypass