From 8a9a6865954ade85d4a55f955829ae08941c31b8 Mon Sep 17 00:00:00 2001 From: P. J. McDermott Date: Sun, 21 Feb 2016 21:13:33 -0500 Subject: Remove old demo parsing code --- (limited to 'parsing') diff --git a/parsing/codegen.sh b/parsing/codegen.sh deleted file mode 100644 index 8d9d2fd..0000000 --- a/parsing/codegen.sh +++ /dev/null @@ -1,85 +0,0 @@ -sc= - -sgetc() -{ - sc="$(dd bs=1 count=1 2>/dev/null; printf '.')" - sc="${sc%.}" -} - -codegen_sub() -{ - local array="${1}" - shift 1 - - IFS="${RS}" - for t in ${array}; do - toktext "${t}" - case "${t%${US}*}" in - T_NEWLINE) - ;; - *) - printf ' ' - ;; - esac - done - unset IFS -} - -# The token stack is encoded in a string in the following grammar: -# Terminal symbols: -# TOKEN -# Production rules: -# stack = tokens [ '' type '' stack '' [ tokens ] ] ; -# tokens = TOKEN { '' TOKEN } ; -# type = 'C' ; -# We need to recurse through this stack to get to all the tokens. -# Each element in the stack (an array of tokens) gets run through the codegen to -# become text that is inserted into the array below. -parse_stack() -{ - local array= - - array='' - while :; do - sgetc - case "${sc}" in - '') - # EOF - break - ;; - "${SOH}") - # New stack element - sgetc - case "${sc}" in - 'C') - # Command substitution - sgetc # STX - array="${array}$(parse_stack)." - array="${array%.}" - ;; - esac - ;; - "${ETX}") - # End of stack element - break - ;; - *) - # Token character - array="${array}${sc}" - ;; - esac - done - codegen_sub "${array}" -} - -codegen() -{ - local toks="${1}" - shift 1 - - if printf '%s' "${toks}" | parse_stack; then - return 0 - else - return 1 - fi -} diff --git a/parsing/lexer.sh b/parsing/lexer.sh deleted file mode 100644 index 886e7f8..0000000 --- a/parsing/lexer.sh +++ /dev/null @@ -1,958 +0,0 @@ -fname= -lineno= -ln_off= -start= -c= -wordexp= -here_queue= -here_awaiting_end= -here_awaiting_word= -tok= -tokens= - -# -# Error handling (used by scanning and interface functions) -# - -error() -{ - local fmt="${1}" - shift 1 - - case "${fname}" in - '-') - printf "stdin:%d: ${fmt}\n" ${lineno} "${@}" >&2 - ;; - *) - printf "%s:%d: ${fmt}\n" "${fname}" ${lineno} "${@}" >&2 - ;; - esac - - # The parser and lexer run in a subshell, so this just returns up to the - # caller like an exception. - exit 1 -} - -synexp() -{ - local t="${1}" - shift 1 - - if [ "x${t}" = 'x' ]; then - synerr '%s unexpected' "$(tokname "${tok}")" - else - synerr '%s unexpected (expecting %s)' "$(tokname "${tok}")" \ - "$(tokname "${t}")" - fi -} - -synerr() -{ - local fmt="${1}" - shift 1 - - error "Syntax error: ${fmt}" "${@}" -} - -# -# Input reading -# - -lgetc() -{ - c="$(dd bs=1 count=1 2>/dev/null; printf '.')" - c="${c%.}" -} - -# -# Token recognition -# - -next() -{ - if ${here_awaiting_word}; then - next_here - return - fi - while :; do - dbg "parsing char '$c' at lineno $lineno" - case "${c}" in - '') - lgetc - tok=T_EOF - return - ;; - "${LF}") - if ${here_awaiting_end}; then - synexp '' - else - case "${here_queue}" in *"${RS}"*) - here_awaiting_end=false - here_awaiting_word=true - ;; - esac - fi - lgetc - lineno=$((${lineno} + 1)) - tok=T_NEWLINE - return - ;; - ' '|"${HT}") - lgetc - continue - ;; - \\) - lgetc - case "${c}" in "${LF}") - lineno=$((${lineno} + 1)) - lgetc - continue - ;; - esac - next_word \\ - return - ;; - '#') - lgetc - while :; do - case "${c}" in "${LF}"|'') - break - ;; - esac - lgetc - done - continue - ;; - '&') - lgetc - case "${c}" in '&') - lgetc - tok=T_AND_IF - return - ;; - esac - tok=T_AND - return - ;; - '|') - lgetc - case "${c}" in '|') - lgetc - tok=T_OR_IF - return - ;; - esac - tok=T_PIPE - return - ;; - ';') - lgetc - case "${c}" in ';') - lgetc - tok=T_DSEMI - return - ;; - esac - dbg T_SEMI - tok=T_SEMI - return - ;; - '(') - lgetc - tok=T_LPAREN - return - ;; - ')') - lgetc - tok=T_RPAREN - return - ;; - '<'|'>') - next_io - return - ;; - *) - next_word '' - return - ;; - esac - lgetc - done -} - -next_here() -{ - local here= - local here_strip_tabs= - local here_end= - local here_escaped= - local line= - local word= - local res= - local wordexp= - - # Dequeue the here-document. - here="${here_queue%%${RS}*}" - here_strip_tabs="${here%%${US}*}" - here_end="${here%${US}*}" - here_end="$(printf '%s' "${here_end#*${US}}" | \ - sed 's/\\//g; s/"//g; s/'\''//g;')" # Stupid Vim: ')" - here_escaped="${here##*${US}}" - here_queue="${here_queue#*${RS}}" - here_awaiting_word=false - - line='' - word='' - while :; do - case "${c}" in - '') - # Bash throws a warning when EOF occurs in a - # here document. mksh throws an error. dash, - # BusyBox ash, ksh93, and zsh accept EOF as a - # delimiter. We aim for the lowest common - # denominator, so throw an error like mksh does. - synerr 'Here-document "%s" unclosed' \ - "${here_end}" - ;; - "${LF}") - word="${word}${line}" - case "${line}" in "${here_end}") - tok="T_WORD${US}${word}" - return - ;; - esac - word="${word}${c}" - line='' - ;; - "${HT}") - if ${here_strip_tabs}; then - case "${line}" in - '') - ;; - *) - line="${line}${c}" - ;; - esac - else - line="${line}${c}" - fi - ;; - '$') - if ! ${here_escaped}; then - lgetc - if ! res="$(scan_wordexp)"; then - exit 1 - fi - ln_off=${res%%${RS}*} - res="${res#*${RS}}" - c="${res%%${RS}*}" - res="${res#*${RS}}" - wordexp="${res%%${RS}*}" - lineno=$((${lineno} + ${ln_off})) - line="${line}${wordexp}" - continue - else - line="${line}${c}" - fi - ;; - *) - line="${line}${c}" - ;; - esac - lgetc - done -} - -next_io() -{ - case "${c}" in - '<') - lgetc - case "${c}" in - '<') - lgetc - case "${c}" in '-') - lgetc - tok=T_DLESSDASH - here_queue="${here_queue}true" - here_awaiting_end=true - here_awaiting_word=false - break - ;; - esac - tok=T_DLESS - here_queue="${here_queue}false" - here_awaiting_end=true - here_awaiting_word=false - break - ;; - '&') - lgetc - tok=T_LESSAND - break - ;; - '>') - lgetc - tok=T_LESSGREAT - break - ;; - esac - tok=T_LESS - break - ;; - '>') - lgetc - case "${c}" in - '>') - lgetc - tok=T_DGREAT - break - ;; - '&') - lgetc - tok=T_GREATAND - break - ;; - '|') - lgetc - tok=T_CLOBBER - break - ;; - esac - tok=T_GREAT - break - ;; - esac -} - -next_word() -{ - local prev_c="${1}" - shift 1 - local res= - local word= - - if ! res="$(scan_word false)"; then - exit 1 - fi - ln_off=${res%%${RS}*} - res="${res#*${RS}}" - c="${res%%${RS}*}" - res="${res#*${RS}}" - word="${prev_c}${res%%${RS}*}" - - # We must advance lineno because scan_word() was run in a subshell. - lineno=$((${lineno} + ${ln_off})) - tok="T_WORD${US}${word}" - - if ${here_awaiting_end}; then - here_queue="${here_queue}${US}${word}" - case "${word}" in - *\\*|*'"'*|*"'"*) - here_queue="${here_queue}${US}true" - ;; - *) - here_queue="${here_queue}${US}false" - ;; - esac - here_queue="${here_queue}${RS}" - here_awaiting_end=false - fi -} - -# -# Token scanning -# - -scan_word() -{ - local in_param="${1}" - local res= - local word= - local quoted= - local lines= - local wordexp= - - word='' - quoted=false - lines=0 - while :; do - dbg "parsing word char '$c' at lineno $lineno" - case "${c}" in - '') - break - ;; - "${LF}") - if ! ${in_param} && ! ${quoted}; then - break - fi - lineno=$((${lineno} + 1)) - lines=$((${lines} + 1)) - word="${word}${c}" - ;; - ' '|"${HT}"|'&'|'|'|';'|'('|')'|'<'|'>') - if ! ${in_param} && ! ${quoted}; then - break - fi - word="${word}${c}" - ;; - '$') - case "${here_queue}" in *"${RS}"*) - if ${here_awaiting_end}; then - synerr '%s %s %s %s' \ - 'Word expansions' \ - 'not supported in' \ - 'here-document' \ - 'delimiters' - fi - esac - lgetc - if ! res=$(scan_wordexp); then - exit 1 - fi - ln_off=${res%%${RS}*} - res="${res#*${RS}}" - c="${res%%${RS}*}" - res="${res#*${RS}}" - wordexp="${res%%${RS}*}" - # We must advance lineno because scan_wordexp() - # was run in a subshell. - lineno=$((${lineno} + ${ln_off})) - word="${word}${wordexp}" - # scan_wordexp() leaves behind an unused - # character, so we should skip the lgetc() call - # below. - continue - ;; - '`') - synerr 'Backquoted (old-style) %s' \ - 'command substitution not supported' - break - ;; - \\) - word="${word}${c}" - lgetc - case "${c}" in '') - # Bash, ksh93, mksh, and zsh ignore a - # backslash at the end of a file, but - # dash and BusyBox ash include it in the - # word. To help with script - # portability, we'll throw an error - # (which is a reasonable thing to do - # anyway). - synerr 'Unexpected end of file %s' \ - 'after "\"' - ;; - esac - word="${word}${c}" - ;; - \') - word="${word}${c}" - while :; do - lgetc - word="${word}${c}" - case "${c}" in - '') - synerr '%s %s' \ - 'Unterminated' \ - 'quoted string' - ;; - \') - break - ;; - esac - done - ;; - '"') - word="${word}${c}" - if ${quoted}; then - quoted=false - else - quoted=true - fi - ;; - '}') - if ${in_param} && ! ${quoted}; then - break - fi - word="${word}${c}" - ;; - *) - word="${word}${c}" - ;; - esac - lgetc - done - - if ${quoted}; then - synerr 'Unterminated quoted string' - fi - - printf "%d${RS}%c${RS}%s" ${lines} "${c}" "${word}" -} - -scan_wordexp() -{ - local res= - local toks= - local param= - - wordexp='' - ln_off=0 - case "${c}" in - '{') - # Parameter expansion brace - scan_wordexp_param_brace - ;; - '(') - # Arithmetic expansion or command substitution - lgetc - case "${c}" in - '(') - # Arithmetic expansion - scan_wordexp_arith - ;; - *) - # Command substitution - if ! res="$(run_sublexer "sub${fname}" \ - ${lineno} "${start}" \ - "${c}")"; then - exit 1 - fi - ln_off=${res%%${RS}*} - res="${res#*${RS}}" - c="${res%%${RS}*}" - res="${res#*${RS}}" - toks="${res%%${RS}*}" - lineno=${ln_off} - wordexp="\$(${SOH}C${STX}${toks}" - wordexp="${wordexp}${ETX})" - # ")" is recognized in run_sublexer(). - ;; - esac - ;; - [@*#?$!A-Za-z0-9_-]) - if ! res="$(scan_param)"; then - exit 1 - fi - ln_off=${res%%${RS}*} - res="${res#*${RS}}" - c="${res%%${RS}*}" - res="${res#*${RS}}" - param="${res%%${RS}*}" - lineno=$((${lineno} + ${ln_off})) - wordexp="\$${param}" - ;; - esac - - printf "%d${RS}%c${RS}%s" ${ln_off} "${c}" "${wordexp}" - return 0 -} - -scan_wordexp_param_brace() -{ - local mod= - local res= - local param= - local word= - - mod=true - - lgetc - case "${c}" in - '#') - lgetc - case "${c}" in - [@*#?$!A-Za-z0-9_-]) - # String length expansion - if ! res="$(scan_param)"; then - exit 1 - fi - ln_off=${res%%${RS}*} - res="${res#*${RS}}" - c="${res%%${RS}*}" - res="${res#*${RS}}" - param="${res%%${RS}*}" - lineno=$((${lineno} + ${ln_off})) - # Disable modifications. - mod=false - ;; - *) - # Special parameter "#" - param='#' - ;; - esac - ;; - *) - if ! res="$(scan_param)"; then - exit 1 - fi - ln_off=${res%%${RS}*} - res="${res#*${RS}}" - c="${res%%${RS}*}" - res="${res#*${RS}}" - param="${res%%${RS}*}" - lineno=$((${lineno} + ${ln_off})) - ;; - esac - wordexp="\${${param}" - - # If modifications are allowed - if ${mod}; then - # Check for modifications. - mod=false - case "${c}" in - ':') - mod=true - wordexp="${wordexp}${c}" - lgetc - case "${c}" in '-'|'='|'?'|'+') - wordexp="${wordexp}${c}" - lgetc - ;; - esac - ;; - '-'|'='|'?'|'+') - mod=true - wordexp="${wordexp}${c}" - lgetc - ;; - '%') - mod=true - wordexp="${wordexp}${c}" - lgetc - case "${c}" in '%') - wordexp="${wordexp}${c}" - lgetc - ;; - esac - ;; - '#') - mod=true - wordexp="${wordexp}${c}" - lgetc - case "${c}" in '#') - wordexp="${wordexp}${c}" - lgetc - ;; - esac - ;; - esac - fi - - # If a modification was found - if ${mod}; then - # Get word. - if ! res="$(scan_word true)"; then - exit 1 - fi - ln_off=${res%%${RS}*} - res="${res#*${RS}}" - c="${res%%${RS}*}" - res="${res#*${RS}}" - word="${res%%${RS}*}" - # We must advance lineno because scan_word() was run in a - # subshell. - lineno=$((${lineno} + ${ln_off})) - wordexp="${wordexp}${word}" - dbg "param mod word: '$word'" - fi - - # Check for right brace. - case "${c}" in - '}') - wordexp="${wordexp}${c}" - lgetc - ;; - *) - synerr 'Missing "}"' - ;; - esac - - return 0 -} - -scan_param() -{ - local param= - - param='' - case "${c}" in - [@*#?$!0-]) - # Special parameter - param="${c}" - lgetc - ;; - [1-9]) - # Positional parameter - param="${param}${c}" - lgetc - while :; do - case "${c}" in [!0-9]) - break - ;; - esac - param="${param}${c}" - lgetc - done - ;; - [A-Za-z_]) - # Parameter name - param="${param}${c}" - lgetc - while :; do - case "${c}" in [!A-Za-z0-9_]) - break - ;; - esac - param="${param}${c}" - lgetc - done - ;; - *) - synerr 'Bad parameter name' - ;; - esac - - printf "%d${RS}%c${RS}%s" 0 "${c}" "${param}" - return 0 -} - -scan_wordexp_arith() -{ - local arith= - local paren_lvl= - local res= - local sub_wordexp= - - arith='' - paren_lvl=0 - while :; do - lgetc - case "${c}" in - '') - synerr 'end of file unexpected (%s)' \ - 'expecting "))"' - ;; - '(') - arith="${arith}${c}" - paren_lvl=$((${paren_lvl} + 1)) - ;; - ')') - if [ ${paren_lvl} -eq 0 ]; then - lgetc - case "${c}" in ')') - wordexp="\$((${arith}))" - lgetc - return 0 - ;; - esac - synerr 'Arithmetic expansion: ")" %s' \ - 'unexpected' - fi - arith="${arith}${c}" - paren_lvl=$((${paren_lvl} - 1)) - ;; - '$') - lgetc - if ! res=$(scan_wordexp); then - exit 1 - fi - ln_off=${res%%${RS}*} - res="${res#*${RS}}" - c="${res%%${RS}*}" - res="${res#*${RS}}" - sub_wordexp="${res%%${RS}*}" - # We must advance lineno because scan_wordexp() - # was run in a subshell. - lineno=$((${lineno} + ${ln_off})) - arith="${arith}${sub_wordexp}" - ;; - *) - arith="${arith}${c}" - ;; - esac - done -} - -# -# Interface -# - -# Check the current token. If it matches, add it to the syntax array. -accept() -{ - local t="${1}" - local rw= - - dbg "looking for $t, current tok ${tok%%${US}*}" - case "${t}" in - T_IF|T_THEN|T_ELSE|T_ELIF|T_FI|\ - T_DO|T_DONE|T_CASE|T_ESAC|T_WHILE|T_UNTIL|\ - T_FOR|T_LBRACE|T_RBRACE|T_BANG|T_IN) - dbg "looking for reserved word $t, have '$tok'" - if ! [ "x${tok%%${US}*}" = "x${t}" ]; then - # Reserved words are recognized as literal - # T_WORDs. - if ! [ "x${tok%%${US}*}" = 'xT_WORD' ]; then - return 1 - fi - # T_WORD data unit must match reserved word - # exactly. - if ! [ "x${tok#T_WORD${US}}" = \ - "x$(toktext "${t}")" ]; then - return 1 - fi - # If the token matches the reserved word, - # replace it with the reserved word token. - tok="${t}" - fi - ;; - T_NAME) - # Names are recognized as literal T_WORDs. - if ! [ "x${tok%%${US}*}" = 'xT_WORD' ]; then - return 1 - fi - # Validate name. - case "${tok%%${US}*}" in - [A-Za-z_][0-9A-Za-z_]*) - ;; - *) - return 1 - ;; - esac - tok="T_NAME${US}${tok#T_WORD${US}}" - ;; - T_FNAME) - # Function names are recognized as literal T_WORDs. - if ! [ "x${tok%%${US}*}" = 'xT_WORD' ]; then - return 1 - fi - # Validate name. - case "${tok%%${US}*}" in - [A-Za-z_][0-9A-Za-z_]*) - ;; - *) - return 1 - ;; - esac - # Verify that the function name doesn't match any - # reserved words. - for rw in T_IF T_THEN T_ELSE T_ELIF T_FI T_DO T_DONE \ - T_CASE T_ESAC T_WHILE T_UNTIL T_FOR \ - T_LBRACE T_RBRACE T_BANG T_IN; do - if [ "x${tok#T_WORD${US}}" = \ - "x$(toktext "${rw}")" ]; then - tok="${rw}" - return 1 - fi - done - tok="T_FNAME${US}${tok#T_WORD${US}}" - ;; - T_CMDNAME) - # The first word of a simple command is to be checked - # for reserved words. - if ! [ "x${tok%%${US}*}" = 'xT_WORD' ]; then - return 1 - fi - # Verify that the word doesn't match any reserved words. - for rw in T_IF T_THEN T_ELSE T_ELIF T_FI T_DO T_DONE \ - T_CASE T_ESAC T_WHILE T_UNTIL T_FOR \ - T_LBRACE T_RBRACE T_BANG T_IN; do - if [ "x${tok#T_WORD${US}}" = \ - "x$(toktext "${rw}")" ]; then - tok="${rw}" - return 1 - fi - done - ;; - *) - if ! [ "x${tok%%${US}*}" = "x${t}" ]; then - return 1 - fi - ;; - esac - - dbg "accept $t" - tokens="${tokens}${tok}${RS}" - next - return 0 -} - -expect() -{ - local t="${1}" - - if accept "${t}"; then - return 0 - else - synexp "${t}" - fi -} - -# Called by the lexer, not the parser -run_sublexer() -{ - local fn="${1}" - local ln="${2}" - local st="${3}" - local ch="${4}" - shift 4 - - # Initialize global variables. - fname="${fn}" - lineno=${ln} - start="${st}" - here_queue='' - here_awaiting_end=false - here_awaiting_word=false - tokens='' - - c="${ch}" - next - - #dbg=true - # If this returns (does not exit), there are no errors. - ${start} - case "${tok%${US}*}" in - T_RPAREN) - ;; - *) - synerr 'Missing ")"' - ;; - esac - - printf "%d${RS}%c${RS}%s" ${lineno} "${c}" "${tokens}" - return 0 -} - -run_lexer() -{ - local fn="${1}" - local st="${2}" - shift 2 - - # Initialize global variables. - fname="${fn}" - lineno=1 - start="${st}" - here_queue='' - here_awaiting_end=false - here_awaiting_word=false - tokens='' - - # Read the first character and recognize the first token. - lgetc - next - - # If this returns (does not exit), there are no errors. - ${start} - if ! accept T_EOF; then - synexp '' - fi - - # Return the tokens. - printf '%s' "${tokens}" - - return 0 -} diff --git a/parsing/parse.sh b/parsing/parse.sh deleted file mode 100644 index 199005a..0000000 --- a/parsing/parse.sh +++ /dev/null @@ -1,676 +0,0 @@ -SOH="$(printf '\001.')"; SOH="${SOH%.}" -STX="$(printf '\002.')"; STX="${STX%.}" -ETX="$(printf '\003.')"; ETX="${ETX%.}" - HT="$(printf '\t.')"; HT="${HT%.}" - LF="$(printf '\n.')"; LF="${LF%.}" - RS="$(printf '\036.')"; RS="${RS%.}" - US="$(printf '\037.')"; US="${US%.}" - -dbg=true -dbg=false - -dbg() -{ - if ${dbg}; then - printf 'DEBUG: %s\n' "${@}" >&2 - fi -} - -ptrace=false - -ptrace_begn() -{ - local fn="${1}" - shift 1 - - if ${ptrace}; then - printf 'TRACE: BEGN %s()\n' "${fn}" >&2 - fi -} - -ptrace_pass() -{ - local fn="${1}" - shift 1 - - if ${ptrace}; then - printf 'TRACE: PASS %s()\n' "${fn}" >&2 - fi -} - -ptrace_fail() -{ - local fn="${1}" - shift 1 - - if ${ptrace}; then - printf 'TRACE: FAIL %s()\n' "${fn}" >&2 - fi -} - -. ./tokens.sh -. ./lexer.sh -. ./codegen.sh - -complete_command() -{ - if list; then - separator - return 0 - fi - # Unexpected EOF - synexp '' -} - -list() -{ - ptrace_begn list - if and_or; then - while separator && and_or; do - : - done - ptrace_pass list - return 0 - fi - ptrace_fail list - return 1 -} - -and_or() -{ - ptrace_begn and_or - if pipeline; then - while accept T_AND_IF || accept T_OR_IF; do - if ! linebreak || ! pipeline; then - ptrace_fail and_or - return 1 - fi - done - ptrace_pass and_or - return 0 - fi - ptrace_fail and_or - return 1 -} - -pipeline() -{ - ptrace_begn pipeline - accept T_BANG - if pipe_sequence; then - ptrace_pass pipeline - return 0 - fi - ptrace_fail pipeline - return 1 -} - -pipe_sequence() -{ - ptrace_begn pipe_sequence - if command; then - while accept T_PIPE; do - if ! linebreak || ! command; then - ptrace_fail pipe_sequence - return 1 - fi - done - ptrace_pass pipe_sequence - return 0 - fi - ptrace_fail pipe_sequence - return 1 -} - -command() -{ - ptrace_begn command - if simple_command; then - ptrace_pass command - return 0 - elif compound_command; then - redirect_list - ptrace_pass command - return 0 - fi - ptrace_fail command - return 1 -} - -compound_command() -{ - ptrace_begn compound_command - if brace_group; then - ptrace_pass compound_command - return 0 - elif subshell; then - ptrace_pass compound_command - return 0 - elif for_clause; then - ptrace_pass compound_command - return 0 - elif case_clause; then - ptrace_pass compound_command - return 0 - elif if_clause; then - ptrace_pass compound_command - return 0 - elif while_clause; then - ptrace_pass compound_command - return 0 - elif until_clause; then - ptrace_pass compound_command - return 0 - fi - ptrace_fail compound_command - return 1 -} - -subshell() -{ - ptrace_begn subshell - if accept T_LPAREN && compound_list && expect T_RPAREN; then - ptrace_pass subshell - return 0 - fi - ptrace_fail subshell - return 1 -} - -compound_list() -{ - ptrace_begn compound_list - newline_list - if term; then - separator - ptrace_pass compound_list - return 0 - fi - ptrace_fail compound_list - return 1 -} - -term() -{ - ptrace_begn term - if and_or; then - while separator; do - and_or - done - ptrace_pass term - return 0 - fi - ptrace_fail term - return 1 -} - -for_clause() -{ - ptrace_begn for_clause - if accept T_FOR; then - if expect T_NAME && linebreak; then - if accept T_IN; then - wordlist - if ! sequential_sep; then - ptrace_fail for_clause - return 1 - fi - fi - if do_group; then - ptrace_pass for_clause - return 0 - fi - fi - fi - ptrace_fail for_clause - return 1 -} - -wordlist() -{ - ptrace_begn wordlist - if accept T_WORD; then - while accept T_WORD; do :; done - ptrace_pass wordlist - return 0 - fi - ptrace_fail wordlist - return 1 -} - -case_clause() -{ - if accept T_CASE; then - if expect T_WORD && linebreak && expect T_IN && linebreak; then - case_list || case_list_ns - expect T_ESAC - return 0 - fi - fi - return 1 -} - -case_list_ns() -{ - if case_list && case_item_ns; then - return 0 - elif case_item_ns; then - return 0 - fi - return 1 -} - -case_list() -{ - if case_item; then - while case_item; do - : - done - return 0 - fi - return 1 -} - -case_item_ns() -{ - accept T_LPAREN - if pattern && expect RPAREN; then - compound_list - if linebreak; then - return 0 - fi - fi - return 1 -} - -case_item() -{ - accept T_LPAREN - if pattern && expect T_RPAREN; then - if compound_list || linebreak; then - if expect T_DSEMI && linebreak; then - return 0 - fi - fi - fi - return 1 -} - -pattern() -{ - if accept T_CMDNAME; then - while accept T_PIPE; do - expect T_WORD - done - return 0 - fi - return 1 -} - -if_clause() -{ - if accept T_IF; then - if compound_list && expect T_THEN && compound_list; then - else_part - expect T_FI - return 0 - fi - fi - return 1 -} - -else_part() -{ - while accept T_ELIF; do - if compound_list && expect T_THEN && compound_list; then - continue - fi - return 1 - done - if accept T_ELSE; then - if compound_list; then - return 0 - fi - fi - return 1 -} - -while_clause() -{ - if accept T_WHILE; then - if compound_list && do_group; then - return 0 - fi - fi - return 1 -} - -until_clause() -{ - if accept T_UNTIL; then - if compound_list && do_group; then - return 0 - fi - fi - return 1 -} - -function_body() -{ - ptrace_begn function_body - if compound_command; then - redirect_list - ptrace_pass function_body - return 0 - fi - ptrace_fail function_body - return 1 -} - -brace_group() -{ - ptrace_begn brace_group - if accept T_LBRACE && compound_list && expect T_RBRACE; then - ptrace_pass brace_group - return 0 - fi - ptrace_fail brace_group - return 1 -} - -do_group() -{ - ptrace_begn do_group - if accept T_DO && compound_list && expect T_DONE; then - ptrace_pass do_group - return 0 - fi - ptrace_fail do_group - return 1 -} - -simple_command() -{ - ptrace_begn simple_command - if cmd_prefix; then - if cmd_word; then - cmd_suffix - fi - ptrace_pass simple_command - return 0 - elif accept T_FNAME; then - if accept T_LPAREN; then - expect T_RPAREN - if linebreak && function_body; then - ptrace_pass simple_command - return 0 - fi - else - cmd_suffix - ptrace_pass simple_command - return 0 - fi - elif cmd_name; then - cmd_suffix - ptrace_pass simple_command - return 0 - fi - ptrace_fail simple_command - return 1 -} - -cmd_name() -{ - ptrace_begn cmd_name - # TODO: Assignment - if accept T_CMDNAME; then - ptrace_pass cmd_name - return 0 - fi - ptrace_fail cmd_name - return 1 -} - -cmd_word() -{ - ptrace_begn cmd_word - # TODO: Assignment - if accept T_WORD; then - ptrace_pass cmd_word - return 0 - fi - ptrace_fail cmd_word - return 1 -} - -cmd_prefix() -{ - ptrace_begn cmd_prefix - if io_redirect || accept T_ASSIGNMENT_WORD; then - while io_redirect || accept T_ASSIGNMENT_WORD; do - : - done - ptrace_pass cmd_prefix - return 0 - fi - ptrace_fail cmd_prefix - return 1 -} - -cmd_suffix() -{ - ptrace_begn cmd_suffix - if io_redirect || accept T_WORD; then - while io_redirect || accept T_WORD; do - : - done - ptrace_pass cmd_suffix - return 0 - fi - ptrace_fail cmd_suffix - return 1 -} - -redirect_list() -{ - ptrace_begn redirect_list - if io_redirect; then - while io_redirect; do - : - done - ptrace_pass redirect_list - return 0 - fi - ptrace_fail redirect_list - return 1 -} - -io_redirect() -{ - ptrace_begn io_redirect - if io_file || io_here; then - ptrace_pass io_redirect - return 0 - fi - ptrace_fail io_redirect - return 1 -} - -io_file() -{ - if accept T_LESS || accept T_LESSAND || accept T_GREAT || \ - accept T_GREATAND || accept T_DGREAT || \ - accept T_LESSGREAT || accept T_CLOBBER; then - if filename; then - return 0 - fi - fi - return 1 -} - -filename() -{ - if accept T_WORD; then - return 0 - fi - return 1 -} - -io_here() -{ - if accept T_DLESS || accept T_DLESSDASH; then - if here_end; then - return 0 - fi - fi - return 1 -} - -here_end() -{ - if accept T_WORD; then - return 0 - fi - return 1 -} - -newline_list() -{ - if accept T_NEWLINE; then - while accept T_NEWLINE; do - : - done - return 0 - fi - return 1 -} - -linebreak() -{ - newline_list - return 0 -} - -separator_op() -{ - if accept T_AND || accept T_SEMI; then - return 0 - fi - return 1 -} - -separator() -{ - if separator_op && linebreak; then - return 0 - elif newline_list; then - return 0 - fi - return 1 -} - -sequential_sep() -{ - ptrace_begn sequential_sep - if accept T_SEMI; then - if linebreak; then - ptrace_pass sequential_sep - return 0 - fi - elif newline_list; then - ptrace_pass sequential_sep - return 0 - fi - ptrace_fail sequential_sep - return 1 -} - -parse() -{ - local fn="${1}" - shift 1 - - if run_lexer "${fn}" complete_command; then - return 0 - fi - return 1 -} - -try() -{ - local tokens= - local t= - - printf 'Trying script:\n' - printf '\t%s\n' "${@}" - if tokens="$(printf '%s\n' "${@}" | parse -)"; then - printf 'Tokens: %s\n' "${tokens}" | sed " - s/${SOH}//g; s/${STX}//g; s/${ETX}//g; - s/${RS}//g; s/${US}//g; - " - IFS="${RS}" - for t in ${tokens}; do - printf 'Token: %s\n' "$(tokname "${t}")" - case "${t%${US}*}" in T_NAME|T_FNAME|T_CMDNAME|T_WORD) - printf ' "%s"\n' "${t#*${US}}" - ;; - esac - done - printf 'Generated code:\n' - IFS="${LF}" - printf '\t%s\n' $(codegen "${tokens}") - unset IFS - else - printf 'FAIL\n' - fi - printf '\n\n' -} - -#try '"foo bar" && $baz || qux' '${quux%uux quuux' -#try '"foo bar" && $baz || qux' '${quux%uux } quuux' -#try 'foo ${bar}' -#try 'foo ${#bar}' -#try 'foo ${bar#baz}' -#try 'foo ${#bar#}' -#try 'foo ${^}' -#try 'foo `bar`' -#try 'foo &&' -#try '{ foo; }' -#try '( foo )' -#try 'for i in 1 2 3; do stuff; done' -#try 'if foo; then bar; fi' -#try 'if foo; then bar; elif baz; then qux; else quux; fi' -#try 'if ; then ; fi' -#try 'while foo; do bar; done' -#try 'while ; do ; done' -#try 'foo(){ bar; }' -#try 'case foo in bar) baz;; (qux) quux;; quux);; esac' -#try 'foo bar ( baz )' -#try 'foo $(bar)' -#try 'foo $(bar); baz' -#try 'foo $(bar)' 'baz' -#try 'foo $(bar) baz' -#try 'foo$(bar$(baz))qux' -#try 'foo $((1 + 1))' -#try '$((1 + 1))' -#try '$((1 + (1 + 1)))' -#try '$((1 + $(foo) + 1))' -#try '$((1' -#try 'foo <