|
#! /usr/bin/env python
|
| import sys,os,subprocess |
| from stat import * |
#!/usr/bin/env bash
| |
| |
throw () {
echo "$*" >&2
exit 1
}
| |
| def throw () :
print(str(" ".join(sys.argv[1:])))
exit(1)
|
| |
BRIEF=0
| |
| BRIEF=0 |
LEAFONLY=0
| |
| LEAFONLY=0 |
PRUNE=0
| |
| PRUNE=0 |
| |
usage() {
echo
echo "Usage: JSON.sh [-b] [-l] [-p] [-h]"
echo
echo "-p - Prune empty. Exclude fields with empty values."
echo "-l - Leaf only. Only show leaf nodes, which stops data duplication."
echo "-b - Brief. Combines 'Leaf only' and 'Prune empty' options."
echo "-h - This help text."
echo
}
| |
| def usage () :
print()
print("Usage: JSON.sh [-b] [-l] [-p] [-h]")
print()
print("-p - Prune empty. Exclude fields with empty values.")
print("-l - Leaf only. Only show leaf nodes, which stops data duplication.")
print("-b - Brief. Combines 'Leaf only' and 'Prune empty' options.")
print("-h - This help text.")
print()
|
| |
parse_options() {
set -- "$@"
local ARGN=$#
while [ $ARGN -ne 0 ]
do
case $1 in
-h) usage
exit 0
;;
-b) BRIEF=1
LEAFONLY=1
PRUNE=1
;;
-l) LEAFONLY=1
;;
-p) PRUNE=1
;;
?*) echo "ERROR: Unknown option."
usage
exit 0
;;
esac
shift 1
ARGN=$((ARGN-1))
done
}
| |
| def parse_options () :
global BRIEF
global LEAFONLY
global PRUNE
_rc = subprocess.call(["set","--",str('"'+"\" \"".join(sys.argv[1:])+'"')])
ARGN=len(sys.argv)
while (ARGN != 0 ):
if ( sys.argv[1] == '-h'):
usage()
exit(0)
elif ( sys.argv[1] == '-b'):
BRIEF=1
LEAFONLY=1
PRUNE=1
elif ( sys.argv[1] == '-l'):
LEAFONLY=1
elif ( sys.argv[1] == '-p'):
PRUNE=1
elif ( sys.argv[1] == '?*'):
print("ERROR: Unknown option.")
usage()
exit(0)
_rc = subprocess.call(["shift",1])
ARGN=(\"ARGN-1\")
|
| |
awk_egrep () {
local pattern_string=$1
gawk '{
while ($0) {
start=match($0, pattern);
token=substr($0, start, RLENGTH);
print token;
$0=substr($0, start+RLENGTH);
}
}' pattern=$pattern_string
}
| |
| def awk_egrep () :
global pattern
pattern_string=sys.argv[1]
_rc = subprocess.call(["gawk","{\n while (\$0) {\n start=match(\$0, pattern);\n token=substr(\$0, start, RLENGTH);\n print token;\n \$0=substr(\$0, start+RLENGTH);\n }\n }",pattern=pattern_string])
|
| |
tokenize () {
local GREP
local ESCAPE
local CHAR
if echo "test string" | egrep -ao --color=never "test" &>/dev/null
then
GREP='egrep -ao --color=never'
else
GREP='egrep -ao'
fi
if echo "test string" | egrep -o "test" &>/dev/null
then
ESCAPE='(\\[^u[:cntrl:]]|\\u[0-9a-fA-F]{4})'
CHAR='[^[:cntrl:]"\\]'
else
GREP=awk_egrep
ESCAPE='(\\\\[^u[:cntrl:]]|\\u[0-9a-fA-F]{4})'
CHAR='[^[:cntrl:]"\\\\]'
fi
local STRING="\"$CHAR*($ESCAPE$CHAR*)*\""
local NUMBER='-?(0|[1-9][0-9]*)([.][0-9]*)?([eE][+-]?[0-9]*)?'
local KEYWORD='null|false|true'
local SPACE='[[:space:]]+'
$GREP "$STRING|$NUMBER|$KEYWORD|$SPACE|." | egrep -v "^$SPACE$"
}
| |
| def tokenize () :
if (print("test string") | _rc = subprocess.call("egrep -ao --color"="never test",shell=True,stderr=file('/dev/null','wb'),stdout=file('/dev/null','wb'))
):
GREP="egrep -ao --color=never"
else:
GREP="egrep -ao"
if (print("test string") | _rc = subprocess.call("egrep -o test",shell=True,stderr=file('/dev/null','wb'),stdout=file('/dev/null','wb'))
):
ESCAPE="(\\\\[^u[:cntrl:]]|\\\\u[0-9a-fA-F]{4})"
CHAR="[^[:cntrl:]\"\\\\]"
else:
GREP="awk_egrep"
ESCAPE="(\\\\\\\\[^u[:cntrl:]]|\\\\u[0-9a-fA-F]{4})"
CHAR="[^[:cntrl:]\"\\\\\\\\]"
STRING="\"" + str(CHAR) + "*(" + str(ESCAPE) + str(CHAR) + "*)*\""
NUMBER="-?(0|[1-9][0-9]*)([.][0-9]*)?([eE][+-]?[0-9]*)?"
KEYWORD="null|false|true"
SPACE="[[:space:]]+"
_rc = subprocess.call([GREP,str(STRING) + "|" + str(NUMBER) + "|" + str(KEYWORD) + "|" + str(SPACE) + "|."]) | _rc = subprocess.call(["egrep","-v","^" + str(SPACE) + str()])
|
| |
parse_array () {
local index=0
local ary=''
read -r token
case "$token" in
']') ;;
*)
while :
do
parse_value "$1" "$index"
index=$((index+1))
ary="$ary""$value"
read -r token
case "$token" in
']') break ;;
',') ary="$ary," ;;
*) throw "EXPECTED , or ] GOT ${token:-EOF}" ;;
esac
read -r token
done
;;
esac
[ "$BRIEF" -eq 0 ] && value=`printf '[%s]' "$ary"` || value=
:
}
| |
| def parse_array () :
global token
global value
global BRIEF
index=0
ary=""
token = raw_input()
if ( str(token) == ']'):
else:
while ():
_rc = subprocess.call(["parse_value",str(sys.argv[1]),str(index)])
index=(\"index+1\")
ary=arystr(value)
token = raw_input()
elif ( str(token) == ']'):
break
elif ( str(token) == ','):
ary=str(ary) + ","
else:
throw()
token = raw_input()
"BRIEF" == 0 and value=os.popen("printf \"[%s]\" \""+str(ary)+"\"").read() or value=
|
| |
parse_object () {
local key
local obj=''
read -r token
case "$token" in
'}') ;;
*)
while :
do
case "$token" in
'"'*'"') key=$token ;;
*) throw "EXPECTED string GOT ${token:-EOF}" ;;
esac
read -r token
case "$token" in
':') ;;
*) throw "EXPECTED : GOT ${token:-EOF}" ;;
esac
read -r token
parse_value "$1" "$key"
obj="$obj$key:$value"
read -r token
case "$token" in
'}') break ;;
',') obj="$obj," ;;
*) throw "EXPECTED , or } GOT ${token:-EOF}" ;;
esac
read -r token
done
;;
esac
[ "$BRIEF" -eq 0 ] && value=`printf '{%s}' "$obj"` || value=
:
}
| |
| def parse_object () :
global token
global value
global BRIEF
obj=""
token = raw_input()
if ( str(token) == '}'):
else:
while ():
elif ( str(token) == ''"'*'"''):
key=token
else:
throw()
token = raw_input()
if ( str(token) == ':'):
else:
throw()
token = raw_input()
_rc = subprocess.call(["parse_value",str(sys.argv[1]),str(key)])
obj=str(obj) + str(key) + ":" + str(value)
token = raw_input()
if ( str(token) == '}'):
break
elif ( str(token) == ','):
obj=str(obj) + ","
else:
throw()
token = raw_input()
"BRIEF" == 0 and value=os.popen("printf \"{%s}\" \""+str(obj)+"\"").read() or value=
|
| |
parse_value () {
local jpath="${1:+$1,}$2" isleaf=0 isempty=0 print=0
case "$token" in
'{') parse_object "$jpath" ;;
'[') parse_array "$jpath" ;;
# At this point, the only valid single-character tokens are digits.
''|[!0-9]) throw "EXPECTED value GOT ${token:-EOF}" ;;
*) value=$token
isleaf=1
[ "$value" = '""' ] && isempty=1
;;
esac
[ "$value" = '' ] && return
[ "$LEAFONLY" -eq 0 ] && [ "$PRUNE" -eq 0 ] && print=1
[ "$LEAFONLY" -eq 1 ] && [ "$isleaf" -eq 1 ] && [ $PRUNE -eq 0 ] && print=1
[ "$LEAFONLY" -eq 0 ] && [ "$PRUNE" -eq 1 ] && [ "$isempty" -eq 0 ] && print=1
[ "$LEAFONLY" -eq 1 ] && [ "$isleaf" -eq 1 ] && \
[ $PRUNE -eq 1 ] && [ $isempty -eq 0 ] && print=1
[ "$print" -eq 1 ] && printf "[%s]\t%s\n" "$jpath" "$value"
:
}
| |
| def parse_value () :
global token
global value
global LEAFONLY
global PRUNE
jpath=str('' if dir().count('1') == 0 or 1 == '' else sys.argv[1],) + str(sys.argv[2])
isleaf=0
isempty=0
print=0
if ( str(token) == '{'):
parse_object()
elif ( str(token) == '['):
parse_array()
elif ( str(token) == '' or str(token) == '[!0-9]'):
# At this point, the only valid single-character tokens are digits. |
|
throw()
else:
value=token
isleaf=1
"value" == "\"\"" and isempty=1
"value" == "" and return
"LEAFONLY" == 0 and "PRUNE" == 0 and print=1
"LEAFONLY" == 1 and "isleaf" == 1 and PRUNE == 0 and print=1
"LEAFONLY" == 0 and "PRUNE" == 1 and "isempty" == 0 and print=1
"LEAFONLY" == 1 and "isleaf" == 1 and PRUNE == 1 and isempty == 0 and print=1
"print" == 1 and print( "[%s]\t%s\n" % (str(jpath), str(value)) )
|
| |
parse () {
read -r token
parse_value
read -r token
case "$token" in
'') ;;
*) throw "EXPECTED EOF GOT $token" ;;
esac
}
| |
| def parse () :
global token
token = raw_input()
parse_value()
token = raw_input()
if ( str(token) == ''):
else:
throw()
|
| |
parse_options "$@"
| |
| parse_options() |
| |
if ([ "$0" = "$BASH_SOURCE" ] || ! [ -n "$BASH_SOURCE" ]);
then
tokenize | parse
fi
| |
| if (( "__file__" == "BASH_SOURCE" or ! (str(BASH_SOURCE) != '') ) ):
tokenize() | parse() |
ÿ | |