new release, improvements in site avenger code, auto location code for feisty meow, many other improvements
+++ /dev/null
-
-# snippet of code to set all the temp folders and genesis2 state dir on a stable local
-# temporary directory. do not use /localtmp if it will be deleted! this stuff is
-# expected to persist until the user decides to clean things up.
-
-# use a local temporary directory if possible.
-if [ -d /localtmp ]; then
- export FAST_LOCAL_STORAGE=/localtmp/$USER
- export TMP=$FAST_LOCAL_STORAGE/tempo
- mkdir -p $TMP &>/dev/null
- chmod -R 700 $FAST_LOCAL_STORAGE
-
- # plan on putting the state directory onto there.
- export GENII_USER_DIR=$FAST_LOCAL_STORAGE/state-dir
-fi
-
-# after the above, load feisty meow scripts and they will take advantage of the
-# TMP folder we set above.
-
+++ /dev/null
-
-
-#taking a comma (or any char) separated list and turning it into an array:
-
-commaSeparatedList=tony,tiger,detroit,sugar,biscuits
-
-IFS="," read -ra argArray <<< "$commaSeparatedList"
-
-for ((i = 0; i < ${#argArray[@]}; i++)); do
- echo "arg $(($i + 1)): ${argArray[$i]}"
-done
-
+++ /dev/null
-# runs the nechung oracle program at exit from bash.
-
-sep 79
-$FEISTY_MEOW_GENERATED_STORE/runtime/binaries/nechung
-echo
-
+++ /dev/null
-
-# shell option parsing -- old school version only handles single dash options.
-
-while getopts "fr:q:a:h" opt; do
- case "${opt}" in
- f) force_query=1; ;;
- r) row_num="${OPTARG}"; ;;
- q) queue_name="${OPTARG}"; ;;
- a) alias_name="${OPTARG}"; ;;
- h) usage 1>&2; exit ${EX_OK}; ;;
- ?) usage 1>&2; exit ${EX_USAGE}; ;;
- esac
-done
-
-shift $(($OPTIND - 1))
-
+++ /dev/null
-#!/bin/bash
-
-##############
-# Name : fred_techniques
-# Author : Chris Koeritz
-# Rights : Copyright (C) 2010-$now by Author
-##############
-# Copyright (c) 2010-$now By Author. This script is free software; you can
-# redistribute it and/or modify it under the terms of the simplified BSD
-# license. See: http://www.opensource.org/licenses/bsd-license.php
-# Please send updates for this code to: fred@gruntose.com -- Thanks, fred.
-##############
-
-# this script is a collection of helpful bash practices that unfortunately
-# sometimes slip my mind when i need them. it's intended to collect all the
-# good bits so they don't slip away. feel free to re-use them in your own
-# code as needed.
-
-##############
-
-# clean for loops in bash:
-
-for ((i=0; i < 5; i++)) do
- echo $i
-done
-
-##############
-
-# removing an array element
-# --> only works on arrays that have no elements containing a space character.
-
-# define a 5 element array.
-arr=(a b c d e)
-
-# remove element 2 (the 'c').
-removepoint=2
-
-# set the array to slices of itself.
-arr=(${arr[*]:0:$removepoint} ${arr[*]:(($removepoint+1))} )
-
-# show the new contents.
-echo ${arr[*]}
-# shows: a b d e
-
-##############
-
-# store to a variable name by derefercing it.
-
-# shows how you can store into a variable when you are given only its name.
-function store_to_named_var()
-{
- local name="$1"; shift
- eval ${name}=\(gorbachev "perestroikanator 12000" chernenko\)
-}
-
-declare -a ted=(petunia "butter cup" smorgasbord)
-echo ted is ${ted[@]}
-store_to_named_var ted
-echo ted is now ${ted[@]}
-
-##############
-
+++ /dev/null
-
-
-# when the array elements have spaces, it is still possible to get them back right.
-
-
-a=("ted row" "boon" "moopy dongle")
-echo ${#a[@]}
-# 3
-borg=( "${a[@]}" )
-echo ${#borg[@]}
-# 3
-
-# normally the setting of borg would not preserve the elements with spaces in them as separate.
-# but by using the @ to get all the array members and the spaces around the reference, you get
-# the list back properly.
-
+++ /dev/null
-#!/bin/bash
-
-#
-# these great examples of handy unix tidbits were donated by "q. black".
-#
-
-# list a directory tree
-ls -R | grep ":$" | sed -e 's/:$//' -e 's/[^-][^\/]*\//--/g' -e 's/^/ /' -e 's/-/|/'
-
-# list directory sizes (biggest first)
-du -h $(du -s * |sort -nr|awk '{print $2}')
-
-# this will sort a date field of the form: DD-MON-YYYY HH:MM:SS
-sort +0.7 -1 +0.3M -0.6 +0 -0.2 +1
-
-# this will sort a date field of the form: MON DD HH:MM:SS YYYY
-sort +3 -4 +0M +1n
-
-# this will sort a date field of the form: MON DD HH:MM:SS
-sort +0M +1n
-
-# this will sort a date field of the form: Date: Tue Feb 3 09:17:58 EST 2004
-sort +6 -7 +2M +3n +4
-
-# display all lines from a certain line onward
-start_line=132
-|awk "{if (NR >= ${start_line}){print \$0}}"
-
-# display all lines after a token
-sed '1,/CUT HERE/d'
-
-# print the first and last lines
-sed -n '1,1p;$,$p'
-
-# signal bash about a window size change
-kill -winch $$
-
-# show the date 1 year, 2 months and 3 days ago
-date -v -1y -v -2m -v -3d
-
-# set the date back 1 year
-sudo date $(date -v -1y +%Y%m%d%H%M)
-
-# output the standard date format for setting the time
-# get the date
-date -u +%Y%m%d%H%M.%S
-# set the date
-date -u (cut and paste from above)
-
-# convert one date format to another (output is in the current time zone)
-old_date="Aug 27 15:24:33 2005 GMT"
-new_date=$(date -j -f "%b %e %T %Y %Z" "${old_date}" +%D)
-echo ${new_date}
-# returns "08/27/05"
-
-# output the modification time of a file in different format
-file=
-date -j -f "%b %e %T %Y" "$(ls -lT ${file} |awk '{print $6,$7,$8,$9}')"
-
-# output the number of days until a certain date
-target_date="Sep 2 15:20:20 2005 GMT"
-target_seconds=$(date -j -f "%b %e %T %Y" +%s "${target_date}" 2>/dev/null)
-diff_seconds=$(expr ${target_seconds} - $(date +%s))
-diff_days=$(expr ${diff_seconds} / 86400)
-echo "${diff_days} day(s)"
-
-# these commands can be used to fill in missing times in a "uniq -c" count
-# of times.
-# output 24 hours in one minute increments
-for h in $(jot -w %02d - 0 23 1); do
- for m in $(jot -w %02d - 0 59 1); do
- echo " 0 ${h}:${m}"
- done
-done
-# sort them together, and remove any 0 counts if an count already exists
-sort +1 +0rn out1 out2 |uniq -f 1
-
-# output with w3m to get basic html word wrap
-w3m -T "text/html" -dump -cols 72 <<EOF
- <p>
- This test verifies basic networking and that the ${product_short_name}
- can reach it's default gateway.
-EOF
-
-# another way to format text for output
-fmt 72 <<EOF
-This test verifies basic networking and that the ${product_short_name}
-can reach it's default gateway.
-EOF
-
-# smtpcrypt "printf"
-{
-char *jkwbuf = NULL;
-asprintf(&jkwbuf, "JKW: msg->used = %ld\n", msg->used);
-BIO_write(sc->log, jkwbuf, strlen(jkwbuf)+1);
-free(jkwbuf);
-}
-
-# rolling diff of a list of files (diff a & b, then b & c,...)
-last=
-for i in $(ls -1rt); do
- if [ ! -z "${last}" ]; then
- diff -u ${last} ${i}
- fi
- last=${i}
-done
-
-# clearing and restoring chflags
-file=
-old_chflags=$(ls -lo ${file}|awk '{print $5}')
-chflags 0 ${file}
-# do whatever
-if [ ."${old_chflags}" != ."-" ]; then
- chflags ${old_chflags} ${file}
-fi
-
-# way to do standard edits to files
-file=
-{
- # append line(s) after a line, "i" to insert before
- echo '/www_recovery/a'
- echo 'mithril ALL = (root) NOPASSWD: /usr/local/libexec/destroyer'
- echo '.'
- # modify a line
- echo 'g/^xntpd_program=/s,^xntpd_program=.*$,xntpd_program="ntpd",'
- # delete a line
- echo 'g/^controls key secret =/d'
- echo 'x!'
-} | ex - ${file}
-
-# how to search for errors in the last 24 hours
-# note that this command does not work quite right. The sort is off early
-# in the year because the dates do not have the year.
-# Also sed never sees the /CUT HERE/ when it is the first line.
-(echo "$(date -v-24H "+%b %e %H:%M:%S") --CUT HERE--"; \
- zgrep -h "cookie" /var/log/messages*)|sort +0M| \
- sed '1,/CUT HERE/d'
-# This version fixes those problems. It adds the file year to the date
-# and puts a marker at the start of the list.
-(echo "$(date -j -f "%s" 0 "+%Y %b %e %H:%M:%S") --ALWAYS FIRST--"; \
- echo "$(date -v-24H "+%Y %b %e %H:%M:%S") --CUT HERE--"; \
- for i in /var/log/messages*; do
- year=$(ls -lT ${i}|awk '{print $9}')
- zgrep -h "cookie" ${i}|while read line; do
- echo "${year} ${line}"
- done
- done)|sort +0n +1M| sed '1,/CUT HERE/d'
-
-# process a list of quoted values
-{
- # It tends to be easiest to use a 'here-document' to feed in the list.
- # I prefer to have the list at the start instead of the end
- cat <<EOF
- 'general' 'network node0' 'private address'
- 'general' 'options node2' 'kern securelevel'
-EOF
-}| while read line; do
- eval set -- ${line}
- config=$1; shift
- section=$1; shift
- key=$1; shift
-
- echo "confutil value \"${config}\" \"${section}\" \"${key}\""
-done
-
-# Method to read lines with a "for" loop, without spawning a subshell
-NEWLINE='
-'
-OIFS="${IFS}"
-IFS="${NEWLINE}"
-for line in $(cat /etc/passwd | sort -r); do
- IFS="${OIFS}"
-
- # do whatever you want here
- echo "line = ${line}"
-
- IFS="${NEWLINE}"
-done
-IFS="${OIFS}"
-
-# generate a histogram of characters in a file
-cat file|
- awk '{for (i=1; i <= length($0); i++) {printf("%s\n",substr($0,i,1))}}'|
- sort|uniq -c
-
-# show line lengths for a file
-cat file| awk '{print length($0)}'| sort -n
-
-
-
-
-# get the modification time of a directory or file and then reset the time.
-target=/usr/local/etc/pkdb
-save_date=$(ls -ldT ${target}|awk '{print $6,$7,$8,$9}')
-save_date=$(date -j -f "%b %e %T %Y" "${save_date}" +"%Y%m%d%H%M.%S")
-# later
-touch -t ${save_date} ${target}
-
-
-# detect NULL bytes in a file
-file=
-hexdump -e '"%_u\n"' ${file}|grep -q '^nul$'
-if [ $? -eq 0 ]; then
-else
-fi
-
-
-# calculate average
-cd /tmp
-uudecode
-begin 644 bc.average
-M<V-A;&4],PIT;W1A;#TP"F-O=6YT/3`*=VAI;&4@*#$I('L*("`@(&YU;2`]
-M(')E860H*0H@("`@:68@*&YU;2`]/2`P*2!B<F5A:SL*("`@(&-O=6YT*RL*
-M("`@('1O=&%L("L](&YU;0I]"B)T;W1A;"`]("([('1O=&%L"B)C;W5N="`]
-K("([(&-O=6YT"B)A=F5R86=E(#T@(CL@=&]T86P@+R!C;W5N=`IQ=6ET"@``
-`
-end
-(cat data; echo "0") |bc -q bc.average
-
-
+++ /dev/null
-
-# find out the location where this script is running from. this will not
-# work properly in a bash script that is included via 'source' or '.'.
-# the first letter of each command is escaped to eliminate the danger of
-# personal aliases or functions disrupting the results.
-ORIGINATING_FOLDER="$( \cd "$(\dirname "$0")" && /bin/pwd )"
-
-# another slightly tighter version:
-export WORKDIR="$( \cd "$(\dirname "$0")" && \pwd )" # obtain the script's working directory.
-
+++ /dev/null
-
-"c:/Program Files (x86)/Microsoft Visual Studio 10.0/Common7/Tools/vsvars32.bat"
+++ /dev/null
-//
-// Title: C++ Grammar Lexer support compilation unit.
-//
-// File Name: CxxLexer.cpp
-//
-// Author: E.D.Willink
-//END
-//
-#include <CxxLexer.cxx>
+++ /dev/null
-/*
- * Title: Miniature lexer for C++ parser.
- *
- * File Name: CxxLexer.l
- *
- * Author: E.D.Willink
- *
- * This is a complete lexer for C++, intended for use with CxxParser.y.
- * All actions are done by macros, so that there is some chance that customisation
- * can be performed within the bounds of the CxxLexing.hxx and CxxLexing.cxx
- * include files.
- *END
- */
-%{
-#include <CxxLexing.hxx>
-%}
-%a 5000
-%e 1500
-%n 1000
-%o 10000
-%p 10000
-ws [ \f\v\t]
-
-digit [0-9]
-hex [0-9A-Fa-f]
-letter [A-Z_a-z]
-simple_escape_sequence (\\\'|\\\"|\\\?|\\\\|\\a|\\b|\\f|\\n|\\r|\\t|\\v)
-octal_escape_sequence (\\[0-7]|\\[0-7][0-7]|\\[0-7][0-7][0-7])
-hexadecimal_escape_sequence (\\x{hex}+)
-escape_sequence ({simple_escape_sequence}|{octal_escape_sequence}|{hexadecimal_escape_sequence})
-universal_character_name (\\u{hex}{hex}{hex}{hex}|\\U{hex}{hex}{hex}{hex}{hex}{hex}{hex}{hex})
-non_digit ({letter}|{universal_character_name})
-identifier ({non_digit}({non_digit}|{digit})*)
-
-character_lit (L?\'([^\'\\\n]|\\.)*)
-character_literal ({character_lit}\')
-
-string_lit (L?\"([^\"\\\n]|\\.)*)
-string_literal ({string_lit}\")
-
-pp_number (\.?{digit}({digit}|{non_digit}|[eE][-+]|\.)*)
-%%
-^.*\n { LEX_SAVE_LINE(yytext, yyleng); REJECT; }
-^{ws}*"#".* { /* Throw away preprocessor lines - hopefully only #line and equivalent. */ }
-
-{character_lit}\' { LEX_CHARACTER_TOKEN(yytext, yyleng-1); };
-{character_lit}\\ { ERRMSG("End of line assumed to terminate character with trailing escape.");
- LEX_CHARACTER_TOKEN(yytext, yyleng-1); };
-{character_lit} { ERRMSG("End of line assumed to terminate character.");
- LEX_CHARACTER_TOKEN(yytext, yyleng); };
-
-{string_lit}\" { LEX_STRING_TOKEN(yytext, yyleng-1); };
-{string_lit}\\ { ERRMSG("End of line assumed to terminate string with trailing escape.");
- LEX_STRING_TOKEN(yytext, yyleng-1); };
-{string_lit} { ERRMSG("End of line assumed to terminate string.");
- LEX_STRING_TOKEN(yytext, yyleng); };
-
-"asm" { LEX_STATIC_TOKEN(ASM); }
-"auto" { LEX_STATIC_TOKEN(AUTO); }
-"bool" { LEX_C_STATIC_TOKEN(BOOL); }
-"break" { LEX_STATIC_TOKEN(BREAK); }
-"case" { LEX_STATIC_TOKEN(CASE); }
-"catch" { LEX_C_STATIC_TOKEN(CATCH); }
-"char" { LEX_STATIC_TOKEN(CHAR); }
-"class" { LEX_C_STATIC_TOKEN(CLASS); }
-"const" { LEX_STATIC_TOKEN(CONST); }
-"const_cast" { LEX_C_STATIC_TOKEN(CONST_CAST); }
-"continue" { LEX_STATIC_TOKEN(CONTINUE); }
-"default" { LEX_STATIC_TOKEN(DEFAULT); }
-"delete" { LEX_C_STATIC_TOKEN(DELETE); }
-"do" { LEX_STATIC_TOKEN(DO); }
-"double" { LEX_STATIC_TOKEN(DOUBLE); }
-"dynamic_cast" { LEX_C_STATIC_TOKEN(DYNAMIC_CAST); }
-"else" { LEX_STATIC_TOKEN(ELSE); }
-"enum" { LEX_STATIC_TOKEN(ENUM); }
-"explicit" { LEX_C_STATIC_TOKEN(EXPLICIT); }
-"export" { LEX_C_STATIC_TOKEN(EXPORT); }
-"extern" { LEX_STATIC_TOKEN(EXTERN); }
-"false" { LEX_C_STATIC_TOKEN(FALSE); }
-"float" { LEX_STATIC_TOKEN(FLOAT); }
-"for" { LEX_STATIC_TOKEN(FOR); }
-"friend" { LEX_STATIC_TOKEN(FRIEND); }
-"goto" { LEX_STATIC_TOKEN(GOTO); }
-"if" { LEX_STATIC_TOKEN(IF); }
-"inline" { LEX_C_STATIC_TOKEN(INLINE); }
-"int" { LEX_STATIC_TOKEN(INT); }
-"long" { LEX_STATIC_TOKEN(LONG); }
-"mutable" { LEX_C_STATIC_TOKEN(MUTABLE); }
-"namespace" { LEX_C_STATIC_TOKEN(NAMESPACE); }
-"new" { LEX_C_STATIC_TOKEN(NEW); }
-"operator" { LEX_C_STATIC_TOKEN(OPERATOR); }
-"private" { LEX_C_STATIC_TOKEN(PRIVATE); }
-"protected" { LEX_C_STATIC_TOKEN(PROTECTED); }
-"public" { LEX_C_STATIC_TOKEN(PUBLIC); }
-"register" { LEX_STATIC_TOKEN(REGISTER); }
-"reinterpret_cast" { LEX_C_STATIC_TOKEN(REINTERPRET_CAST); }
-"return" { LEX_STATIC_TOKEN(RETURN); }
-"short" { LEX_STATIC_TOKEN(SHORT); }
-"signed" { LEX_C_STATIC_TOKEN(SIGNED); }
-"sizeof" { LEX_STATIC_TOKEN(SIZEOF); }
-"static" { LEX_STATIC_TOKEN(STATIC); }
-"static_cast" { LEX_C_STATIC_TOKEN(STATIC_CAST); }
-"struct" { LEX_STATIC_TOKEN(STRUCT); }
-"switch" { LEX_STATIC_TOKEN(SWITCH); }
-"template" { LEX_C_STATIC_TOKEN(TEMPLATE); }
-"this" { LEX_C_STATIC_TOKEN(THIS); }
-"throw" { LEX_C_STATIC_TOKEN(THROW); }
-"true" { LEX_C_STATIC_TOKEN(TRUE); }
-"try" { LEX_C_STATIC_TOKEN(TRY); }
-"typedef" { LEX_STATIC_TOKEN(TYPEDEF); }
-"typeid" { LEX_C_STATIC_TOKEN(TYPEID); }
-"typename" { LEX_C_STATIC_TOKEN(TYPENAME); }
-"union" { LEX_STATIC_TOKEN(UNION); }
-"unsigned" { LEX_STATIC_TOKEN(UNSIGNED); }
-"using" { LEX_C_STATIC_TOKEN(USING); }
-"virtual" { LEX_STATIC_TOKEN(VIRTUAL); }
-"void" { LEX_STATIC_TOKEN(VOID); }
-"volatile" { LEX_STATIC_TOKEN(VOLATILE); }
-"wchar_t" { LEX_C_STATIC_TOKEN(WCHAR_T); }
-"while" { LEX_STATIC_TOKEN(WHILE); }
-
-"::" { LEX_C_STATIC_TOKEN(SCOPE); }
-"..." { LEX_STATIC_TOKEN(ELLIPSIS); }
-"<<" { LEX_STATIC_TOKEN(SHL); }
-">>" { LEX_STATIC_TOKEN(SHR); }
-"==" { LEX_STATIC_TOKEN(EQ); }
-"!=" { LEX_STATIC_TOKEN(NE); }
-"<=" { LEX_STATIC_TOKEN(LE); }
-">=" { LEX_STATIC_TOKEN(GE); }
-"&&" { LEX_STATIC_TOKEN(LOG_AND); }
-"||" { LEX_STATIC_TOKEN(LOG_OR); }
-"++" { LEX_STATIC_TOKEN(INC); }
-"--" { LEX_STATIC_TOKEN(DEC); }
-"->*" { LEX_STATIC_TOKEN(ARROW_STAR); }
-"->" { LEX_STATIC_TOKEN(ARROW); }
-".*" { LEX_STATIC_TOKEN(DOT_STAR); }
-"+=" { LEX_STATIC_TOKEN(ASS_ADD); }
-"-=" { LEX_STATIC_TOKEN(ASS_SUB); }
-"*=" { LEX_STATIC_TOKEN(ASS_MUL); }
-"/=" { LEX_STATIC_TOKEN(ASS_DIV); }
-"%=" { LEX_STATIC_TOKEN(ASS_MOD); }
-"^=" { LEX_STATIC_TOKEN(ASS_XOR); }
-"&=" { LEX_STATIC_TOKEN(ASS_AND); }
-"|=" { LEX_STATIC_TOKEN(ASS_OR); }
-">>=" { LEX_STATIC_TOKEN(ASS_SHR); }
-"<<=" { LEX_STATIC_TOKEN(ASS_SHL); }
-
-{pp_number} { LEX_NUMBER_TOKEN(yytext, yyleng); }
-
-{identifier} { LEX_IDENTIFIER_TOKEN(yytext, yyleng); }
-
-{escape_sequence} |
-{universal_character_name} { LEX_ESCAPED_TOKEN(yytext, yyleng); }
-
-\n |
-{ws}+ { /* Throw away whitespace */ }
-. { LEX_ASCII_TOKEN(yytext[0]); }
-
-%%
-#include <CxxLexing.cxx>
+++ /dev/null
-#ifdef FLEX_PP_CLASS
-FLEX_PP_CLASS theLexer;
-#define LEX_DOT theLexer .
-#else
-#define LEX_DOT
-#endif
-
-bool c_keywords = false;
-bool echo_line_numbers = false;
-bool echo_line_text = false;
-size_t line_number = 0;
-
-#ifdef NEEDS_YYWRAP
-int yywrap() { return 1; }
-#endif
-
-CxxToken *yylex_token()
-{
- if (!LEX_DOT yylex())
- return 0;
- return yyToken;
-}
-
-//
-// Configure the lexer to reflect successful parsing of a character value, assigning it to yylval.
-//
-// The source someText[aLength] should correspond to the parsed text including any L or ' prefix
-// but excluding any ' suffix. In this way the return can indicate whether a wide character has
-// been detected and the routine can accommodate a variety of erroneous terminations.
-//
-CxxToken *make_character(const char *someText, size_t aLength)
-{
- bool isWide = false;
- if (someText && aLength)
- {
- if (*someText == 'L')
- {
- isWide = true;
- someText++;
- aLength--;
- }
- if (!aLength || (*someText != '\''))
- ERRMSG("BUG - bad start of character literal.");
- if (aLength)
- {
- someText++;
- aLength--;
- }
- }
- if (isWide)
- return make_wide_character(someText, aLength);
- else
- return make_narrow_character(someText, aLength);
-}
-
-CxxToken *make_identifier(const char *someText, size_t aLength)
-{
- return new CxxNaffToken(PARSE_TOKEN(Identifier), someText, aLength);
-}
-
-//
-// Buffer the incoming line, before any characters are analysed.
-//
-void make_line(const char *yyText, size_t yyLeng)
-{
- if (echo_line_text)
- cout << tokenMarkDepth << ": " << line_number << ": " << yyText << flush;
- else if (echo_line_numbers)
- cout << line_number << endl;
- line_number++ ;
-}
-
-CxxToken *make_literal_character(const char *someText, size_t aLength)
-{
- return new CxxNaffToken(PARSE_TOKEN(CharacterLiteral), someText, aLength);
-}
-
-CxxToken *make_narrow_character(const char *someText, size_t aLength)
-{
- return new CxxNaffToken(PARSE_TOKEN(CharacterLiteral), someText, aLength);
-}
-
-CxxToken *make_narrow_string(const char *someText, size_t aLength)
-{
- return new CxxNaffToken(PARSE_TOKEN(StringLiteral), someText, aLength);
-}
-
-CxxToken *make_number(const char *someText, size_t aLength)
-{
- return new CxxNaffToken(PARSE_TOKEN(IntegerLiteral), someText, aLength);
-}
-
-//
-// Configure the lexer to reflect successful parsing of a categorised string.
-//
-// The source someText[aLength] should correspond to the parsed text including any
-// L or " prefix but excluding any " suffix. In this way the return can indicate whether a wide
-// character has been detected and the routine can accommodate a variety of erroneous terminations.
-//
-CxxToken *make_string(const char *someText, size_t aLength)
-{
- bool isWide = false;
- if (someText && aLength)
- {
- if (*someText == 'L')
- {
- isWide = true;
- someText++;
- aLength--;
- }
- if (!aLength || (*someText != '"'))
- ERRMSG("BUG - bad start of string literal.");
- if (aLength)
- {
- someText++;
- aLength--;
- }
- }
- if (isWide)
- return make_wide_string(someText, aLength);
- else
- return make_narrow_string(someText, aLength);
-}
-
-//
-// Return the appropriate 1 of 256 flyweight tokens for the ASCII characters.
-//
-CxxToken *make_token(size_t tokenValue)
-{
- static CxxToken *asciiTokens[256];
- if (tokenValue >= (sizeof(asciiTokens)/sizeof(asciiTokens[0])))
- {
- ERRMSG("Cannot make_token for " << tokenValue);
- return 0;
- }
- CxxToken **p = &asciiTokens[tokenValue];
- CxxToken *theToken = *p;
- if (!theToken)
- *p = theToken = new CxxToken(tokenValue);
- return theToken;
-}
-
-CxxToken *make_wide_character(const char *someText, size_t aLength)
-{
- return new CxxNaffToken(PARSE_TOKEN(CharacterLiteral), someText, aLength);
-}
-
-CxxToken *make_wide_string(const char *someText, size_t aLength)
-{
- return new CxxNaffToken(PARSE_TOKEN(StringLiteral), someText, aLength);
-}
-
+++ /dev/null
-#include <CxxToken.hxx>
-
-#include <CxxParser.hxx>
-
-static CxxToken *yyToken;
-static CxxToken *make_character(const char *someText, size_t aLength);
-static CxxToken *make_string(const char *someText, size_t aLength);
-static CxxToken *make_identifier(const char *someText, size_t aLength);
-static void make_line(const char *yyText, size_t yyLeng);
-static CxxToken *make_literal_character(const char *someText, size_t aLength);
-static CxxToken *make_narrow_character(const char *someText, size_t aLength);
-static CxxToken *make_narrow_string(const char *someText, size_t aLength);
-static CxxToken *make_number(const char *someText, size_t aLength);
-static CxxToken *make_token(size_t aCxxToken);
-static CxxToken *make_wide_character(const char *someText, size_t aLength);
-static CxxToken *make_wide_string(const char *someText, size_t aLength);
-
-#define LEX_SAVE_LINE(yyText, yyLeng) make_line(yyText, yyLeng);
-#define LEX_ASCII_TOKEN(a) yyToken = make_token(a); return true;
-#define LEX_STATIC_TOKEN(a) static CxxToken theToken(PARSE_TOKEN(a)); yyToken = &theToken; return true;
-#define LEX_C_STATIC_TOKEN(a) \
- if (c_keywords) { LEX_IDENTIFIER_TOKEN(yytext, yyleng) } \
- else { LEX_STATIC_TOKEN(a) } return true;
-#define LEX_ESCAPED_TOKEN(yyText, yyLeng) LEX_STATIC_TOKEN(CharacterLiteral)
-// yyToken = make_literal_character(yytext, yyleng); return true;
-#define LEX_CHARACTER_TOKEN(yyText, yyLeng) LEX_STATIC_TOKEN(CharacterLiteral)
-// yyToken = make_character(yyText, yyLeng); return true;
-#define LEX_STRING_TOKEN(yyText, yyLeng) LEX_STATIC_TOKEN(StringLiteral)
-// yyToken = make_string(yyText, yyLeng); return true;
-#define LEX_IDENTIFIER_TOKEN(yyText, yyLeng) LEX_STATIC_TOKEN(Identifier)
-// yyToken = make_identifier(yyText, yyLeng); return true;
-#define LEX_NUMBER_TOKEN(yyText, yyLeng) LEX_STATIC_TOKEN(IntegerLiteral)
-// yyToken = make_number(yyText, yyLeng); return true;
+++ /dev/null
-//
-// Title: C++ Grammar Parser support compilation unit.
-//
-// File Name: CxxParser.cpp
-//
-// Author: E.D.Willink
-//END
-//
-#include <CxxParser.cxx>
-
+++ /dev/null
-/* This is a yacc-able parser for the entire ISO C++ grammar with no unresolved conflicts. */
-/* The parse is SYNTACTICALLY consistent and requires no template or type name assistance.
- * The grammar in the C++ standard notes that its grammar is a superset of the true
- * grammar requiring semantic constraints to resolve ambiguities. This grammar is a really big
- * superset unifying expressions and declarations, eliminating the type/non-type distinction,
- * and iterating to find a consistent solution to the template/arith,metoic < ambiguity.
- * As a result the grammar is much simpler, but requires the missing semantic constraints to be
- * performed in a subsequent semantic pass, which is of course where they belong. This grammar will
- * support conversion of C++ tokens into an Abstract Syntax Tree. A lot of further work is required to
- * make that tree useful.
- *
- * The principles behind this grammar are described in my thesis on Meta-Compilation for C++, which
- * may be found via http://www.computing.surrey.ac.uk/research/dsrg/fog/FogThesis.html.
- *
- * Author: E.D.Willink Ed.Willink@rrl.co.uk
- * Date: 19-Jun-2001
- */
-/*StartTester*/
-%{
-#include <CxxParsing.hxx>
-%}
-/*EndTester*/
-/*
- * The lexer (and/or a preprocessor) is expected to identify the following
- *
- * Punctuation:
- */
-%type <keyword> '+' '-' '*' '/' '%' '^' '&' '|' '~' '!' '<' '>' '=' ':' '[' ']' '{' '}' '(' ')'
-%type <keyword> '?' '.' '\'' '\"' '\\' '@' '$' ';' ','
-/*
- * Punctuation sequences
- */
-%term <keyword> ARROW ARROW_STAR DEC EQ GE INC LE LOG_AND LOG_OR NE SHL SHR
-%term <keyword> ASS_ADD ASS_AND ASS_DIV ASS_MOD ASS_MUL ASS_OR ASS_SHL ASS_SHR ASS_SUB ASS_XOR
-%term <keyword> DOT_STAR ELLIPSIS SCOPE
-/*
- * Reserved words
- */
-%term <access_specifier> PRIVATE PROTECTED PUBLIC
-%term <built_in_id> BOOL CHAR DOUBLE FLOAT INT LONG SHORT SIGNED UNSIGNED VOID WCHAR_T
-%term <class_key> CLASS ENUM NAMESPACE STRUCT TYPENAME UNION
-%term <cv_qualifiers> CONST VOLATILE
-%term <decl_specifier_id> AUTO EXPLICIT EXPORT EXTERN FRIEND INLINE MUTABLE REGISTER STATIC TEMPLATE TYPEDEF USING VIRTUAL
-%term <keyword> ASM BREAK CASE CATCH CONST_CAST CONTINUE DEFAULT DELETE DO DYNAMIC_CAST
-%term <keyword> ELSE FALSE FOR GOTO IF NEW OPERATOR REINTERPRET_CAST RETURN
-%term <keyword> SIZEOF STATIC_CAST SWITCH THIS THROW TRUE TRY TYPEID WHILE
-/*
- * Parametric values.
- */
-%term <character_literal> CharacterLiteral
-%term <floating_literal> FloatingLiteral
-%term <identifier> Identifier
-%term <integer_literal> IntegerLiteral
-%term <number_literal> NumberLiteral
-%term <string_literal> StringLiteral
-/*
- * The lexer need not treat '0' as distinct from IntegerLiteral in the hope that pure-specifier can
- * be distinguished, It isn't. Semantic rescue from = constant-expression is necessary.
- *
- * The lexer is not required to distinguish template or type names, although a slight simplification to the
- * grammar and elaboration of the action rules could make good use of template name information.
- *
- * In return for not needing to use semantic information, the lexer must support back-tracking, which
- * is easily achieved by a simple linear buffer, a reference implementation of which may be found in the
- * accompanying CxxParsing.cxx. Back-tracking is used to support:
- *
- * Binary search for a consistent parse of the template/arithmetic ambiguity.
- * start_search() initialises the search
- * advance_search() iterates the search
- * end_search() cleans up after a search
- * template_test() maintains context during a search
- *
- * Lookahead to resolve the inheritance/anonymous bit-field similarity
- * mark() saves the starting context
- * unmark() pops it
- * rewind_colon() restores the context and forces the missing :
- *
- * Lookahead to resolve type 1 function parameter ambiguities
- * mark_type1() potentially marks the starting position
- * mark() marks the pre { position
- * remark() rewinds to the starting position
- * unmark() pops the starting position
- *
- * Note that lookaheads may nest.
- */
-
-/*
- * The parsing philosophy is unusual. The major ambiguities are resolved by creating a unified superset
- * grammar rather than non-overlapping subgrammars. Thus the grammar for parameter-declaration covers an
- * assignment-expression. Minor ambiguities whose resolution by supersetting would create more
- * ambiguities are resolved the normal way with partitioned subgrammars.
- * This eliminates the traditional expression/declaration and constructor/parenthesised declarator
- * ambiguities at the syntactic level. A subsequent semantic level has to sort the problems out.
- * The generality introduces four bogus ambiguities and defers the cast ambiguity for resolution
- * once semantic information is available.
- *
- * The C++ grammar comprises 561 rules and uses 897 states in yacc, with 0 unresolved conflicts.
- * 23 conflicts from 10 ambiguities are resolved by 8 %prec's, so that yacc and bison report 0 conflicts.
- *
- * The ambiguities are:
- * 1) dangling else resolved to inner-most if
- * 1 conflict in 1 state on else
- * 2) < as start-template or less-than
- * 1 conflict in 1 states on <
- * 3) a :: b :: c resolved to favour a::b::c rather than a::b ::c or a ::b::c
- * 1 conflicts in 1 state for ::
- * 4) pointer operators maximised at end of conversion id/new in preference to binary operators
- * 2 conflicts in 4 states on * and &
- * 5a) (a)@b resolved to favour binary a@b rather than cast unary (a)(@b)
- * 5b) (a)(b) resolved to favour cast rather than call
- * 8 conflicts in 1 state for the 8 prefix operators: 6 unaries and ( and [.
- * 6) enum name { resolved to enum-specifier rather than function
- * 1 conflict in 1 state on {
- * 7) class name { resolved to class-specifier rather than function
- * 1 conflict in 1 state on {
- * 8) extern "C" resolved to linkage-specification rather than declaration
- * 1 conflict in 1 state on StringLiteral
- * 9) class X : forced to go through base-clause look-ahead
- * 1 conflict in 1 state on :
- * 10) id : forced to label_statement rather than constructor_head
- * 0 conflicts - but causes a double state for 2)
- * of which
- * 1 is a fundamental C conflict - always correctly resolved
- * can be removed - see the Java spec
- * 2, 3, 4 are fundamental C++ conflicts
- * 2 always consistently resolved by iteration
- * 3 always correctly resolved
- * 4 always correctly resolved
- * 5 is a result of not using type information - deferred for semantic repair
- * 6,7 are caused by parsing over-generous superset - always correctly resolved
- * 8 is caused by parsing over-generous superset - always correctly resolved
- * can be removed at the expense of 7 rules and 5 states.
- * 9 is a look-ahead trick - always correctly resolved
- * could be removed by marking one token sooner
- * 10 is caused by parsing over-generous superset - always correctly resolved
- *
- * The hard problem of distinguishing
- * class A { class B : C, D, E { -- A::B privately inherits C, D and E
- * class A { class B : C, D, E ; -- C is width of anon bit-field
- * is resolved by using a lookahead that assumes inheritance and rewinds for the bit-field.
- *
- * The potential shift-reduce conflict on > is resolved by flattening part of the expression grammar
- * to know when the next > is template end or arithmetic >.
- *
- * The grammar is SYNTACTICALLY context-free with respect to type. No semantic assistance is required
- * during syntactic analysis. However the cast ambiguity is deferred and must be recovered
- * after syntactic analysis of a statement has completed.
- *
- * The grammar is SYNTACTICALLY context-free with respect to template-names. This is achieved by
- * organising a binary search over all possible template/arithmetic ambiguities with respect to
- * the enclosing statement. This is potentially exponentially inefficient but well-behaved in practice.
- * Approximately 1% of statements trigger a search and approximately 1% of those are misparsed,
- * requiring the semantic analysis to check and correct once template information is available.
- * 1.5 parse attempts are required on average per ambiguous statement.
- *
- * The grammar supports type I function declarations at severe impediment to efficiency. A lookahead
- * has to be performed after almost every non-statement close parenthesis. A one-line plus corollary
- * change to postfix_expression is commented and strongly recommended to make this grammar as
- * efficient as the rather large number of reduction levels permits.
- *
- * Error recovery occurs mostly at the statement/declaration level. Recovery also occurs at
- * the list-element level where this poses no hazard to statement/declaration level recovery.
- * Note that since error propagation interacts with the lookaheads for template iteration or
- * type 1 function arguments, introduction of finer grained error recovery may repair a false
- * parse and so cause a misparse.
- *
- * The following syntactic analysis errors occur, but are correctable semantically:
- * (cast)unary-op expr is parsed as (parenthesised)binary-op expr
- * The semantic test should look for a binary/call with a (type) as its left child.
- * (parenthesised)(arguments) is parsed as (cast)(parenthesised)
- * The semantic test should look for a cast with a non-type as its left child.
- * template < and arithmetic < may be cross-parsed (unless semnatic help is provided)
- * approximately 0.01% are misparsed, and must be sorted out - not easy.
- *
- * The syntactic analysis defers the following ambiguities for semantic resolution:
- * declaration/expression is parsed as a unified concept
- * Use type and context to complete the parse.
- * ~class-name is parsed as unary~ name
- * The semantic test should look for ~ with a type as its child.
- * delete[] expr is parsed as delete []expr
- * The semantic test should look for delete with a [] cast of its child.
- * operator new/delete[] are parsed as array of operator new/delete
- * The semantic test should look for array of operator new/delete
- * or activate the two extra commented rules in operator
- * template of an explicit_instantiation is buried deep in the tree
- * dig it out
- * pure-specifier and constant-initializer are covered by assignment-expression
- * just another of the deferred declaration/expression ambiguities
- * sizeof and typeid don't distinguish type/value syntaxes
- * probably makes life polymorphically easier
- */
-/* Action code is supplied by a large number of YACC_xxx macros that can be redefined
- * by rewriting the include file rather than the grammar. The number of macros is
- * slightly reduced by using the following protocols
- *
- * YACC_LIST(0,0) create empty list (may safely return 0).
- * YACC_LIST(0,E) create new list with content E (may return 0 if above returned non-0).
- * YACC_LIST(L,E) add E to L
- * YACC_LIST(L,0) error propagation, adding nothing to L.
- */
-%type <bang> bang
-%type <mark> colon_mark mark mark_type1
-%type <nest> nest
-
-%type <access_specifier> access_specifier
-%type <base_specifier> base_specifier
-%type <base_specifiers> base_specifier_list
-%type <built_in_id> built_in_type_id built_in_type_specifier
-%type <_class> class_specifier_head
-%type <class_key> class_key
-%type <condition> condition condition.opt
-%type <cv_qualifiers> cv_qualifier cv_qualifier_seq.opt
-%type <decl_specifier_id> decl_specifier_affix decl_specifier_prefix decl_specifier_suffix function_specifier storage_class_specifier
-%type <declaration> accessibility_specifier asm_definition block_declaration declaration explicit_specialization
-%type <declaration> looped_declaration looping_declaration namespace_alias_definition
-%type <declaration> specialised_block_declaration specialised_declaration template_declaration using_directive
-%type <declarations> compound_declaration declaration_seq.opt
-%type <declarator> nested_ptr_operator ptr_operator
-%type <delete_expression> delete_expression
-%type <enumerator> enumerator_definition
-%type <enumerators> enumerator_clause enumerator_list enumerator_list_head
-%type <exception_declaration> exception_declaration
-%type <exception_specification> exception_specification
-%type <expression> abstract_declarator.opt abstract_expression abstract_parameter_declaration abstract_pointer_declaration
-%type <expression> additive_expression and_expression assignment_expression
-%type <expression> bit_field_declaration bit_field_init_declaration bit_field_width boolean_literal
-%type <expression> cast_expression conditional_expression constant_expression conversion_type_id ctor_definition
-%type <expression> direct_abstract_declarator direct_abstract_declarator.opt direct_new_declarator
-%type <expression> equality_expression exclusive_or_expression expression expression.opt
-%type <expression> for_init_statement func_definition function_definition
-%type <expression> inclusive_or_expression init_declaration literal logical_and_expression logical_or_expression
-%type <expression> multiplicative_expression new_declarator new_type_id
-%type <expression> pm_expression postfix_expression primary_expression ptr_operator_seq ptr_operator_seq.opt
-%type <expression> relational_expression shift_expression simple_declaration special_parameter_declaration
-%type <expression> templated_throw_expression throw_expression templated_abstract_declaration templated_and_expression
-%type <expression>templated_assignment_expression templated_conditional_expression templated_equality_expression
-%type <expression> templated_exclusive_or_expression templated_expression templated_inclusive_or_expression templated_logical_and_expression
-%type <expression> templated_logical_or_expression templated_relational_expression type_id unary_expression
-%type <expressions> constructor_head expression_list expression_list.opt init_declarations
-%type <expressions> new_initializer.opt templated_expression_list type_id_list
-%type <function_body> function_block function_body function_try_block try_block
-%type <handler> handler
-%type <handlers> handler_seq
-%type <initializer_clause> braced_initializer initializer_clause looped_initializer_clause looping_initializer_clause
-%type <initializer_clauses> initializer_list
-%type <is_template> global_scope
-%type <keyword> assignment_operator
-%type <line> start_search start_search1
-%type <mem_initializer> mem_initializer
-%type <mem_initializers> ctor_initializer ctor_initializer.opt mem_initializer_list mem_initializer_list_head
-%type <name> class_specifier conversion_function_id declarator_id destructor_id
-%type <name> elaborated_class_specifier elaborated_enum_specifier elaborated_type_specifier elaborate_type_specifier
-%type <name> enum_specifier enumerator id identifier_word id_scope identifier linkage_specification
-%type <name> namespace_definition nested_id nested_pseudo_destructor_id nested_special_function_id
-%type <name> mem_initializer_id operator operator_function_id pseudo_destructor_id scoped_id scoped_pseudo_destructor_id scoped_special_function_id
-%type <name> simple_type_specifier special_function_id suffix_built_in_decl_specifier suffix_named_decl_specifier.bi
-%type <name> suffix_built_in_decl_specifier.raw suffix_decl_specified_ids suffix_named_decl_specifiers
-%type <name> suffix_named_decl_specifiers.sf suffix_decl_specified_scope suffix_named_decl_specifier
-%type <name> template_id type_specifier
-%type <new_expression> new_expression
-%type <parameter> parameter_declaration templated_parameter_declaration
-%type <parameters> parameters_clause parameter_declaration_clause parameter_declaration_list
-%type <parenthesised> parenthesis_clause
-%type <pointer_declarator> star_ptr_operator
-%type <simple_type_parameter> simple_type_parameter
-%type <statement> compound_statement control_statement declaration_statement iteration_statement jump_statement
-%type <statement> labeled_statement looped_statement looping_statement selection_statement statement
-%type <statements> statement_seq.opt
-%type <strings> string
-%type <template_argument> template_argument
-%type <template_arguments> template_argument_list
-%type <template_parameter> template_parameter
-%type <template_parameters> template_parameter_clause template_parameter_list
-%type <templated_type_parameter> templated_type_parameter
-%type <type1_parameters> type1_parameters
-%type <utility> util
-
-/*
- * C++ productions replaced by more generalised FOG productions
- */
-%type <declaration> looped_member_declaration looping_member_declaration member_declaration using_declaration
-%type <declarations> member_specification.opt
-%type <expression> member_init_declaration simple_member_declaration
-%type <expressions> member_init_declarations
-
-\f
-%nonassoc SHIFT_THERE
-%nonassoc SCOPE ELSE INC DEC '+' '-' '*' '&' '[' '{' '<' ':' StringLiteral
-%nonassoc REDUCE_HERE_MOSTLY
-%nonassoc '('
-/*%nonassoc REDUCE_HERE */
-
-%start translation_unit
-%%
-
-/*
- * The %prec resolves a conflict in identifier_word : which is forced to be a shift of a label for
- * a labeled-statement rather than a reduction for the name of a bit-field or generalised constructor.
- * This is pretty dubious syntactically but correct for all semantic possibilities.
- * The shift is only activated when the ambiguity exists at the start of a statement. In this context
- * a bit-field declaration or constructor definition are not allowed.
- */
-identifier_word: Identifier { $$ = $1; }
-identifier: identifier_word %prec SHIFT_THERE
-/*
- * The %prec resolves the $014.2-3 ambiguity:
- * Identifier '<' is forced to go through the is-it-a-template-name test
- * All names absorb TEMPLATE with the name, so that no template_test is performed for them.
- * This requires all potential declarations within an expression to perpetuate this policy
- * and thereby guarantee the ultimate coverage of explicit_instantiation.
- */
-id: identifier %prec SHIFT_THERE /* Force < through test */ { $$ = YACC_NAME($1); }
- | identifier template_test '+' template_argument_list '>' { $$ = YACC_TEMPLATE_NAME($1, $4); }
- | identifier template_test '+' '>' { $$ = $1; ERRMSG("Empty template-argument-list"); }
- | identifier template_test '-' /* requeued < follows */ { $$ = YACC_NAME($1); }
- | template_id
-template_test: '<' /* Queue '+' or '-' < as follow on */ { template_test(); }
-global_scope: SCOPE { $$ = IS_DEFAULT; }
- | TEMPLATE global_scope { $$ = IS_TEMPLATE; }
-id_scope: id SCOPE { $$ = YACC_NESTED_SCOPE($1); }
-/*
- * A :: B :: C; is ambiguous How much is type and how much name ?
- * The %prec maximises the (type) length which is the $07.1-2 semantic constraint.
- */
-nested_id: id %prec SHIFT_THERE /* Maximise length */
- | id_scope nested_id { $$ = YACC_NESTED_ID($1, $2); }
-scoped_id: nested_id
- | global_scope nested_id { $$ = YACC_GLOBAL_ID($1, $2); }
-
-/*
- * destructor_id has to be held back to avoid a conflict with a one's complement as per $05.3.1-9,
- * It gets put back only when scoped or in a declarator_id, which is only used as an explicit member name.
- * Declarations of an unscoped destructor are always parsed as a one's complement.
- */
-destructor_id: '~' id { $$ = YACC_DESTRUCTOR_ID($2); }
- | TEMPLATE destructor_id { $$ = YACC_SET_TEMPLATE_ID($2); }
-special_function_id: conversion_function_id
- | operator_function_id
- | TEMPLATE special_function_id { $$ = YACC_SET_TEMPLATE_ID($2); }
-nested_special_function_id: special_function_id
- | id_scope destructor_id { $$ = YACC_NESTED_ID($1, $2); }
- | id_scope nested_special_function_id { $$ = YACC_NESTED_ID($1, $2); }
-scoped_special_function_id: nested_special_function_id
- | global_scope nested_special_function_id { $$ = YACC_GLOBAL_ID($1, $2); }
-
-/* declarator-id is all names in all scopes, except reserved words */
-declarator_id: scoped_id
- | scoped_special_function_id
- | destructor_id
-
-/* The standard defines pseudo-destructors in terms of type-name, which is class/enum/typedef, of which
- * class-name is covered by a normal destructor. pseudo-destructors are supposed to support ~int() in
- * templates, so the grammar here covers built-in names. Other names are covered by the lack of
- * identifier/type discrimination.
- */
-built_in_type_id: built_in_type_specifier
- | built_in_type_id built_in_type_specifier { $$ = YACC_BUILT_IN_IDS($1, $2); }
-pseudo_destructor_id: built_in_type_id SCOPE '~' built_in_type_id { $$ = YACC_PSEUDO_DESTRUCTOR_ID($1, $4); }
- | '~' built_in_type_id { $$ = YACC_PSEUDO_DESTRUCTOR_ID(0, $2); }
- | TEMPLATE pseudo_destructor_id { $$ = YACC_SET_TEMPLATE_ID($2); }
-nested_pseudo_destructor_id: pseudo_destructor_id
- | id_scope nested_pseudo_destructor_id { $$ = YACC_NESTED_ID($1, $2); }
-scoped_pseudo_destructor_id: nested_pseudo_destructor_id
- | global_scope scoped_pseudo_destructor_id { $$ = YACC_GLOBAL_ID($1, $2); }
-
-/*---------------------------------------------------------------------------------------------------
- * A.2 Lexical conventions
- *---------------------------------------------------------------------------------------------------*/
-/*
- * String concatenation is a phase 6, not phase 7 activity so does not really belong in the grammar.
- * However it may be convenient to have it here to make this grammar fully functional.
- * Unfortunately it introduces a conflict with the generalised parsing of extern "C" which
- * is correctly resolved to maximise the string length as the token source should do anyway.
- */
-string: StringLiteral { $$ = $1; }
-/*string: StringLiteral %prec SHIFT_THERE { $$ = YACC_STRINGS($1, 0); } */
-/* | StringLiteral string -- Perverse order avoids conflicts -- { $$ = YACC_STRINGS($1, $2); } */
-literal: IntegerLiteral { $$ = YACC_INTEGER_LITERAL_EXPRESSION($1); }
- | CharacterLiteral { $$ = YACC_CHARACTER_LITERAL_EXPRESSION($1); }
- | FloatingLiteral { $$ = YACC_FLOATING_LITERAL_EXPRESSION($1); }
- | string { $$ = YACC_STRING_LITERAL_EXPRESSION($1); }
- | boolean_literal
-boolean_literal: FALSE { $$ = YACC_FALSE_EXPRESSION(); }
- | TRUE { $$ = YACC_TRUE_EXPRESSION(); }
-
-/*---------------------------------------------------------------------------------------------------
- * A.3 Basic concepts
- *---------------------------------------------------------------------------------------------------*/
-translation_unit: declaration_seq.opt { YACC_RESULT($1); }
-
-/*---------------------------------------------------------------------------------------------------
- * A.4 Expressions
- *---------------------------------------------------------------------------------------------------
- * primary_expression covers an arbitrary sequence of all names with the exception of an unscoped destructor,
- * which is parsed as its unary expression which is the correct disambiguation (when ambiguous).
- * This eliminates the traditional A(B) meaning A B ambiguity, since we never have to tack an A onto
- * the front of something that might start with (. The name length got maximised ab initio. The downside
- * is that semantic interpretation must split the names up again.
- *
- * Unification of the declaration and expression syntax means that unary and binary pointer declarator operators:
- * int * * name
- * are parsed as binary and unary arithmetic operators (int) * (*name). Since type information is not used
- * ambiguities resulting from a cast
- * (cast)*(value)
- * are resolved to favour the binary rather than the cast unary to ease AST clean-up.
- * The cast-call ambiguity must be resolved to the cast to ensure that (a)(b)c can be parsed.
- *
- * The problem of the functional cast ambiguity
- * name(arg)
- * as call or declaration is avoided by maximising the name within the parsing kernel. So
- * primary_id_expression picks up
- * extern long int const var = 5;
- * as an assignment to the syntax parsed as "extern long int const var". The presence of two names is
- * parsed so that "extern long into const" is distinguished from "var" considerably simplifying subsequent
- * semantic resolution.
- *
- * The generalised name is a concatenation of potential type-names (scoped identifiers or built-in sequences)
- * plus optionally one of the special names such as an operator-function-id, conversion-function-id or
- * destructor as the final name.
- */
-primary_expression: literal
- | THIS { $$ = YACC_THIS_EXPRESSION(); }
- | suffix_decl_specified_ids { $$ = $1; }
-/* | SCOPE identifier -- covered by suffix_decl_specified_ids */
-/* | SCOPE operator_function_id -- covered by suffix_decl_specified_ids */
-/* | SCOPE qualified_id -- covered by suffix_decl_specified_ids */
- | abstract_expression %prec REDUCE_HERE_MOSTLY /* Prefer binary to unary ops, cast to call */
-/* | id_expression -- covered by suffix_decl_specified_ids */
-
-/*
- * Abstract-expression covers the () and [] of abstract-declarators.
- */
-abstract_expression: parenthesis_clause { $$ = YACC_ABSTRACT_FUNCTION_EXPRESSION($1); }
- | '[' expression.opt ']' { $$ = YACC_ABSTRACT_ARRAY_EXPRESSION($2); }
- | TEMPLATE parenthesis_clause { $$ = YACC_SET_TEMPLATE_EXPRESSION(YACC_ABSTRACT_FUNCTION_EXPRESSION($2)); }
-
-/* Type I function parameters are ambiguous with respect to the generalised name, so we have to do a lookahead following
- * any function-like parentheses. This unfortunately hits normal code, so kill the -- lines and add the ++ lines for efficiency.
- * Supporting Type I code under the superset causes perhaps 25% of lookahead parsing. Sometimes complete class definitions
- * get traversed since they are valid generalised type I parameters!
- */
-type1_parameters: /*----*/ parameter_declaration_list ';' { $$ = YACC_TYPE1_PARAMETERS(0, $1); }
- | /*----*/ type1_parameters parameter_declaration_list ';' { $$ = YACC_TYPE1_PARAMETERS($1, $2); }
-mark_type1: /* empty */ { $$ = mark_type1(); }
-postfix_expression: primary_expression
-/* | /++++++/ postfix_expression parenthesis_clause { $$ = YACC_CALL_EXPRESSION($1, $2); } */
- | /*----*/ postfix_expression parenthesis_clause mark_type1 '-' { $$ = YACC_CALL_EXPRESSION($1, $2); }
- | /*----*/ postfix_expression parenthesis_clause mark_type1 '+' type1_parameters mark '{' error
- /*----*/ { yyerrok; remark_type1($6); unmark(); unmark($5); $$ = YACC_TYPE1_EXPRESSION($1, $2, $5); }
- | /*----*/ postfix_expression parenthesis_clause mark_type1 '+' type1_parameters mark error
- /*----*/ { yyerrok; remark_type1($3); unmark(); unmark(); $$ = YACC_CALL_EXPRESSION($1, $2); }
- | /*----*/ postfix_expression parenthesis_clause mark_type1 '+' error
- /*----*/ { yyerrok; remark_type1($3); unmark(); $$ = YACC_CALL_EXPRESSION($1, $2); }
- | postfix_expression '[' expression.opt ']' { $$ = YACC_ARRAY_EXPRESSION($1, $3); }
-/* | destructor_id '[' expression.opt ']' -- not semantically valid */
-/* | destructor_id parenthesis_clause -- omitted to resolve known ambiguity */
-/* | simple_type_specifier '(' expression_list.opt ')' -- simple_type_specifier is a primary_expression */
- | postfix_expression '.' declarator_id { $$ = YACC_DOT_EXPRESSION($1, $3); }
-/* | postfix_expression '.' TEMPLATE declarator_id -- TEMPLATE absorbed into declarator_id. */
- | postfix_expression '.' scoped_pseudo_destructor_id { $$ = YACC_DOT_EXPRESSION($1, $3); }
- | postfix_expression ARROW declarator_id { $$ = YACC_ARROW_EXPRESSION($1, $3); }
-/* | postfix_expression ARROW TEMPLATE declarator_id -- TEMPLATE absorbed into declarator_id. */
- | postfix_expression ARROW scoped_pseudo_destructor_id { $$ = YACC_ARROW_EXPRESSION($1, $3); }
- | postfix_expression INC { $$ = YACC_POST_INCREMENT_EXPRESSION($1); }
- | postfix_expression DEC { $$ = YACC_POST_DECREMENT_EXPRESSION($1); }
- | DYNAMIC_CAST '<' type_id '>' '(' expression ')' { $$ = YACC_DYNAMIC_CAST_EXPRESSION($3, $6); }
- | STATIC_CAST '<' type_id '>' '(' expression ')' { $$ = YACC_STATIC_CAST_EXPRESSION($3, $6); }
- | REINTERPRET_CAST '<' type_id '>' '(' expression ')' { $$ = YACC_REINTERPRET_CAST_EXPRESSION($3, $6); }
- | CONST_CAST '<' type_id '>' '(' expression ')' { $$ = YACC_CONST_CAST_EXPRESSION($3, $6); }
- | TYPEID parameters_clause { $$ = YACC_TYPEID_EXPRESSION($2); }
-/* | TYPEID '(' expression ')' -- covered by parameters_clause */
-/* | TYPEID '(' type_id ')' -- covered by parameters_clause */
-expression_list.opt: /* empty */ { $$ = YACC_EXPRESSIONS(0, 0); }
- | expression_list
-expression_list: assignment_expression { $$ = YACC_EXPRESSIONS(0, $1); }
- | expression_list ',' assignment_expression { $$ = YACC_EXPRESSIONS($1, $3); }
-
-unary_expression: postfix_expression
- | INC cast_expression { $$ = YACC_PRE_INCREMENT_EXPRESSION($2); }
- | DEC cast_expression { $$ = YACC_PRE_DECREMENT_EXPRESSION($2); }
- | ptr_operator cast_expression { $$ = YACC_POINTER_EXPRESSION($1, $2); }
-/* | '*' cast_expression -- covered by ptr_operator */
-/* | '&' cast_expression -- covered by ptr_operator */
-/* | decl_specifier_seq '*' cast_expression -- covered by binary operator */
-/* | decl_specifier_seq '&' cast_expression -- covered by binary operator */
- | suffix_decl_specified_scope star_ptr_operator cast_expression /* covers e.g int ::type::* const t = 4 */
- { $$ = YACC_SCOPED_POINTER_EXPRESSION($1, $2, $3); }
- | '+' cast_expression { $$ = YACC_PLUS_EXPRESSION($2); }
- | '-' cast_expression { $$ = YACC_MINUS_EXPRESSION($2); }
- | '!' cast_expression { $$ = YACC_NOT_EXPRESSION($2); }
- | '~' cast_expression { $$ = YACC_COMPLEMENT_EXPRESSION($2); }
- | SIZEOF unary_expression { $$ = YACC_SIZEOF_EXPRESSION($2); }
-/* | SIZEOF '(' type_id ')' -- covered by unary_expression */
- | new_expression { $$ = $1; }
- | global_scope new_expression { $$ = YACC_GLOBAL_EXPRESSION($1, $2); }
- | delete_expression { $$ = $1; }
- | global_scope delete_expression { $$ = YACC_GLOBAL_EXPRESSION($1, $2); }
-/* | DELETE '[' ']' cast_expression -- covered by DELETE cast_expression since cast_expression covers ... */
-/* | SCOPE DELETE '[' ']' cast_expression // ... abstract_expression cast_expression and so [] cast_expression */
-
-delete_expression: DELETE cast_expression /* also covers DELETE[] cast_expression */
- { $$ = YACC_DELETE_EXPRESSION($2); }
-new_expression: NEW new_type_id new_initializer.opt { $$ = YACC_NEW_TYPE_ID_EXPRESSION(0, $2, $3); }
- | NEW parameters_clause new_type_id new_initializer.opt { $$ = YACC_NEW_TYPE_ID_EXPRESSION($2, $3, $4); }
- | NEW parameters_clause { $$ = YACC_NEW_EXPRESSION($2, 0, 0); }
-/* | NEW '(' type-id ')' -- covered by parameters_clause */
- | NEW parameters_clause parameters_clause new_initializer.opt { $$ = YACC_NEW_EXPRESSION($2, $3, $4); }
-/* | NEW '(' type-id ')' new_initializer -- covered by parameters_clause parameters_clause */
-/* | NEW parameters_clause '(' type-id ')' -- covered by parameters_clause parameters_clause */
- /* ptr_operator_seq.opt production reused to save a %prec */
-new_type_id: type_specifier ptr_operator_seq.opt { $$ = YACC_TYPED_EXPRESSION($1, $2); }
- | type_specifier new_declarator { $$ = YACC_TYPED_EXPRESSION($1, $2); }
- | type_specifier new_type_id { $$ = YACC_TYPED_EXPRESSION($1, $2); }
-new_declarator: ptr_operator new_declarator { $$ = YACC_POINTER_EXPRESSION($1, $2); }
- | direct_new_declarator
-direct_new_declarator: '[' expression ']' { $$ = YACC_ABSTRACT_ARRAY_EXPRESSION($2); }
- | direct_new_declarator '[' constant_expression ']' { $$ = YACC_ARRAY_EXPRESSION($1, $3); }
-new_initializer.opt: /* empty */ { $$ = YACC_EXPRESSIONS(0, 0); }
- | '(' expression_list.opt ')' { $$ = $2; }
-
-/* cast-expression is generalised to support a [] as well as a () prefix. This covers the omission of DELETE[] which when
- * followed by a parenthesised expression was ambiguous. It also covers the gcc indexed array initialisation for free.
- */
-cast_expression: unary_expression
- | abstract_expression cast_expression { $$ = YACC_CAST_EXPRESSION($1, $2); }
-/* | '(' type_id ')' cast_expression -- covered by abstract_expression */
-
-pm_expression: cast_expression
- | pm_expression DOT_STAR cast_expression { $$ = YACC_DOT_STAR_EXPRESSION($1, $3); }
- | pm_expression ARROW_STAR cast_expression { $$ = YACC_ARROW_STAR_EXPRESSION($1, $3); }
-multiplicative_expression: pm_expression
- | multiplicative_expression star_ptr_operator pm_expression { $$ = YACC_MULTIPLY_EXPRESSION($1, $2, $3); }
- | multiplicative_expression '/' pm_expression { $$ = YACC_DIVIDE_EXPRESSION($1, $3); }
- | multiplicative_expression '%' pm_expression { $$ = YACC_MODULUS_EXPRESSION($1, $3); }
-additive_expression: multiplicative_expression
- | additive_expression '+' multiplicative_expression { $$ = YACC_ADD_EXPRESSION($1, $3); }
- | additive_expression '-' multiplicative_expression { $$ = YACC_SUBTRACT_EXPRESSION($1, $3); }
-shift_expression: additive_expression
- | shift_expression SHL additive_expression { $$ = YACC_SHIFT_LEFT_EXPRESSION($1, $3); }
- | shift_expression SHR additive_expression { $$ = YACC_SHIFT_RIGHT_EXPRESSION($1, $3); }
-relational_expression: shift_expression
- | relational_expression '<' shift_expression { $$ = YACC_LESS_THAN_EXPRESSION($1, $3); }
- | relational_expression '>' shift_expression { $$ = YACC_GREATER_THAN_EXPRESSION($1, $3); }
- | relational_expression LE shift_expression { $$ = YACC_LESS_EQUAL_EXPRESSION($1, $3); }
- | relational_expression GE shift_expression { $$ = YACC_GREATER_EQUAL_EXPRESSION($1, $3); }
-equality_expression: relational_expression
- | equality_expression EQ relational_expression { $$ = YACC_EQUAL_EXPRESSION($1, $3); }
- | equality_expression NE relational_expression { $$ = YACC_NOT_EQUAL_EXPRESSION($1, $3); }
-and_expression: equality_expression
- | and_expression '&' equality_expression { $$ = YACC_AND_EXPRESSION($1, $3); }
-exclusive_or_expression: and_expression
- | exclusive_or_expression '^' and_expression { $$ = YACC_EXCLUSIVE_OR_EXPRESSION($1, $3); }
-inclusive_or_expression: exclusive_or_expression
- | inclusive_or_expression '|' exclusive_or_expression { $$ = YACC_INCLUSIVE_OR_EXPRESSION($1, $3); }
-logical_and_expression: inclusive_or_expression
- | logical_and_expression LOG_AND inclusive_or_expression { $$ = YACC_LOGICAL_AND_EXPRESSION($1, $3); }
-logical_or_expression: logical_and_expression
- | logical_or_expression LOG_OR logical_and_expression { $$ = YACC_LOGICAL_OR_EXPRESSION($1, $3); }
-conditional_expression: logical_or_expression
- | logical_or_expression '?' expression ':' assignment_expression
- { $$ = YACC_CONDITIONAL_EXPRESSION($1, $3, $5); }
-
-/* assignment-expression is generalised to cover the simple assignment of a braced initializer in order to contribute to the
- * coverage of parameter-declaration and init-declaration.
- */
-assignment_expression: conditional_expression
- | logical_or_expression assignment_operator assignment_expression { $$ = YACC_ASSIGNMENT_EXPRESSION($1, $2, $3); }
- | logical_or_expression '=' braced_initializer { $$ = YACC_ASSIGNMENT_EXPRESSION($1, $2, $3); }
- | throw_expression
-assignment_operator: '=' | ASS_ADD | ASS_AND | ASS_DIV | ASS_MOD | ASS_MUL | ASS_OR | ASS_SHL | ASS_SHR | ASS_SUB | ASS_XOR
-
-/* expression is widely used and usually single-element, so the reductions are arranged so that a
- * single-element expression is returned as is. Multi-element expressions are parsed as a list that
- * may then behave polymorphically as an element or be compacted to an element. */
-expression.opt: /* empty */ { $$ = YACC_EXPRESSION(0); }
- | expression
-expression: assignment_expression
- | expression_list ',' assignment_expression { $$ = YACC_EXPRESSION(YACC_EXPRESSIONS($1, $3)); }
-constant_expression: conditional_expression
-
-/* The grammar is repeated for when the parser stack knows that the next > must end a template.
- */
-templated_relational_expression: shift_expression
- | templated_relational_expression '<' shift_expression { $$ = YACC_LESS_THAN_EXPRESSION($1, $3); }
- | templated_relational_expression LE shift_expression { $$ = YACC_LESS_EQUAL_EXPRESSION($1, $3); }
- | templated_relational_expression GE shift_expression { $$ = YACC_GREATER_EQUAL_EXPRESSION($1, $3); }
-templated_equality_expression: templated_relational_expression
- | templated_equality_expression EQ templated_relational_expression { $$ = YACC_EQUAL_EXPRESSION($1, $3); }
- | templated_equality_expression NE templated_relational_expression { $$ = YACC_NOT_EQUAL_EXPRESSION($1, $3); }
-templated_and_expression: templated_equality_expression
- | templated_and_expression '&' templated_equality_expression { $$ = YACC_AND_EXPRESSION($1, $3); }
-templated_exclusive_or_expression: templated_and_expression
- | templated_exclusive_or_expression '^' templated_and_expression
- { $$ = YACC_EXCLUSIVE_OR_EXPRESSION($1, $3); }
-templated_inclusive_or_expression: templated_exclusive_or_expression
- | templated_inclusive_or_expression '|' templated_exclusive_or_expression
- { $$ = YACC_INCLUSIVE_OR_EXPRESSION($1, $3); }
-templated_logical_and_expression: templated_inclusive_or_expression
- | templated_logical_and_expression LOG_AND templated_inclusive_or_expression
- { $$ = YACC_LOGICAL_AND_EXPRESSION($1, $3); }
-templated_logical_or_expression: templated_logical_and_expression
- | templated_logical_or_expression LOG_OR templated_logical_and_expression
- { $$ = YACC_LOGICAL_OR_EXPRESSION($1, $3); }
-templated_conditional_expression: templated_logical_or_expression
- | templated_logical_or_expression '?' templated_expression ':' templated_assignment_expression
- { $$ = YACC_CONDITIONAL_EXPRESSION($1, $3, $5); }
-templated_assignment_expression: templated_conditional_expression
- | templated_logical_or_expression assignment_operator templated_assignment_expression
- { $$ = YACC_ASSIGNMENT_EXPRESSION($1, $2, $3); }
- | templated_throw_expression
-templated_expression: templated_assignment_expression
- | templated_expression_list ',' templated_assignment_expression
- { $$ = YACC_EXPRESSION(YACC_EXPRESSIONS($1, $3)); }
-templated_expression_list: templated_assignment_expression { $$ = YACC_EXPRESSIONS(0, $1); }
- | templated_expression_list ',' templated_assignment_expression { $$ = YACC_EXPRESSIONS($1, $3); }
-
-/*---------------------------------------------------------------------------------------------------
- * A.5 Statements
- *---------------------------------------------------------------------------------------------------
- * Parsing statements is easy once simple_declaration has been generalised to cover expression_statement.
- */
-looping_statement: start_search looped_statement { $$ = YACC_LINED_STATEMENT($2, $1); end_search($$); }
-looped_statement: statement
- | advance_search '+' looped_statement { $$ = $3; }
- | advance_search '-' { $$ = 0; }
-statement: control_statement
-/* | expression_statement -- covered by declaration_statement */
- | compound_statement
- | declaration_statement
- | try_block { $$ = YACC_TRY_BLOCK_STATEMENT($1); }
-control_statement: labeled_statement
- | selection_statement
- | iteration_statement
- | jump_statement
-labeled_statement: identifier_word ':' looping_statement { $$ = YACC_LABEL_STATEMENT($1, $3); }
- | CASE constant_expression ':' looping_statement { $$ = YACC_CASE_STATEMENT($2, $4); }
- | DEFAULT ':' looping_statement { $$ = YACC_DEFAULT_STATEMENT($3); }
-/*expression_statement: expression.opt ';' -- covered by declaration_statement */
-compound_statement: '{' statement_seq.opt '}' { $$ = YACC_COMPOUND_STATEMENT($2); }
- | '{' statement_seq.opt looping_statement '#' bang error '}' { $$ = $2; YACC_UNBANG($5, "Bad statement-seq."); }
-statement_seq.opt: /* empty */ { $$ = YACC_STATEMENTS(0, 0); }
- | statement_seq.opt looping_statement { $$ = YACC_STATEMENTS($1, YACC_COMPILE_STATEMENT($2)); }
- | statement_seq.opt looping_statement '#' bang error ';' { $$ = $1; YACC_UNBANG($4, "Bad statement."); }
-/*
- * The dangling else conflict is resolved to the innermost if.
- */
-selection_statement: IF '(' condition ')' looping_statement %prec SHIFT_THERE { $$ = YACC_IF_STATEMENT($3, $5, 0); }
- | IF '(' condition ')' looping_statement ELSE looping_statement { $$ = YACC_IF_STATEMENT($3, $5, $7); }
- | SWITCH '(' condition ')' looping_statement { $$ = YACC_SWITCH_STATEMENT($3, $5); }
-condition.opt: /* empty */ { $$ = YACC_CONDITION(0); }
- | condition
-condition: parameter_declaration_list { $$ = YACC_CONDITION($1); }
-/* | expression -- covered by parameter_declaration_list */
-/* | type_specifier_seq declarator '=' assignment_expression -- covered by parameter_declaration_list */
-iteration_statement: WHILE '(' condition ')' looping_statement { $$ = YACC_WHILE_STATEMENT($3, $5); }
- | DO looping_statement WHILE '(' expression ')' ';' { $$ = YACC_DO_WHILE_STATEMENT($2, $5); }
- | FOR '(' for_init_statement condition.opt ';' expression.opt ')' looping_statement
- { $$ = YACC_FOR_STATEMENT($3, $4, $6, $8); }
-for_init_statement: simple_declaration
-/* | expression_statement -- covered by simple_declaration */
-jump_statement: BREAK ';' { $$ = YACC_BREAK_STATEMENT(); }
- | CONTINUE ';' { $$ = YACC_CONTINUE_STATEMENT(); }
- | RETURN expression.opt ';' { $$ = YACC_RETURN_STATEMENT($2); }
- | GOTO identifier ';' { $$ = YACC_GOTO_STATEMENT($2); }
-declaration_statement: block_declaration { $$ = YACC_DECLARATION_STATEMENT($1); }
-
-/*---------------------------------------------------------------------------------------------------
- * A.6 Declarations
- *---------------------------------------------------------------------------------------------------*/
-compound_declaration: '{' nest declaration_seq.opt '}' { $$ = $3; unnest($2); }
- | '{' nest declaration_seq.opt util looping_declaration '#' bang error '}'
- { $$ = $3; unnest($2); YACC_UNBANG($7, "Bad declaration-seq."); }
-declaration_seq.opt: /* empty */ { $$ = YACC_DECLARATIONS(0, 0); }
- | declaration_seq.opt util looping_declaration { $$ = YACC_DECLARATIONS($1, YACC_COMPILE_DECLARATION($2, $3)); }
- | declaration_seq.opt util looping_declaration '#' bang error ';' { $$ = $1; YACC_UNBANG($5, "Bad declaration."); }
-looping_declaration: start_search1 looped_declaration { $$ = YACC_LINED_DECLARATION($2, $1); end_search($$); }
-looped_declaration: declaration
- | advance_search '+' looped_declaration { $$ = $3; }
- | advance_search '-' { $$ = 0; }
-declaration: block_declaration
- | function_definition { $$ = YACC_SIMPLE_DECLARATION($1); }
- | template_declaration
-/* | explicit_instantiation -- covered by relevant declarations */
- | explicit_specialization
- | specialised_declaration
-specialised_declaration: linkage_specification { $$ = YACC_LINKAGE_SPECIFICATION($1); }
- | namespace_definition { $$ = YACC_NAMESPACE_DECLARATION($1); }
- | TEMPLATE specialised_declaration { $$ = YACC_SET_TEMPLATE_DECLARATION($2); }
-block_declaration: simple_declaration { $$ = YACC_SIMPLE_DECLARATION($1); }
- | specialised_block_declaration
-specialised_block_declaration: asm_definition
- | namespace_alias_definition
- | using_declaration
- | using_directive
- | TEMPLATE specialised_block_declaration { $$ = YACC_SET_TEMPLATE_DECLARATION($2); }
-simple_declaration: ';' { $$ = YACC_EXPRESSION(0); }
- | init_declaration ';'
- | init_declarations ';' { $$ = $1; }
- | decl_specifier_prefix simple_declaration { $$ = YACC_DECL_SPECIFIER_EXPRESSION($2, $1); }
-
-/* A decl-specifier following a ptr_operator provokes a shift-reduce conflict for
- * * const name
- * which is resolved in favour of the pointer, and implemented by providing versions
- * of decl-specifier guaranteed not to start with a cv_qualifier.
- *
- * decl-specifiers are implemented type-centrically. That is the semantic constraint
- * that there must be a type is exploited to impose structure, but actually eliminate
- * very little syntax. built-in types are multi-name and so need a different policy.
- *
- * non-type decl-specifiers are bound to the left-most type in a decl-specifier-seq,
- * by parsing from the right and attaching suffixes to the right-hand type. Finally
- * residual prefixes attach to the left.
- */
-suffix_built_in_decl_specifier.raw: built_in_type_specifier { $$ = $1; }
- | suffix_built_in_decl_specifier.raw built_in_type_specifier { $$ = YACC_BUILT_IN_NAME($1, $2); }
- | suffix_built_in_decl_specifier.raw decl_specifier_suffix { $$ = YACC_DECL_SPECIFIER_NAME($1, $2); }
-suffix_built_in_decl_specifier: suffix_built_in_decl_specifier.raw { $$ = $1; }
- | TEMPLATE suffix_built_in_decl_specifier { $$ = YACC_SET_TEMPLATE_NAME($2); }
-suffix_named_decl_specifier: scoped_id { $$ = $1; }
- | elaborate_type_specifier { $$ = $1; }
- | suffix_named_decl_specifier decl_specifier_suffix { $$ = YACC_DECL_SPECIFIER_NAME($1, $2); }
-suffix_named_decl_specifier.bi: suffix_named_decl_specifier { $$ = YACC_NAME_EXPRESSION($1); }
- | suffix_named_decl_specifier suffix_built_in_decl_specifier.raw { $$ = YACC_TYPED_NAME($1, $2); }
-suffix_named_decl_specifiers: suffix_named_decl_specifier.bi
- | suffix_named_decl_specifiers suffix_named_decl_specifier.bi { $$ = YACC_TYPED_NAME($1, $2); }
-suffix_named_decl_specifiers.sf: scoped_special_function_id /* operators etc */ { $$ = YACC_NAME_EXPRESSION($1); }
- | suffix_named_decl_specifiers
- | suffix_named_decl_specifiers scoped_special_function_id { $$ = YACC_TYPED_NAME($1, $2); }
-suffix_decl_specified_ids: suffix_built_in_decl_specifier
- | suffix_built_in_decl_specifier suffix_named_decl_specifiers.sf { $$ = YACC_TYPED_NAME($1, $2); }
- | suffix_named_decl_specifiers.sf
-suffix_decl_specified_scope: suffix_named_decl_specifiers SCOPE
- | suffix_built_in_decl_specifier suffix_named_decl_specifiers SCOPE { $$ = YACC_TYPED_NAME($1, $2); }
- | suffix_built_in_decl_specifier SCOPE { $$ = YACC_NAME_EXPRESSION($1); }
-
-decl_specifier_affix: storage_class_specifier
- | function_specifier
- | FRIEND
- | TYPEDEF
- | cv_qualifier { $$ = $1; }
-
-decl_specifier_suffix: decl_specifier_affix
-
-decl_specifier_prefix: decl_specifier_affix
- | TEMPLATE decl_specifier_prefix { $$ = YACC_SET_TEMPLATE_DECL_SPECIFIER($2); }
-
-storage_class_specifier: REGISTER | STATIC | MUTABLE
- | EXTERN %prec SHIFT_THERE /* Prefer linkage specification */
- | AUTO
-
-function_specifier: EXPLICIT
- | INLINE
- | VIRTUAL
-
-type_specifier: simple_type_specifier
- | elaborate_type_specifier
- | cv_qualifier { $$ = YACC_CV_DECL_SPECIFIER($1); }
-
-elaborate_type_specifier: class_specifier
- | enum_specifier
- | elaborated_type_specifier
- | TEMPLATE elaborate_type_specifier { $$ = YACC_SET_TEMPLATE_ID($2); }
-simple_type_specifier: scoped_id
- | built_in_type_specifier { $$ = YACC_BUILT_IN_ID_ID($1); }
-built_in_type_specifier: CHAR | WCHAR_T | BOOL | SHORT | INT | LONG | SIGNED | UNSIGNED | FLOAT | DOUBLE | VOID
-
-/*
- * The over-general use of declaration_expression to cover decl-specifier-seq.opt declarator in a function-definition means that
- * class X {};
- * could be a function-definition or a class-specifier.
- * enum X {};
- * could be a function-definition or an enum-specifier.
- * The function-definition is not syntactically valid so resolving the false conflict in favour of the
- * elaborated_type_specifier is correct.
- */
-elaborated_type_specifier: elaborated_class_specifier
- | elaborated_enum_specifier
- | TYPENAME scoped_id { $$ = YACC_ELABORATED_TYPE_SPECIFIER($1, $2); }
-
-elaborated_enum_specifier: ENUM scoped_id %prec SHIFT_THERE { $$ = YACC_ELABORATED_TYPE_SPECIFIER($1, $2); }
-enum_specifier: ENUM scoped_id enumerator_clause { $$ = YACC_ENUM_SPECIFIER_ID($2, $3); }
- | ENUM enumerator_clause { $$ = YACC_ENUM_SPECIFIER_ID(0, $2); }
-enumerator_clause: '{' enumerator_list_ecarb { $$ = YACC_ENUMERATORS(0, 0); }
- | '{' enumerator_list enumerator_list_ecarb { $$ = $2; }
- | '{' enumerator_list ',' enumerator_definition_ecarb { $$ = $2; }
-enumerator_list_ecarb: '}' { }
- | bang error '}' { YACC_UNBANG($1, "Bad enumerator-list."); }
-enumerator_definition_ecarb: '}' { }
- | bang error '}' { YACC_UNBANG($1, "Bad enumerator-definition."); }
-enumerator_definition_filler: /* empty */
- | bang error ',' { YACC_UNBANG($1, "Bad enumerator-definition."); }
-enumerator_list_head: enumerator_definition_filler { $$ = YACC_ENUMERATORS(0, 0); }
- | enumerator_list ',' enumerator_definition_filler
-enumerator_list: enumerator_list_head enumerator_definition { $$ = YACC_ENUMERATORS($1, $2); }
-enumerator_definition: enumerator { $$ = YACC_ENUMERATOR($1, 0); }
- | enumerator '=' constant_expression { $$ = YACC_ENUMERATOR($1, $3); }
-enumerator: identifier
-
-namespace_definition: NAMESPACE scoped_id compound_declaration { $$ = YACC_NAMESPACE_DEFINITION($2, $3); }
- | NAMESPACE compound_declaration { $$ = YACC_NAMESPACE_DEFINITION(0, $2); }
-namespace_alias_definition: NAMESPACE scoped_id '=' scoped_id ';' { $$ = YACC_NAMESPACE_ALIAS_DEFINITION($2, $4); }
-
-using_declaration: USING declarator_id ';' { $$ = YACC_USING_DECLARATION(false, $2); }
- | USING TYPENAME declarator_id ';' { $$ = YACC_USING_DECLARATION(true, $3); }
-
-using_directive: USING NAMESPACE scoped_id ';' { $$ = YACC_USING_DIRECTIVE($3); }
-asm_definition: ASM '(' string ')' ';' { $$ = YACC_ASM_DEFINITION($3); }
-linkage_specification: EXTERN string looping_declaration { $$ = YACC_LINKAGE_SPECIFIER($2, $3); }
- | EXTERN string compound_declaration { $$ = YACC_LINKAGE_SPECIFIER($2, $3); }
-
-/*---------------------------------------------------------------------------------------------------
- * A.7 Declarators
- *---------------------------------------------------------------------------------------------------*/
-/*init-declarator is named init_declaration to reflect the embedded decl-specifier-seq.opt*/
-init_declarations: assignment_expression ',' init_declaration { $$ = YACC_EXPRESSIONS(YACC_EXPRESSIONS(0, $1), $3); }
- | init_declarations ',' init_declaration { $$ = YACC_EXPRESSIONS($1, $3); }
-init_declaration: assignment_expression
-/* | assignment_expression '=' initializer_clause -- covered by assignment_expression */
-/* | assignment_expression '(' expression_list ')' -- covered by another set of call arguments */
-
-/*declarator: -- covered by assignment_expression */
-/*direct_declarator: -- covered by postfix_expression */
-
-star_ptr_operator: '*' { $$ = YACC_POINTER_DECLARATOR(); }
- | star_ptr_operator cv_qualifier { $$ = YACC_CV_DECLARATOR($1, $2); }
-nested_ptr_operator: star_ptr_operator { $$ = $1; }
- | id_scope nested_ptr_operator { $$ = YACC_NESTED_DECLARATOR($1, $2); }
-ptr_operator: '&' { $$ = YACC_REFERENCE_DECLARATOR(); }
- | nested_ptr_operator { $$ = $1; }
- | global_scope nested_ptr_operator { $$ = YACC_GLOBAL_DECLARATOR($1, $2); }
-ptr_operator_seq: ptr_operator { $$ = YACC_POINTER_EXPRESSION($1, YACC_EPSILON()); }
- | ptr_operator ptr_operator_seq { $$ = YACC_POINTER_EXPRESSION($1, $2); }
-/* Independently coded to localise the shift-reduce conflict: sharing just needs another %prec */
-ptr_operator_seq.opt: /* empty */ %prec SHIFT_THERE /* Maximise type length */ { $$ = YACC_EXPRESSION(0); }
- | ptr_operator ptr_operator_seq.opt { $$ = YACC_POINTER_EXPRESSION($1, $2); }
-
-cv_qualifier_seq.opt: /* empty */ { $$ = YACC_CV_QUALIFIERS(0, 0); }
- | cv_qualifier_seq.opt cv_qualifier { $$ = YACC_CV_QUALIFIERS($1, $2); }
-cv_qualifier: CONST | VOLATILE /* | CvQualifier */
-
-/*type_id -- also covered by parameter declaration */
-type_id: type_specifier abstract_declarator.opt { $$ = YACC_TYPED_EXPRESSION($1, $2); }
- | type_specifier type_id { $$ = YACC_TYPED_EXPRESSION($1, $2); }
-
-/*abstract_declarator: -- also covered by parameter declaration */
-abstract_declarator.opt: /* empty */ { $$ = YACC_EPSILON(); }
- | ptr_operator abstract_declarator.opt { $$ = YACC_POINTER_EXPRESSION($1, $2); }
- | direct_abstract_declarator
-direct_abstract_declarator.opt: /* empty */ { $$ = YACC_EPSILON(); }
- | direct_abstract_declarator
-direct_abstract_declarator: direct_abstract_declarator.opt parenthesis_clause { $$ = YACC_CALL_EXPRESSION($1, $2); }
- | direct_abstract_declarator.opt '[' ']' { $$ = YACC_ARRAY_EXPRESSION($1, 0); }
- | direct_abstract_declarator.opt '[' constant_expression ']' { $$ = YACC_ARRAY_EXPRESSION($1, $3); }
-/* | '(' abstract_declarator ')' -- covered by parenthesis_clause */
-
-parenthesis_clause: parameters_clause cv_qualifier_seq.opt { $$ = YACC_PARENTHESISED($1, $2, 0); }
- | parameters_clause cv_qualifier_seq.opt exception_specification { $$ = YACC_PARENTHESISED($1, $2, $3); }
-parameters_clause: '(' parameter_declaration_clause ')' { $$ = $2; }
-/* parameter_declaration_clause also covers init_declaration, type_id, declarator and abstract_declarator. */
-parameter_declaration_clause: /* empty */ { $$ = YACC_PARAMETERS(0, 0); }
- | parameter_declaration_list
- | parameter_declaration_list ELLIPSIS { $$ = YACC_PARAMETERS($1, YACC_ELLIPSIS_EXPRESSION()); }
-parameter_declaration_list: parameter_declaration { $$ = YACC_PARAMETERS(0, $1); }
- | parameter_declaration_list ',' parameter_declaration { $$ = YACC_PARAMETERS($1, $3); }
-
-/* A typed abstract qualifier such as
- * Class * ...
- * looks like a multiply, so pointers are parsed as their binary operation equivalents that
- * ultimately terminate with a degenerate right hand term.
- */
-abstract_pointer_declaration: ptr_operator_seq
- | multiplicative_expression star_ptr_operator ptr_operator_seq.opt { $$ = YACC_MULTIPLY_EXPRESSION($1, $2, $3); }
-abstract_parameter_declaration: abstract_pointer_declaration
- | and_expression '&' { $$ = YACC_AND_EXPRESSION($1, YACC_EPSILON()); }
- | and_expression '&' abstract_pointer_declaration { $$ = YACC_AND_EXPRESSION($1, $3); }
-special_parameter_declaration: abstract_parameter_declaration
- | abstract_parameter_declaration '=' assignment_expression { $$ = YACC_ASSIGNMENT_EXPRESSION($1, $2, $3); }
- | ELLIPSIS { $$ = YACC_ELLIPSIS_EXPRESSION(); }
-parameter_declaration: assignment_expression { $$ = YACC_EXPRESSION_PARAMETER($1); }
- | special_parameter_declaration { $$ = YACC_EXPRESSION_PARAMETER($1); }
- | decl_specifier_prefix parameter_declaration { $$ = YACC_DECL_SPECIFIER_PARAMETER($2, $1); }
-
-/* The grammar is repeated for use within template <>
- */
-templated_parameter_declaration: templated_assignment_expression { $$ = YACC_EXPRESSION_PARAMETER($1); }
- | templated_abstract_declaration { $$ = YACC_EXPRESSION_PARAMETER($1); }
- | templated_abstract_declaration '=' templated_assignment_expression
- { $$ = YACC_EXPRESSION_PARAMETER(YACC_ASSIGNMENT_EXPRESSION($1, $2, $3)); }
- | decl_specifier_prefix templated_parameter_declaration { $$ = YACC_DECL_SPECIFIER_PARAMETER($2, $1); }
-templated_abstract_declaration: abstract_pointer_declaration
- | templated_and_expression '&' { $$ = YACC_AND_EXPRESSION($1, 0); }
- | templated_and_expression '&' abstract_pointer_declaration { $$ = YACC_AND_EXPRESSION($1, $3); }
-
-/* function_definition includes constructor, destructor, implicit int definitions too.
- * A local destructor is successfully parsed as a function-declaration but the ~ was treated as a unary operator.
- * constructor_head is the prefix ambiguity between a constructor and a member-init-list starting with a bit-field.
- */
-function_definition: ctor_definition
- | func_definition
-func_definition: assignment_expression function_try_block { $$ = YACC_FUNCTION_DEFINITION($1, $2); }
- | assignment_expression function_body { $$ = YACC_FUNCTION_DEFINITION($1, $2); }
- | decl_specifier_prefix func_definition { $$ = YACC_DECL_SPECIFIER_EXPRESSION($2, $1); }
-ctor_definition: constructor_head function_try_block { $$ = YACC_CTOR_DEFINITION($1, $2); }
- | constructor_head function_body { $$ = YACC_CTOR_DEFINITION($1, $2); }
- | decl_specifier_prefix ctor_definition { $$ = YACC_DECL_SPECIFIER_EXPRESSION($2, $1); }
-constructor_head: bit_field_init_declaration { $$ = YACC_EXPRESSIONS(0, $1); }
- | constructor_head ',' assignment_expression { $$ = YACC_EXPRESSIONS($1, $3); }
-function_try_block: TRY function_block handler_seq { $$ = YACC_TRY_FUNCTION_BLOCK($2, $3); }
-function_block: ctor_initializer.opt function_body { $$ = YACC_CTOR_FUNCTION_BLOCK($2, $1); }
-function_body: compound_statement { $$ = YACC_FUNCTION_BLOCK($1); }
-
-/* An = initializer looks like an extended assignment_expression.
- * An () initializer looks like a function call.
- * initializer is therefore flattened into its generalised customers.
- *initializer: '=' initializer_clause -- flattened into caller
- * | '(' expression_list ')' -- flattened into caller */
-initializer_clause: assignment_expression { $$ = YACC_INITIALIZER_EXPRESSION_CLAUSE($1); }
- | braced_initializer
-braced_initializer: '{' initializer_list '}' { $$ = YACC_INITIALIZER_LIST_CLAUSE($2); }
- | '{' initializer_list ',' '}' { $$ = YACC_INITIALIZER_LIST_CLAUSE($2); }
- | '{' '}' { $$ = YACC_INITIALIZER_LIST_CLAUSE(0); }
- | '{' looping_initializer_clause '#' bang error '}' { $$ = 0; YACC_UNBANG($4, "Bad initializer_clause."); }
- | '{' initializer_list ',' looping_initializer_clause '#' bang error '}'
- { $$ = $2; YACC_UNBANG($6, "Bad initializer_clause."); }
-initializer_list: looping_initializer_clause { $$ = YACC_INITIALIZER_CLAUSES(0, $1); }
- | initializer_list ',' looping_initializer_clause { $$ = YACC_INITIALIZER_CLAUSES($1, $3); }
-looping_initializer_clause: start_search looped_initializer_clause { $$ = $2; end_search($$); }
-looped_initializer_clause: initializer_clause
- | advance_search '+' looped_initializer_clause { $$ = $3; }
- | advance_search '-' { $$ = 0; }
-
-/*---------------------------------------------------------------------------------------------------
- * A.8 Classes
- *---------------------------------------------------------------------------------------------------
- *
- * An anonymous bit-field declaration may look very like inheritance:
- * class A : B = 3;
- * class A : B ;
- * The two usages are too distant to try to create and enforce a common prefix so we have to resort to
- * a parser hack by backtracking. Inheritance is much the most likely so we mark the input stream context
- * and try to parse a base-clause. If we successfully reach a { the base-clause is ok and inheritance was
- * the correct choice so we unmark and continue. If we fail to find the { an error token causes back-tracking
- * to the alternative parse in elaborated_class_specifier which regenerates the : and declares unconditional success.
- */
-colon_mark: ':' { $$ = mark(); }
-elaborated_class_specifier: class_key scoped_id %prec SHIFT_THERE { $$ = YACC_ELABORATED_TYPE_SPECIFIER($1, $2); }
- | class_key scoped_id colon_mark error { $$ = YACC_ELABORATED_TYPE_SPECIFIER($1, $2); rewind_colon($3, $$); }
-class_specifier_head: class_key scoped_id colon_mark base_specifier_list '{' { unmark($4); $$ = YACC_CLASS_SPECIFIER_ID($1, $2, $4); }
- | class_key ':' base_specifier_list '{' { $$ = YACC_CLASS_SPECIFIER_ID($1, 0, $3); }
- | class_key scoped_id '{' { $$ = YACC_CLASS_SPECIFIER_ID($1, $2, 0); }
- | class_key '{' { $$ = YACC_CLASS_SPECIFIER_ID($1, 0, 0); }
-class_key: CLASS | STRUCT | UNION
-class_specifier: class_specifier_head member_specification.opt '}' { $$ = YACC_CLASS_MEMBERS($1, $2); }
- | class_specifier_head member_specification.opt util looping_member_declaration '#' bang error '}'
- { $$ = YACC_CLASS_MEMBERS($1, $2); YACC_UNBANG($6, "Bad member_specification.opt."); }
-member_specification.opt: /* empty */ { $$ = YACC_MEMBER_DECLARATIONS(0, 0); }
- | member_specification.opt util looping_member_declaration { $$ = YACC_MEMBER_DECLARATIONS($1, YACC_COMPILE_DECLARATION($2, $3)); }
- | member_specification.opt util looping_member_declaration '#' bang error ';'
- { $$ = $1; YACC_UNBANG($5, "Bad member-declaration."); }
-looping_member_declaration: start_search looped_member_declaration { $$ = YACC_LINED_DECLARATION($2, $1); end_search($$); }
-looped_member_declaration: member_declaration
- | advance_search '+' looped_member_declaration { $$ = $3; }
- | advance_search '-' { $$ = 0; }
-member_declaration: accessibility_specifier
- | simple_member_declaration { $$ = YACC_SIMPLE_DECLARATION($1); }
- | function_definition { $$ = YACC_SIMPLE_DECLARATION($1); }
-/* | function_definition ';' -- trailing ; covered by null declaration */
-/* | qualified_id ';' -- covered by simple_member_declaration */
- | using_declaration
- | template_declaration
-
-/* The generality of constructor names (there need be no parenthesised argument list) means that that
- * name : f(g), h(i)
- * could be the start of a constructor or the start of an anonymous bit-field. An ambiguity is avoided by
- * parsing the ctor-initializer of a function_definition as a bit-field.
- */
-simple_member_declaration: ';' { $$ = YACC_EXPRESSION(0); }
- | assignment_expression ';'
- | constructor_head ';' { $$ = $1; }
- | member_init_declarations ';' { $$ = $1; }
- | decl_specifier_prefix simple_member_declaration { $$ = YACC_DECL_SPECIFIER_EXPRESSION($2, $1); }
-member_init_declarations: assignment_expression ',' member_init_declaration { $$ = YACC_EXPRESSIONS(YACC_EXPRESSIONS(0, $1), $3); }
- | constructor_head ',' bit_field_init_declaration { $$ = YACC_EXPRESSIONS($1, $3); }
- | member_init_declarations ',' member_init_declaration { $$ = YACC_EXPRESSIONS($1, $3); }
-member_init_declaration: assignment_expression
-/* | assignment_expression '=' initializer_clause -- covered by assignment_expression */
-/* | assignment_expression '(' expression_list ')' -- covered by another set of call arguments */
- | bit_field_init_declaration
-accessibility_specifier: access_specifier ':' { $$ = YACC_ACCESSIBILITY_SPECIFIER($1); }
-bit_field_declaration: assignment_expression ':' bit_field_width { $$ = YACC_BIT_FIELD_EXPRESSION($1, $3); }
- | ':' bit_field_width { $$ = YACC_BIT_FIELD_EXPRESSION(0, $2); }
-bit_field_width: logical_or_expression
-/* | logical_or_expression '?' expression ':' assignment_expression -- has SR conflict w.r.t later = */
- | logical_or_expression '?' bit_field_width ':' bit_field_width { $$ = YACC_CONDITIONAL_EXPRESSION($1, $3, $5); }
-bit_field_init_declaration: bit_field_declaration
- | bit_field_declaration '=' initializer_clause { $$ = YACC_ASSIGNMENT_EXPRESSION($1, $2, $3); }
-
-/*---------------------------------------------------------------------------------------------------
- * A.9 Derived classes
- *---------------------------------------------------------------------------------------------------*/
-/*base_clause: ':' base_specifier_list -- flattened */
-base_specifier_list: base_specifier { $$ = YACC_BASE_SPECIFIERS(0, $1); }
- | base_specifier_list ',' base_specifier { $$ = YACC_BASE_SPECIFIERS($1, $3); }
-base_specifier: scoped_id { $$ = YACC_BASE_SPECIFIER($1); }
- | access_specifier base_specifier { $$ = YACC_ACCESS_BASE_SPECIFIER($2, $1); }
- | VIRTUAL base_specifier { $$ = YACC_VIRTUAL_BASE_SPECIFIER($2); }
-access_specifier: PRIVATE | PROTECTED | PUBLIC
-
-/*---------------------------------------------------------------------------------------------------
- * A.10 Special member functions
- *---------------------------------------------------------------------------------------------------*/
-conversion_function_id: OPERATOR conversion_type_id { $$ = YACC_CONVERSION_FUNCTION_ID($2); }
-conversion_type_id: type_specifier ptr_operator_seq.opt { $$ = YACC_TYPED_EXPRESSION($1, $2); }
- | type_specifier conversion_type_id { $$ = YACC_TYPED_EXPRESSION($1, $2); }
-/*
- * Ctor-initialisers can look like a bit field declaration, given the generalisation of names:
- * Class(Type) : m1(1), m2(2) {}
- * NonClass(bit_field) : int(2), second_variable, ...
- * The grammar below is used within a function_try_block or function_definition.
- * See simple_member_declaration for use in normal member function_definition.
- */
-ctor_initializer.opt: /* empty */ { $$ = YACC_MEM_INITIALIZERS(0, 0); }
- | ctor_initializer
-ctor_initializer: ':' mem_initializer_list { $$ = $2; }
- | ':' mem_initializer_list bang error { $$ = $2; YACC_UNBANG($3, "Bad ctor-initializer."); }
-mem_initializer_list: mem_initializer { $$ = YACC_MEM_INITIALIZERS(0, $1); }
- | mem_initializer_list_head mem_initializer { $$ = YACC_MEM_INITIALIZERS($1, $2); }
-mem_initializer_list_head: mem_initializer_list ','
- | mem_initializer_list bang error ',' { YACC_UNBANG($2, "Bad mem-initializer."); }
-mem_initializer: mem_initializer_id '(' expression_list.opt ')' { $$ = YACC_MEM_INITIALIZER($1, $3); }
-mem_initializer_id: scoped_id
-
-/*---------------------------------------------------------------------------------------------------
- * A.11 Overloading
- *---------------------------------------------------------------------------------------------------*/
-operator_function_id: OPERATOR operator { $$ = YACC_OPERATOR_FUNCTION_ID($2); }
-/*
- * It is not clear from the ANSI standard whether spaces are permitted in delete[]. If not then it can
- * be recognised and returned as DELETE_ARRAY by the lexer. Assuming spaces are permitted there is an
- * ambiguity created by the over generalised nature of expressions. operator new is a valid delarator-id
- * which we may have an undimensioned array of. Semantic rubbish, but syntactically valid. Since the
- * array form is covered by the declarator consideration we can exclude the operator here. The need
- * for a semantic rescue can be eliminated at the expense of a couple of shift-reduce conflicts by
- * removing the comments on the next four lines.
- */
-operator: /*++++*/ NEW { $$ = YACC_OPERATOR_NEW_ID(); }
- | /*++++*/ DELETE { $$ = YACC_OPERATOR_DELETE_ID(); }
-/* | / ---- / NEW %prec SHIFT_THERE { $$ = YACC_OPERATOR_NEW_ID(); }
-/* | / ---- / DELETE %prec SHIFT_THERE { $$ = YACC_OPERATOR_DELETE_ID(); }
-/* | / ---- / NEW '[' ']' -- Covered by array of OPERATOR NEW */
-/* | / ---- / DELETE '[' ']' -- Covered by array of OPERATOR DELETE */
- | '+' { $$ = YACC_OPERATOR_ADD_ID(); }
- | '-' { $$ = YACC_OPERATOR_SUB_ID(); }
- | '*' { $$ = YACC_OPERATOR_MUL_ID(); }
- | '/' { $$ = YACC_OPERATOR_DIV_ID(); }
- | '%' { $$ = YACC_OPERATOR_MOD_ID(); }
- | '^' { $$ = YACC_OPERATOR_XOR_ID(); }
- | '&' { $$ = YACC_OPERATOR_BIT_AND_ID(); }
- | '|' { $$ = YACC_OPERATOR_BIT_OR_ID(); }
- | '~' { $$ = YACC_OPERATOR_BIT_NOT_ID(); }
- | '!' { $$ = YACC_OPERATOR_LOG_NOT_ID(); }
- | '=' { $$ = YACC_OPERATOR_ASS_ID(); }
- | '<' { $$ = YACC_OPERATOR_LT_ID(); }
- | '>' { $$ = YACC_OPERATOR_GT_ID(); }
- | ASS_ADD { $$ = YACC_OPERATOR_ASS_ADD_ID(); }
- | ASS_SUB { $$ = YACC_OPERATOR_ASS_SUB_ID(); }
- | ASS_MUL { $$ = YACC_OPERATOR_ASS_MUL_ID(); }
- | ASS_DIV { $$ = YACC_OPERATOR_ASS_DIV_ID(); }
- | ASS_MOD { $$ = YACC_OPERATOR_ASS_MOD_ID(); }
- | ASS_XOR { $$ = YACC_OPERATOR_ASS_XOR_ID(); }
- | ASS_AND { $$ = YACC_OPERATOR_ASS_BIT_AND_ID(); }
- | ASS_OR { $$ = YACC_OPERATOR_ASS_BIT_OR_ID(); }
- | SHL { $$ = YACC_OPERATOR_SHL_ID(); }
- | SHR { $$ = YACC_OPERATOR_SHR_ID(); }
- | ASS_SHR { $$ = YACC_OPERATOR_ASS_SHR_ID(); }
- | ASS_SHL { $$ = YACC_OPERATOR_ASS_SHL_ID(); }
- | EQ { $$ = YACC_OPERATOR_EQ_ID(); }
- | NE { $$ = YACC_OPERATOR_NE_ID(); }
- | LE { $$ = YACC_OPERATOR_LE_ID(); }
- | GE { $$ = YACC_OPERATOR_GE_ID(); }
- | LOG_AND { $$ = YACC_OPERATOR_LOG_AND_ID(); }
- | LOG_OR { $$ = YACC_OPERATOR_LOG_OR_ID(); }
- | INC { $$ = YACC_OPERATOR_INC_ID(); }
- | DEC { $$ = YACC_OPERATOR_DEC_ID(); }
- | ',' { $$ = YACC_OPERATOR_COMMA_ID(); }
- | ARROW_STAR { $$ = YACC_OPERATOR_ARROW_STAR_ID(); }
- | ARROW { $$ = YACC_OPERATOR_ARROW_ID(); }
- | '(' ')' { $$ = YACC_OPERATOR_CALL_ID(); }
- | '[' ']' { $$ = YACC_OPERATOR_INDEX_ID(); }
-
-/*---------------------------------------------------------------------------------------------------
- * A.12 Templates
- *---------------------------------------------------------------------------------------------------*/
-template_declaration: template_parameter_clause declaration { $$ = YACC_TEMPLATE_DECLARATION($1, $2); }
- | EXPORT template_declaration { $$ = YACC_DECL_SPECIFIER_DECLARATION($2, $1); }
-template_parameter_clause: TEMPLATE '<' template_parameter_list '>' { $$ = $3; }
-template_parameter_list: template_parameter { $$ = YACC_TEMPLATE_PARAMETERS(0, $1); }
- | template_parameter_list ',' template_parameter { $$ = YACC_TEMPLATE_PARAMETERS($1, $3); }
-template_parameter: simple_type_parameter { $$ = YACC_INIT_SIMPLE_TYPE_PARAMETER($1, 0); }
- | simple_type_parameter '=' type_id { $$ = YACC_INIT_SIMPLE_TYPE_PARAMETER($1, $3); }
- | templated_type_parameter { $$ = YACC_INIT_TEMPLATED_PARAMETER($1, 0); }
- | templated_type_parameter '=' identifier { $$ = YACC_INIT_TEMPLATED_PARAMETER($1, $3); }
- | templated_parameter_declaration { $$ = YACC_TEMPLATE_PARAMETER($1); }
- | bang error { $$ = 0; YACC_UNBANG($1, "Bad template-parameter."); }
-simple_type_parameter: CLASS { $$ = YACC_CLASS_TYPE_PARAMETER(0); }
-/* | CLASS identifier -- covered by parameter_declaration */
- | TYPENAME { $$ = YACC_TYPENAME_TYPE_PARAMETER(0); }
-/* | TYPENAME identifier -- covered by parameter_declaration */
-templated_type_parameter: template_parameter_clause CLASS { $$ = YACC_TEMPLATED_TYPE_PARAMETER($1, 0); }
- | template_parameter_clause CLASS identifier { $$ = YACC_TEMPLATED_TYPE_PARAMETER($1, $3); }
-template_id: TEMPLATE identifier '<' template_argument_list '>' { $$ = YACC_TEMPLATE_NAME($2, $4); }
- | TEMPLATE template_id { $$ = $2; }
-/*
- * template-argument is evaluated using a templated...expression so that > resolves to end of template.
- */
-template_argument_list: template_argument { $$ = YACC_TEMPLATE_ARGUMENTS(0, $1); }
- | template_argument_list ',' template_argument { $$ = YACC_TEMPLATE_ARGUMENTS($1, $3); }
-template_argument: templated_parameter_declaration { $$ = YACC_TEMPLATE_ARGUMENT($1); }
-/* | type_id -- covered by templated_parameter_declaration */
-/* | template_name -- covered by templated_parameter_declaration */
-/* | error -- must allow template failure to re-search */
-
-/*
- * Generalised naming makes identifier a valid declaration, so TEMPLATE identifier is too.
- * The TEMPLATE prefix is therefore folded into all names, parenthesis_clause and decl_specifier_prefix.
- */
-/*explicit_instantiation: TEMPLATE declaration */
-explicit_specialization: TEMPLATE '<' '>' declaration { $$ = YACC_EXPLICIT_SPECIALIZATION($4); }
-
-/*---------------------------------------------------------------------------------------------------
- * A.13 Exception Handling
- *---------------------------------------------------------------------------------------------------*/
-try_block: TRY compound_statement handler_seq { $$ = YACC_TRY_BLOCK($2, $3); }
-/*function_try_block: -- moved near function_block */
-handler_seq: handler { $$ = YACC_HANDLERS(0, $1); }
- | handler handler_seq { $$ = YACC_HANDLERS($2, $1); }
-handler: CATCH '(' exception_declaration ')' compound_statement { $$ = YACC_HANDLER($3, $5); }
-exception_declaration: parameter_declaration { $$ = YACC_EXCEPTION_DECLARATION($1); }
-/* ELLIPSIS -- covered by parameter_declaration */
-throw_expression: THROW { $$ = YACC_THROW_EXPRESSION(0); }
- | THROW assignment_expression { $$ = YACC_THROW_EXPRESSION($2); }
-templated_throw_expression: THROW { $$ = YACC_THROW_EXPRESSION(0); }
- | THROW templated_assignment_expression { $$ = YACC_THROW_EXPRESSION($2); }
-exception_specification: THROW '(' ')' { $$ = YACC_EXCEPTION_SPECIFICATION(0); }
- | THROW '(' type_id_list ')' { $$ = YACC_EXCEPTION_SPECIFICATION($3); }
-type_id_list: type_id { $$ = YACC_EXPRESSIONS(0, $1); }
- | type_id_list ',' type_id { $$ = YACC_EXPRESSIONS($1, $3); }
-
-/*---------------------------------------------------------------------------------------------------
- * Back-tracking and context support
- *---------------------------------------------------------------------------------------------------*/
-advance_search: error { yyerrok; advance_search(); } /* Rewind and queue '+' or '-' '#' */
-bang: /* empty */ { $$ = YACC_BANG(); } /* set flag to suppress "parse error" */
-mark: /* empty */ { $$ = mark(); } /* Push lookahead and input token stream context onto a stack */
-nest: /* empty */ { $$ = nest(); } /* Push a declaration nesting depth onto the parse stack */
-start_search: /* empty */ { $$ = YACC_LINE(); start_search(false); } /* Create/reset binary search context */
-start_search1: /* empty */ { $$ = YACC_LINE(); start_search(true); } /* Create/reset binary search context */
-util: /* empty */ { $$ = YACC_UTILITY_MODE(); } /* Get current utility mode */
-/*StartTester*/
-%%
-#include <CxxParsing.cxx>
-/*EndTester*/
+++ /dev/null
-#include <iostream.h>
-#include <memory.h>
-#include <CxxToken.hxx>
-
-extern CxxToken *yylex_token();
-
-#ifdef BISON_PP_CLASS
-BISON_PP_CLASS theParser;
-#define PARSE_DOT theParser .
-#define PARSE_SCOPE BISON_PP_CLASS ::
-#else
-#define PARSE_DOT
-#define PARSE_SCOPE
-extern int yydebug;
-#ifndef YYEMPTY
-#define YYEMPTY -1
-#endif
-#endif
-
-class CxxSearchContext
-{
- friend class ios; // Suppress GNU error message for no public constructors.
- CxxSearchContext *_next;
- size_t _index;
- size_t _depth;
- size_t _size;
- size_t _mark;
- bool _enable_type1;
- size_t _line;
- size_t _advances;
- bool _status[32];
-private:
- CxxSearchContext(CxxSearchContext *nextSearch)
- : _next(nextSearch), _index(0), _depth(0), _size(sizeof(_status)/sizeof(_status[0])),
- _mark(0), _enable_type1(false), _line(0), _advances(0) {}
- CxxSearchContext(const CxxSearchContext&);
- CxxSearchContext& operator=(const CxxSearchContext&);
- bool did_search() const { return _depth > 0 ? true : false; }
- void initialise(size_t markIndex, bool enableType1);
- CxxSearchContext *queue(CxxSearchContext *& listHead);
- void reset();
-public:
- bool advance();
- bool enable_type1() const { return _enable_type1; }
- bool is_template();
- size_t mark() const { return _mark; }
-private:
- static CxxSearchContext *_current;
- static CxxSearchContext *_free;
-public:
- static size_t actual_searches;
- static size_t advances[16];
- static size_t max_search_depth;
- static size_t nested_searches;
- static size_t releases;
- static size_t search_advances;
- static size_t unnested_searches;
-public:
- static CxxSearchContext *current() { return _current; }
- static void release();
- static void start(YACC_MARK_TYPE anIndex, bool enableType1);
-};
-
-size_t bang_depth = 0;
-size_t error_count = 0;
-size_t marked_error_count = 0;
-bool in_type1 = false;
-bool show_marked = false;
-
-int main(int argc, char *argv[])
-{
- for (--argc, ++argv; argc-- > 0; ++argv)
- {
- char *p = *argv;
- if (*p == '-')
- {
- switch (*(p+1))
- {
- case 'c':
- c_keywords = true;
- break;
- case 't':
- echo_line_text = true;
- break;
- case 'm':
- show_marked = true;
- break;
- case 'n':
- echo_line_numbers = true;
- break;
- case 'y':
- PARSE_DOT yydebug = true;
- break;
- }
- }
- }
- if (PARSE_DOT yyparse() != 0)
- ERRMSG("Failed to parse to end of file,");
- cout << "error_count = " << error_count
- << ", marked_error_count = " << marked_error_count
- << ", lines = " << line_number
- << ", unnested_searches = " << CxxSearchContext::unnested_searches
- << ", nested_searches = " << CxxSearchContext::nested_searches
- << ", releases = " << CxxSearchContext::releases
- << ", actual_searches = " << CxxSearchContext::actual_searches
- << ", max_search_depth = " << CxxSearchContext::max_search_depth
- << ", search_advances = " << CxxSearchContext::search_advances << endl;
- cout << "number of occurences of each advance";
- for (size_t i = 0; i < sizeof(CxxSearchContext::advances)/sizeof(CxxSearchContext::advances[0]); i++)
- cout << ' ' << CxxSearchContext::advances[i];
- cout << endl;
- return 0;
-}
-
-static CxxToken **tokenBuffer = 0; // Allocated buffer
-static YACC_MARK_TYPE tokenReadIndex = 0; // Read index
-static size_t tokenSize = 0; // Allocate buffer size
-static YACC_MARK_TYPE tokenWriteIndex = 0; // Write index
-int tokenMarkDepth = 0; // Write index
-static CxxToken *primed_tokens[3] = {0, 0}; // Restarting sequence
-static void token_put(CxxToken *aToken);
-
-CxxSearchContext *CxxSearchContext::_current = 0;
-CxxSearchContext *CxxSearchContext::_free = 0;
-size_t CxxSearchContext::actual_searches = 0;
-size_t CxxSearchContext::advances[16] = { 0 };
-size_t CxxSearchContext::max_search_depth = 0;
-size_t CxxSearchContext::nested_searches = 0;
-size_t CxxSearchContext::releases = 0;
-size_t CxxSearchContext::search_advances;
-size_t CxxSearchContext::unnested_searches;
-
-//
-// Implements a binary search counter, performing the increment at the
-// _index of othe failed search.
-//
-bool CxxSearchContext::advance()
-{
- _advances++;
- size_t i = _depth;
- if (i <= 0)
- return false;
- while (--i > _index)
- _status[i] = false;
- while (true)
- {
- if (!_status[i])
- {
- _status[i] = true;
- _index = 0;
- return true;
- }
- if (i <= 0)
- return false;
- _status[i--] = false;
- }
-}
-
-void CxxSearchContext::initialise(size_t markIndex, bool enableType1)
-{
- _index = 0;
- _depth = 0;
- _mark = markIndex;
- _enable_type1 = enableType1;
- _line = line_number;
- _advances = 0;
-}
-
-bool CxxSearchContext::is_template()
-{
- if (_index >= _depth)
- {
- if (_depth >= _size)
- {
- ERRMSG("Binary search depth exceeded.");
- return false;
- }
- _status[_depth++] = false;
- if (_depth > max_search_depth)
- max_search_depth = _depth;
- }
- return _status[_index++] ? false : true;
-}
-
-//
-// Put this element onto listHead, returning element under this one.
-//
-CxxSearchContext *CxxSearchContext::queue(CxxSearchContext *& listHead)
-{
- CxxSearchContext *oldNext = _next;
- _next = listHead;
- listHead = this;
- return oldNext;
-}
-
-//
-// Release the current search buffer.
-//
-void CxxSearchContext::release()
-{
- if (_current)
- {
- releases++;
- _current->reset();
- _current = _current->queue(_free);
- }
-}
-
-void CxxSearchContext::reset()
-{
- if (did_search())
- {
- _advances++;
- actual_searches++;
- }
- if (_advances >= sizeof(advances)/sizeof(advances[0]))
- advances[sizeof(advances)/sizeof(advances[0])-1]++;
- else
- advances[_advances]++;
-}
-
-void CxxSearchContext::start(YACC_MARK_TYPE anIndex, bool enableType1)
-{
- if (!_current)
- unnested_searches++;
- else
- nested_searches++;
- if (!_free)
- _current = new CxxSearchContext(_current);
- else
- _free = _free->queue(_current);
- _current->initialise(anIndex, enableType1);
-}
-
-static CxxToken angleToken('<');
-static CxxToken colonToken(':');
-static CxxToken hashToken('#');
-static CxxToken plusToken('+');
-static CxxToken minusToken('-');
-
-void PARSE_SCOPE yyerror(const char *s)
-{
- if (!bang_depth && (tokenMarkDepth == 0))
- {
- cout << s << endl;
- increment_error_count();
- }
- else
- {
- if (show_marked)
- cout << "Marked " << s << endl;
- marked_error_count++;
- }
-}
-
-//
-// Get the next token for the parser, invoking yylex_token to get the next token from the lexer.
-// This routine gets renamed to buffered_yylex by a #define when using yacc so that the two purposes
-// above are split allowing lookahead buffering and primimimg to occur.
-//
-int PARSE_SCOPE yylex()
-{
- CxxToken *aToken = primed_tokens[0];
- if (aToken)
- {
- primed_tokens[0] = primed_tokens[1];
- primed_tokens[1] = primed_tokens[2];
- primed_tokens[2] = 0;
- }
- else if (tokenReadIndex < tokenWriteIndex)
- aToken = tokenBuffer[tokenReadIndex++];
- else
- {
- aToken = yylex_token();
- if (!aToken)
- return 0;
- if (tokenMarkDepth > 0)
- token_put(aToken);
- else
- {
- tokenWriteIndex = 0;
- tokenReadIndex = 0;
- }
- }
- yylval.token = aToken;
- return aToken->value();
-}
-
-//
-// Advance the binary search of template attempts. Rewinds and forces true into the input sequence
-// to proceed with the search. Rewinds and forces false to terminate it. Also forces a # that may then
-// be used to initiate error propagation.
-//
-void advance_search()
-{
- CxxSearchContext::search_advances++;
- remark(CxxSearchContext::current()->mark());
- if (CxxSearchContext::current() && CxxSearchContext::current()->advance())
- {
- primed_tokens[0] = &plusToken;
- primed_tokens[1] = 0;
- }
- else
- {
- primed_tokens[0] = &minusToken;
- primed_tokens[1] = &hashToken;
- }
-}
-
-//
-// Complete a search, releasing the search context object and popping a mark off the stack.
-//
-void end_search(CxxToken *aToken)
-{
- CxxSearchContext::release();
- unmark(aToken);
-}
-
-//
-// Notch up an error and establish a good break point.
-//
-void increment_error_count()
-{
- error_count++;
-}
-
-//
-// Push a new marked context onto the stack, returning its identity for use by remark().
-// Any parser readahead is incorporated within the marked region.
-//
-YACC_MARK_TYPE mark()
-{
- if (primed_tokens[0])
- ERRMSG("Unexpected primed_tokens[0] in mark.");
- YACC_MARK_TYPE markIndex = tokenReadIndex;
- if (PARSE_DOT yychar != YYEMPTY)
- {
-// if (primed_tokens[2])
-// token_put(primed_tokens[2]);
-// if (primed_tokens[1])
-// token_put(primed_tokens[1]);
-// if (primed_tokens[0])
-// token_put(primed_tokens[0]);
-// if (!tokenMarkDepth)
- if (!tokenReadIndex && !tokenWriteIndex)
- {
- token_put(PARSE_DOT yylval.token);
- tokenReadIndex = 0;
- }
- else if (!tokenReadIndex)
- ERRMSG("Unexpected 0 read index in mark.");
- else if (tokenBuffer[--tokenReadIndex] != PARSE_DOT yylval.token)
- ERRMSG("Unexpected unget in mark.");
- markIndex = tokenReadIndex;
- yyclearin;
- primed_tokens[0] = 0;
- primed_tokens[1] = 0;
- }
- tokenMarkDepth++;
- bang_depth++;
- return markIndex;
-}
-
-//
-// If it is appropriate to do type I function parameter parsing perform a mark and force a rrue token
-// into the input stream. Otherwise just force a false token in.
-//
-YACC_MARK_TYPE mark_type1()
-{
- if (!in_type1 && CxxSearchContext::current() && CxxSearchContext::current()->enable_type1())
- {
- YACC_MARK_TYPE markIndex = mark();
- primed_tokens[0] = &plusToken;
- primed_tokens[1] = 0;
- in_type1 = true;
- yyclearin;
- return markIndex;
- }
- else
- {
- primed_tokens[0] = &minusToken;
- primed_tokens[1] = PARSE_DOT yychar != YYEMPTY ? PARSE_DOT yylval.token : 0;
- yyclearin;
- return 0; // Never used.
- }
-}
-
-//
-// Push a bang context onto the error suppression stack, returning the context for restoration by pop_bang.
-//
-void pop_bang(YACC_BANG_TYPE bangValue)
-{
- bang_depth = bangValue;
-}
-
-//
-// Push a bang context onto the error suppression stack, returning the context for restoration by pop_bang.
-//
-YACC_BANG_TYPE push_bang()
-{
- return bang_depth++;
-}
-
-//
-// Reposition the input to restart at the position returned by a mark().
-//
-void remark(YACC_MARK_TYPE anIndex)
-{
- tokenReadIndex = anIndex;
- yyclearin;
-}
-
-//
-// Reposition the input to restart at the position returned by a mark().
-//
-void remark_type1(YACC_MARK_TYPE anIndex)
-{
- remark(anIndex);
- in_type1 = false;
-}
-
-//
-// Rewind the input stream back to anIndex and force a : prior to resuming input.
-//
-void rewind_colon(YACC_MARK_TYPE anIndex, const CxxToken *aToken)
-{
- remark(anIndex);
- unmark();
- primed_tokens[0] = &colonToken;
- primed_tokens[1] = PARSE_DOT yylval.token;
-}
-
-//
-// Start a new binary search over the template/arithmetic alternative parses of a statement.
-// Marks the current position and saves it in a binary search context maintained on a private stack.
-//
-void start_search(bool enableType1)
-{
- bool type1Enabled = !CxxSearchContext::current() || CxxSearchContext::current()->enable_type1() ? true : false;
- CxxSearchContext::start(mark(), enableType1 && type1Enabled ? true : false);
-}
-
-//
-// Determine whether the just parsed < should be interpreted as a template or arithmetic operator.
-// The implementation here intersacts with a binary search to traverse all possibilities in
-// multiple passes. The search proceeds by branch and bound presuming the template interpretation.
-// A true token is forced into the input stream to take the template interpretaion. A false token
-// otherwise.
-//
-// An alternate implementation that keeps track of scopes may interact with semantic knowledge to make
-// the correct decision directly.
-//
-void template_test()
-{
- if (!CxxSearchContext::current() || CxxSearchContext::current()->is_template())
- {
- primed_tokens[0] = &plusToken;
- primed_tokens[1] = 0;
- }
- else
- {
- primed_tokens[0] = &minusToken;
- primed_tokens[1] = &angleToken;
- }
-}
-
-void token_put(CxxToken *aToken)
-{
- if (!tokenBuffer || !tokenSize)
- tokenBuffer = new CxxToken *[tokenSize = 256];
- else if (tokenWriteIndex >= tokenSize)
- {
- CxxToken **oldTokenBuffer = tokenBuffer;
- size_t oldTokenSize = tokenSize;
- tokenBuffer = new CxxToken *[tokenSize *= 2];
- memcpy(tokenBuffer, oldTokenBuffer, oldTokenSize * sizeof(*oldTokenBuffer));
- delete[] oldTokenBuffer;
- }
- tokenBuffer[tokenWriteIndex++] = aToken;
- tokenReadIndex = tokenWriteIndex;
-}
-
-//
-// Pop a marked context off the stack.
-//
-void unmark(const CxxToken *aToken)
-{
- if (bang_depth)
- bang_depth--;
- else
- ERRMSG("BUG - should not unmark with 0 bang.");
- if (tokenMarkDepth <= 0)
- ERRMSG("Unexpected unmark.");
- else
- tokenMarkDepth--;
-}
+++ /dev/null
-#include <CxxToken.hxx>
-#include <stdio.h>
-#ifndef _MSC_VER
-#include <alloca.h>
-#else
-#include <malloc.h>
-//#define alloca _alloca
-#endif
-void advance_search();
-void end_search(CxxToken *aToken);
-YACC_MARK_TYPE mark();
-YACC_MARK_TYPE mark_type1();
-size_t nest() { return 0; }
-void pop_bang(YACC_BANG_TYPE bangValue);
-YACC_BANG_TYPE push_bang();
-void remark(YACC_MARK_TYPE anIndex);
-void remark_type1(YACC_MARK_TYPE anIndex);
-void rewind_colon(YACC_MARK_TYPE anIndex, const CxxToken *aToken);
-void start_search(bool enableType1);
-void template_test();
-void unmark(const CxxToken *aToken = 0);
-void unnest(size_t aNest) {}
-
-void classify_argument();
-void classify_function();
-void dollar_kill();
-CxxTokens *get_code(CxxToken *);
-CxxTokens *get_expr();
-CxxTokens *get_for_init();
-CxxTokens *get_for_next();
-CxxTokens *get_for_test();
-CxxTokens *get_func();
-CxxTokens *get_raw(CxxToken *);
-CxxTokens *get_statement();
-void make(CxxToken *);
-void queue(CxxToken *);
-int set_replace_formals(int);
-
-extern CxxToken *_list_token;
-
-#ifndef BISON_PP_CLASS
-void yyerror(const char *s);
-#define yylex buffered_yylex
-int yylex();
-#endif
-
-#define YACC_ABSTRACT_ARRAY_EXPRESSION(a) make_abstract_array_expression(a)
-#define YACC_ABSTRACT_FUNCTION_EXPRESSION(a) make_abstract_function_expression(a)
-#define YACC_ACCESSIBILITY_SPECIFIER(a) make_accessibility_specifier(a)
-#define YACC_ACCESS_BASE_SPECIFIER(a,b) make_access_base_specifier(a,b)
-#define YACC_ACCESS_SPECIFIER_ID(a) make_access_specifier_id(a)
-#define YACC_ADD_EXPRESSION(a,b) make_add_expression(a, b)
-#define YACC_AND_EXPRESSION(a,b) make_and_expression(a,b)
-#define YACC_ARRAY_EXPRESSION(a,b) make_array_expression(a,b)
-#define YACC_ARROW_EXPRESSION(a,b) make_arrow_expression(a,b)
-#define YACC_ARROW_STAR_EXPRESSION(a,b) make_arrow_star_expression(a,b)
-#define YACC_ASM_DEFINITION(a) make_asm_definition(a)
-#define YACC_ASSIGNMENT_EXPRESSION(a,b,c) make_assignment_expression(a,b,c)
-#define YACC_BASE_SPECIFIER(a) make_base_specifier(a)
-#define YACC_BASE_SPECIFIERS(a,b) make_base_specifiers(a,b)
-#define YACC_BIT_FIELD_EXPRESSION(a,b) make_bit_field_expression(a,b)
-#define YACC_BREAK_STATEMENT() make_break_statement()
-#define YACC_BUILT_IN_ID(a) make_built_in_id(a)
-#define YACC_BUILT_IN_ID_ID(a) make_built_in_id_id(a)
-#define YACC_BUILT_IN_IDS(a,b) make_built_in_ids(a,b)
-#define YACC_BUILT_IN_NAME(a,b) make_built_in_name(a,b)
-#define YACC_CALL_EXPRESSION(a,b) make_call_expression(a,b)
-#define YACC_CASE_STATEMENT(a,b) make_case_statement(a,b)
-#define YACC_CAST_EXPRESSION(a,b) make_cast_expression(a,b)
-#define YACC_CHARACTER_LITERAL_EXPRESSION(a) make_character_literal_expression(a)
-#define YACC_CLASS_MEMBERS(a,b) make_class_members(a,b)
-#define YACC_CLASS_SPECIFIER_ID(a,b,c) make_class_specifier_id(a,b,c)
-#define YACC_CLASS_TEMPLATE_PARAMETER(a) make_class_template_parameter(a)
-#define YACC_CLASS_TYPE_PARAMETER(a) make_class_type_parameter(a)
-#define YACC_COMPILE_DECLARATION(a,b) compile_declaration(a,b)
-#define YACC_COMPILE_STATEMENT(a) compile_statement(a)
-#define YACC_COMPLEMENT_EXPRESSION(a) make_complement_expression(a)
-#define YACC_COMPOUND_STATEMENT(a) make_compound_statement(a)
-#define YACC_CONDITION(a) make_condition(a)
-#define YACC_CONDITIONAL_EXPRESSION(a,b,c) make_conditional_expression(a,b,c)
-#define YACC_CONST_CAST_EXPRESSION(a,b) make_const_cast_expression(a,b)
-#define YACC_CONTINUE_STATEMENT() make_continue_statement()
-#define YACC_CONVERSION_FUNCTION_ID(a) make_conversion_function_id(a)
-#define YACC_CTOR_DEFINITION(a,b) make_ctor_definition(a,b)
-#define YACC_CTOR_FUNCTION_BLOCK(a,b) make_ctor_function_block(a,b)
-#define YACC_CV_DECLARATOR(a,b) make_cv_declarator(a,b)
-#define YACC_CV_DECL_SPECIFIER(a) make_cv_decl_specifier(a)
-#define YACC_CV_QUALIFIERS(a,b) make_cv_qualifiers(a,b)
-#define YACC_DECLARATIONS(a,b) make_declarations(a,b)
-#define YACC_DECLARATION_STATEMENT(a) make_declaration_statement(a)
-#define YACC_DECL_SPECIFIER_DECLARATION(a,b) make_decl_specifier_declaration(a,b)
-#define YACC_DECL_SPECIFIER_EXPRESSION(a,b) make_decl_specifier_expression(a,b)
-#define YACC_DECL_SPECIFIER_NAME(a,b) make_decl_specifier_name(a,b)
-#define YACC_DECL_SPECIFIER_PARAMETER(a,b) make_decl_specifier_parameter(a,b)
-#define YACC_DECL_SPECIFIERS(a,b) make_decl_specifiers(a,b)
-#define YACC_DECL_SPECIFIER_TREE_ARGUMENT(a,b) make_decl_specifier_tree_argument(a,b)
-#define YACC_DECL_SPECIFIER_TREE_ARGUMENTS(a,b) make_decl_specifier_tree_arguments(a,b)
-#define YACC_DEFAULT_STATEMENT(a) make_default_statement(a)
-#define YACC_DELETE_EXPRESSION(a) make_delete_expression(a)
-#define YACC_DERIVED_CLAUSE(a,b) make_derived_clause(a,b)
-#define YACC_DESTRUCTOR_ID(a) make_destructor_id(a)
-#define YACC_DIVIDE_EXPRESSION(a,b) make_divide_expression(a,b)
-#define YACC_DOT_EXPRESSION(a,b) make_dot_expression(a,b)
-#define YACC_DOT_STAR_EXPRESSION(a,b) make_dot_star_expression(a,b)
-#define YACC_DO_WHILE_STATEMENT(a,b) make_do_while_statement(a,b)
-#define YACC_DYNAMIC_CAST_EXPRESSION(a,b) make_dynamic_cast_expression(a,b)
-#define YACC_ELABORATED_TYPE_SPECIFIER(a,b) make_elaborated_type_specifier(a,b)
-#define YACC_ELLIPSIS_EXPRESSION() make_ellipsis_expression()
-#define YACC_ENUMERATOR(a,b) make_enumerator(a,b)
-#define YACC_ENUMERATORS(a,b) make_enumerators(a,b)
-#define YACC_ENUM_SPECIFIER_ID(a,b) make_enum_specifier_id(a,b)
-#define YACC_ENUM_TREE_ID(a) make_enum_tree_id(a)
-#define YACC_EPSILON() make_epsilon()
-#define YACC_EQUAL_EXPRESSION(a,b) make_equal_expression(a,b)
-#define YACC_EXCEPTION_DECLARATION(a) make_exception_declaration(a)
-#define YACC_EXCEPTION_SPECIFICATION(a) make_exception_specification(a)
-#define YACC_EXCLUSIVE_OR_EXPRESSION(a,b) make_exclusive_or_expression(a,b)
-#define YACC_EXPLICIT_IMPLEMENTATION_DECLARATION(a) make_explicit_implementation_declaration(a)
-#define YACC_EXPLICIT_INTERFACE_DECLARATION(a) make_explicit_interface_declaration(a)
-#define YACC_EXPLICIT_SPECIALIZATION(a) make_explicit_specialization(a)
-#define YACC_EXPORT_IMPLEMENTATION_DECLARATION(a) make_export_implementation_declaration(a)
-#define YACC_EXPORT_INTERFACE_DECLARATION(a) make_export_interface_declaration(a)
-#define YACC_EXPORT_NOIMPLEMENTATION_DECLARATION() make_export_noimplementation_declaration()
-#define YACC_EXPRESSION(a) make_expression(a)
-#define YACC_EXPRESSIONS(a,b) make_expressions(a,b)
-#define YACC_EXPRESSION_PARAMETER(a) make_expression_parameter(a)
-#define YACC_FALSE_EXPRESSION() make_false_expression()
-#define YACC_FILESPACE_DECLARATION(a) make_filespace_declaration(a)
-#define YACC_FILESPACE_SPECIFIER(a,b) make_filespace_specifier(a,b)
-#define YACC_FILE_ID(a) make_file_id(a)
-#define YACC_FILE_ID_IMPLEMENTATION(a) make_file_id_implementation(a)
-#define YACC_FILE_ID_INTERFACE(a) make_file_id_interface(a)
-#define YACC_FILE_IDS(a,b) make_file_ids(a,b)
-#define YACC_FILE_NAME(a) make_file_name(a)
-#define YACC_FILE_NAME_GUARD(a,b) make_file_name_guard(a,b)
-#define YACC_FILE_NAME_IMPLEMENTATION(a) make_file_name_implementation(a)
-#define YACC_FILE_NAME_INTERFACE(a) make_file_name_interface(a)
-#define YACC_FILE_NAME_NOGUARD(a) make_file_name_noguard(a)
-#define YACC_FILE_NAME_PATH(a,b) make_file_name_path(a,b)
-#define YACC_FILE_NAME_PREFIX(a,b) make_file_name_prefix(a,b)
-#define YACC_FILE_NAME_SUFFIX(a,b) make_file_name_suffix(a,b)
-#define YACC_FILE_NAME_TEMPLATE(a) make_file_name_template(a)
-#define YACC_FILE_NAME_UTILITY(a,b) make_file_name_utility(a,b)
-#define YACC_FLOATING_LITERAL_EXPRESSION(a) make_floating_literal_expression(a)
-#define YACC_FOR_STATEMENT(a,b,c,d) make_for_statement(a,b,c,d)
-#define YACC_FUNCTION_BLOCK(a) make_function_block(a)
-#define YACC_FUNCTION_DECLARATIONS(a,b) make_function_declarations(a,b)
-#define YACC_FUNCTION_DEFINITION(a,b) make_function_definition(a,b)
-#define YACC_GLOBAL_DECLARATOR(a,b) make_global_declarator(a,b)
-#define YACC_GLOBAL_EXPRESSION(a, b) make_global_expression(a,b)
-#define YACC_GLOBAL_ID(a,b) make_global_id(a,b)
-#define YACC_GOTO_STATEMENT(a) make_goto_statement(a)
-#define YACC_GREATER_EQUAL_EXPRESSION(a,b) make_greater_equal_expression(a,b)
-#define YACC_GREATER_THAN_EXPRESSION(a,b) make_greater_than_expression(a,b)
-#define YACC_HANDLER(a,b) make_handler(a,b)
-#define YACC_HANDLERS(a,b) make_handlers(a,b)
-#define YACC_IF_STATEMENT(a,b,c) make_if_statement(a,b,c)
-#define YACC_INCLUDE_DECLARATION(a,b) make_include_declaration(a,b)
-#define YACC_INCLUSIVE_OR_EXPRESSION(a,b) make_inclusive_or_expression(a,b)
-#define YACC_INITIALIZED_PARAMETER(a,b) make_initialized_parameter(a, b)
-#define YACC_INITIALIZER_CLAUSES(a,b) make_initializer_clauses(a,b)
-#define YACC_INITIALIZER_EXPRESSION_CLAUSE(a) make_initializer_expression_clause(a)
-#define YACC_INITIALIZER_LIST_CLAUSE(a) make_initializer_list_clause(a)
-#define YACC_INIT_SIMPLE_TYPE_PARAMETER(a,b) make_init_simple_type_parameter(a,b)
-#define YACC_INIT_TEMPLATED_PARAMETER(a,b) make_init_templated_parameter(a,b)
-#define YACC_INLINE_AS_FRIEND() make_inline_as_friend()
-#define YACC_INLINE_IF_SHORT() make_inline_if_short()
-#define YACC_INLINE_IN_IMPLEMENTATION() make_inline_in_implementation()
-#define YACC_INLINE_IN_INTERFACE() make_inline_in_interface()
-#define YACC_INDEX_CAST_EXPRESSION(a,b) make_index_cast_expression(a,b)
-#define YACC_INPUT_FILE(a) make_input_file(a)
-#define YACC_INTEGER_LITERAL_EXPRESSION(a) make_integer_literal_expression(a)
-#define YACC_LABEL_STATEMENT(a,b) make_label_statement(a,b)
-#define YACC_LESS_EQUAL_EXPRESSION(a,b) make_less_equal_expression(a,b)
-#define YACC_LESS_THAN_EXPRESSION(a,b) make_less_than_expression(a,b)
-#define YACC_LINE() make_line()
-#define YACC_LINED_DECLARATION(a,b) make_lined_declaration(a,b)
-#define YACC_LINED_STATEMENT(a,b) make_lined_statement(a,b)
-#define YACC_LINED_TOKEN(a,b) make_lined_token(a,b)
-#define YACC_LINKAGE_SPECIFICATION(a) make_linkage_specification(a)
-#define YACC_LINKAGE_SPECIFIER(a,b) make_linkage_specifier(a,b)
-#define YACC_LOGICAL_AND_EXPRESSION(a,b) make_logical_and_expression(a,b)
-#define YACC_LOGICAL_OR_EXPRESSION(a,b) make_logical_or_expression(a,b)
-#define YACC_MEMBER_DECLARATIONS(a,b) make_member_declarations(a,b)
-#define YACC_MEM_INITIALIZER(a,b) make_mem_initializer(a,b)
-#define YACC_MEM_INITIALIZERS(a,b) make_mem_initializers(a,b)
-#define YACC_META_ASSIGNMENT_EXPRESSION(a,b,c) make_meta_assignment_expression(a,b,c)
-#define YACC_META_BASE_SPECIFIER(a) make_meta_base_specifier(a)
-#define YACC_META_BREAK_STATEMENT() make_meta_break_statement()
-#define YACC_META_BUILT_IN_TYPE(a) make_meta_built_in_type(a)
-#define YACC_META_CASE_STATEMENT(a,b) make_meta_case_statement(a,b)
-#define YACC_META_CLASS(a,b,c) make_meta_class(a,b,c)
-#define YACC_META_CONTINUE_STATEMENT() make_meta_continue_statement()
-#define YACC_META_DEFAULT_STATEMENT(a) make_meta_default_statement(a)
-#define YACC_META_DO_WHILE_STATEMENT(a,b,c) make_meta_do_while_statement(a,b,c)
-#define YACC_META_FOR_STATEMENT(a,b,c,d,e) make_meta_for_statement(a,b,c,d,e)
-#define YACC_META_FUNCTION(a,b,c) make_meta_function(a,b,c)
-#define YACC_META_IF_STATEMENT(a,b,c,d) make_meta_if_statement(a,b,c,d)
-#define YACC_META_INITIALIZER(a,b) make_meta_initializer(a,b)
-#define YACC_META_INITIALIZERS(a,b) make_meta_initializers(a,b)
-#define YACC_META_RETURN_STATEMENT(a) make_meta_return_statement(a)
-#define YACC_META_STATEMENT(a) make_meta_statement(a)
-#define YACC_META_STATEMENT_DECLARATION(a) make_meta_statement_declaration(a)
-#define YACC_META_SWITCH_STATEMENT(a,b,c) make_meta_switch_statement(a,b,c)
-#define YACC_META_TYPE(a) make_meta_type(a)
-#define YACC_META_TYPE_ID(a) make_meta_type_id(a)
-#define YACC_META_WHILE_STATEMENT(a,b,c) make_meta_while_statement(a,b,c)
-#define YACC_MINUS_EXPRESSION(a) make_minus_expression(a)
-#define YACC_MODULUS_EXPRESSION(a,b) make_modulus_expression(a,b)
-#define YACC_MULTIPLY_EXPRESSION(a,b,c) make_multiply_expression(a,b,c)
-#define YACC_NAME(a) make_name(a)
-#define YACC_NAMESPACE_ALIAS_DEFINITION(a,b) make_namespace_alias_definition(a,b)
-#define YACC_NAMESPACE_DECLARATION(a) make_namespace_declaration(a)
-#define YACC_NAMESPACE_DEFINITION(a,b) make_namespace_definition(a,b)
-#define YACC_NAME_EXPRESSION(a) make_name_expression(a)
-#define YACC_NESTED_DECLARATOR(a,b) make_nested_declarator(a,b)
-#define YACC_NESTED_ID(a,b) make_nested_id(a,b)
-#define YACC_NESTED_SCOPE(a) make_nested_scope(a)
-#define YACC_NEW_EXPRESSION(a,b,c) make_new_expression(a,b,c)
-#define YACC_NEW_TYPE_ID_EXPRESSION(a,b,c) make_new_type_id_expression(a,b,c)
-#define YACC_NOT_CONST() make_not_const()
-#define YACC_NOT_EQUAL_EXPRESSION(a,b) make_not_equal_expression(a,b)
-#define YACC_NOT_EXPRESSION(a) make_not_expression(a)
-#define YACC_NOT_INLINE() make_not_inline()
-#define YACC_NOT_STATIC() make_not_static()
-#define YACC_NOT_VIRTUAL() make_not_virtual()
-#define YACC_NOT_VIRTUAL_BASE_SPECIFIER(a) make_not_virtual_base_specifier(a)
-#define YACC_NOT_VOLATILE() make_not_volatile()
-#define YACC_NUMBER_LITERAL_EXPRESSION(a) make_number_literal_expression(a)
-#define YACC_OBJECT_SCOPE_EXPRESSION(a,b) make_object_scope_expression(a,b)
-#define YACC_OPERATOR_ADD_ID() make_operator_add_id()
-#define YACC_OPERATOR_ARROW_ID() make_operator_arrow_id()
-#define YACC_OPERATOR_ARROW_STAR_ID() make_operator_arrow_star_id()
-#define YACC_OPERATOR_ASS_ADD_ID() make_operator_ass_add_id()
-#define YACC_OPERATOR_ASS_BIT_AND_ID() make_operator_ass_bit_and_id()
-#define YACC_OPERATOR_ASS_BIT_OR_ID() make_operator_ass_bit_or_id()
-#define YACC_OPERATOR_ASS_DIV_ID() make_operator_ass_div_id()
-#define YACC_OPERATOR_ASS_ID() make_operator_ass_id()
-#define YACC_OPERATOR_ASS_MOD_ID() make_operator_ass_mod_id()
-#define YACC_OPERATOR_ASS_MUL_ID() make_operator_ass_mul_id()
-#define YACC_OPERATOR_ASS_SHL_ID() make_operator_ass_shl_id()
-#define YACC_OPERATOR_ASS_SHR_ID() make_operator_ass_shr_id()
-#define YACC_OPERATOR_ASS_SUB_ID() make_operator_ass_sub_id()
-#define YACC_OPERATOR_ASS_XOR_ID() make_operator_ass_xor_id()
-#define YACC_OPERATOR_BIT_AND_ID() make_operator_bit_and_id()
-#define YACC_OPERATOR_BIT_NOT_ID() make_operator_bit_not_id()
-#define YACC_OPERATOR_BIT_OR_ID() make_operator_bit_or_id()
-#define YACC_OPERATOR_CALL_ID() make_operator_call_id()
-#define YACC_OPERATOR_COMMA_ID() make_operator_comma_id()
-#define YACC_OPERATOR_DEC_ID() make_operator_dec_id()
-#define YACC_OPERATOR_DELETE_ID() make_operator_delete_id()
-#define YACC_OPERATOR_DIV_ID() make_operator_div_id()
-#define YACC_OPERATOR_EQ_ID() make_operator_eq_id()
-#define YACC_OPERATOR_FUNCTION_ID(a) make_operator_function_id(a)
-#define YACC_OPERATOR_GE_ID() make_operator_ge_id()
-#define YACC_OPERATOR_GT_ID() make_operator_gt_id()
-#define YACC_OPERATOR_INC_ID() make_operator_inc_id()
-#define YACC_OPERATOR_INDEX_ID() make_operator_index_id()
-#define YACC_OPERATOR_LE_ID() make_operator_le_id()
-#define YACC_OPERATOR_LOG_AND_ID() make_operator_log_and_id()
-#define YACC_OPERATOR_LOG_NOT_ID() make_operator_log_not_id()
-#define YACC_OPERATOR_LOG_OR_ID() make_operator_log_or_id()
-#define YACC_OPERATOR_LT_ID() make_operator_lt_id()
-#define YACC_OPERATOR_MOD_ID() make_operator_mod_id()
-#define YACC_OPERATOR_MUL_ID() make_operator_mul_id()
-#define YACC_OPERATOR_NE_ID() make_operator_ne_id()
-#define YACC_OPERATOR_NEW_ID() make_operator_new_id()
-#define YACC_OPERATOR_SHL_ID() make_operator_shl_id()
-#define YACC_OPERATOR_SHR_ID() make_operator_shr_id()
-#define YACC_OPERATOR_SUB_ID() make_operator_sub_id()
-#define YACC_OPERATOR_XOR_ID() make_operator_xor_id()
-#define YACC_PARAMETERS(a,b) make_parameters(a,b)
-#define YACC_PARENTHESISED(a,b,c) make_parenthesised(a,b,c)
-#define YACC_POINTER_DECLARATOR() make_pointer_declarator()
-#define YACC_POINTER_EXPRESSION(a,b) make_pointer_expression(a,b)
-#define YACC_PLUS_EXPRESSION(a) make_plus_expression(a)
-#define YACC_POSITION(a,b) make_position(a)
-#define YACC_POSITION_FUNCTION_BLOCK(a,b) make_position_function_block(a,b)
-#define YACC_POST_DECREMENT_EXPRESSION(a) make_post_decrement_expression(a)
-#define YACC_POST_INCREMENT_EXPRESSION(a) make_post_increment_expression(a)
-#define YACC_PRE_DECREMENT_EXPRESSION(a) make_pre_decrement_expression(a)
-#define YACC_PRE_INCREMENT_EXPRESSION(a) make_pre_increment_expression(a)
-#define YACC_PSEUDO_DESTRUCTOR_ID(a,b) make_pseudo_destructor_id(a,b)
-#define YACC_PURE_VIRTUAL() make_pure_virtual()
-#define YACC_READ_ONLY_RESULT(a) make_read_only_result(a)
-#define YACC_READ_WRITE_RESULT(a) make_read_write_result(a)
-#define YACC_REFERENCE_DECLARATOR() make_reference_declarator()
-#define YACC_REINTERPRET_CAST_EXPRESSION(a,b) make_reinterpret_cast_expression(a,b)
-#define YACC_RESULT(a) make_result(a)
-#define YACC_RETURN_STATEMENT(a) make_return_statement(a)
-#define YACC_SCOPED_POINTER_EXPRESSION(a,b,c) make_scoped_pointer_expression(a,b,c)
-#define YACC_SCOPED_ID(a,b) make_scoped_id(a,b)
-#define YACC_SEGMENT(a,b) make_segment(a)
-#define YACC_SEGMENT_FUNCTION_BLOCK(a,b) make_segment_function_block(a,b)
-#define YACC_SET_TEMPLATE_DECLARATION(a) make_set_template_declaration(a)
-#define YACC_SET_TEMPLATE_DECL_SPECIFIER(a) make_set_template_decl_specifier(a)
-#define YACC_SET_TEMPLATE_EXPRESSION(a) make_set_template_expression(a)
-#define YACC_SET_TEMPLATE_ID(a) make_set_template_id(a)
-#define YACC_SET_TEMPLATE_NAME(a) make_set_template_name(a)
-#define YACC_SET_TEMPLATE_SCOPE(a) make_set_template_scope(a)
-#define YACC_SHIFT_LEFT_EXPRESSION(a,b) make_shift_left_expression(a,b)
-#define YACC_SHIFT_RIGHT_EXPRESSION(a,b) make_shift_right_expression(a,b)
-#define YACC_SIMPLE_DECLARATION(a) make_simple_declaration(a)
-#define YACC_SIZEOF_EXPRESSION(a) make_sizeof_expression(a)
-#define YACC_STATEMENTS(a,b) make_statements(a,b)
-#define YACC_STATIC_CAST_EXPRESSION(a,b) make_static_cast_expression(a,b)
-#define YACC_STRINGS(a,b) make_strings(a,b)
-#define YACC_STRING_LITERAL_EXPRESSION(a) make_string_literal_expression(a)
-#define YACC_SUBTRACT_EXPRESSION(a,b) make_subtract_expression(a,b)
-#define YACC_SWITCH_STATEMENT(a,b) make_switch_statement(a,b)
-#define YACC_SYNTAX_MACRO_DEFINITION(a,b,c,d,e) make_syntax_macro_definition(a,b,c,d,e)
-#define YACC_SYNTAX_MACRO_PARAMETER(a,b,c) make_syntax_macro_parameter(a,b,c)
-#define YACC_SYNTAX_MACRO_PARAMETERS(a,b) make_syntax_macro_parameters(a,b)
-#define YACC_TEMPLATE_ARGUMENT(a) make_template_argument(a)
-#define YACC_TEMPLATE_ARGUMENTS(a,b) make_template_arguments(a,b)
-#define YACC_TEMPLATED_TEMPLATE_PARAMETER(a,b) make_templated_template_parameter(a,b)
-#define YACC_TEMPLATED_TYPE_PARAMETER(a,b) make_templated_type_parameter(a,b)
-#define YACC_TEMPLATE_DECLARATION(a,b) make_template_declaration(a,b)
-#define YACC_TEMPLATE_NAME(a,b) make_template_name(a,b)
-#define YACC_TEMPLATE_PARAMETER(a) make_template_parameter(a)
-#define YACC_TEMPLATE_PARAMETERS(a,b) make_template_parameters(a,b)
-#define YACC_THIS_EXPRESSION() make_this_expression()
-#define YACC_THROW_EXPRESSION(a) make_throw_expression(a)
-#define YACC_TOKENS_EXPRESSION(a) make_tokens_expression(a)
-#define YACC_TREE_ARGUMENT(a) make_tree_argument(a)
-#define YACC_TREE_ARGUMENTS(a,b) make_tree_arguments(a,b)
-#define YACC_TREE_ARRAY_EXPRESSION(a,b) make_tree_array_expression(a,b)
-#define YACC_TREE_ARROW_EXPRESSION(a,b) make_tree_arrow_expression(a,b)
-#define YACC_TREE_ARROW_CALL_EXPRESSION(a,b,c) make_tree_arrow_call_expression(a,b,c)
-#define YACC_TREE_CALL_EXPRESSION(a,b) make_tree_call_expression(a,b)
-#define YACC_TREE_DOT_EXPRESSION(a,b) make_tree_dot_expression(a,b)
-#define YACC_TREE_DOT_CALL_EXPRESSION(a,b,c) make_tree_dot_call_expression(a,b,c)
-#define YACC_TREE_EXPRESSION(a) make_tree_expression(a)
-#define YACC_TREE_ID(a) make_tree_id(a)
-#define YACC_TREE_POINTER_EXPRESSION(a) make_tree_pointer_expression(a)
-#define YACC_TRUE_EXPRESSION() make_true_expression()
-#define YACC_TRY_BLOCK(a,b) make_try_block(a,b)
-#define YACC_TRY_BLOCK_STATEMENT(a) make_try_block_statement(a)
-#define YACC_TRY_FUNCTION_BLOCK(a,b) make_try_function_block(a,b)
-#define YACC_TYPE1_EXPRESSION(a,b,c) make_type1_expression(a,b,c)
-#define YACC_TYPE1_PARAMETERS(a,b) make_type1_parameters(a,b)
-#define YACC_TYPED_EXPRESSION(a,b) make_typed_expression(a,b)
-#define YACC_TYPED_NAME(a,b) make_typed_name(a,b)
-#define YACC_TYPEID_EXPRESSION(a) make_typeid_expression(a)
-#define YACC_TYPENAME_TEMPLATE_PARAMETER(a) make_typename_template_parameter(a)
-#define YACC_TYPENAME_TYPE_PARAMETER(a) make_typename_type_parameter(a)
-#define YACC_TYPE_TEMPLATE_PARAMETER(a,b) make_type_template_parameter(a,b)
-#define YACC_USING_DECLARATION(a,b) make_using_declaration(a,b)
-#define YACC_USING_DIRECTIVE(a) make_using_directive(a)
-#define YACC_USING_FUNCTION_BLOCK(a,b) make_using_function_block(a,b)
-#define YACC_USING_IMPLEMENTATION_DECLARATION(a) make_using_implementation_declaration(a)
-#define YACC_USING_INTERFACE_DECLARATION(a) make_using_interface_declaration(a)
-#define YACC_UTILITY(a) make_utility(0)
-#define YACC_UTILITY_MODE() make_utility_mode()
-#define YACC_VIRTUAL_BASE_SPECIFIER(a) make_virtual_base_specifier(a)
-#define YACC_WHILE_STATEMENT(a,b) make_while_statement(a,b)
-
-CxxDeclaration *compile_declaration(CxxUtility *utilityMode, CxxDeclaration *aDeclaration) { return 0; }
-CxxStatement *compile_statement(CxxStatement *aDeclaration) { return 0; }
-void make_result(CxxToken *aResult) {}
-
-CxxExpression *make_abstract_array_expression(CxxExpression *sizeExpr) { return 0; }
-CxxExpression *make_abstract_function_expression(CxxParenthesised *aparenthesis) { return 0; }
-CxxBaseSpecifier *make_access_base_specifier(CxxBaseSpecifier *baseSpecifier, CxxAccessSpecifier *accessSpecifier) { return 0; }
-CxxDeclSpecifierId *make_access_specifier_id(CxxAccessSpecifier *aName) { return 0; }
-CxxDeclaration *make_accessibility_specifier(CxxAccessSpecifier *accessSpecifier) { return 0; }
-CxxExpression *make_add_expression(CxxExpression *leftExpr, CxxExpression *rightExpr) { return 0; }
-CxxExpression *make_and_expression(CxxExpression *leftExpr, CxxExpression *rightExpr) { return 0; }
-CxxExpression *make_array_expression(CxxExpression *anExpr, CxxExpression *indexExpr) { return 0; }
-CxxExpression *make_arrow_expression(CxxExpression *anExpr, CxxName *aName) { return 0; }
-CxxExpression *make_arrow_star_expression(CxxExpression *anExpr, CxxExpression *memberExpr) { return 0; }
-CxxDeclaration *make_asm_definition(CxxStrings *aString) { return 0; }
-CxxExpression *make_assignment_expression(CxxExpression *leftExpr, CxxToken *assOp, CxxExpression *rightExpr) { return 0; }
-CxxBaseSpecifier *make_base_specifier(CxxName *aName) { return 0; }
-CxxBaseSpecifiers *make_base_specifiers(CxxBaseSpecifiers *aList, CxxBaseSpecifier *anElement) { return 0; }
-CxxExpression *make_bit_field_expression(CxxExpression *nameExpr, CxxExpression *sizeExpr) { return 0; }
-CxxStatement *make_break_statement() { return 0; }
-CxxName *make_built_in_id(CxxBuiltInId *aName) { return 0; }
-CxxName *make_built_in_id_id(CxxBuiltInId *aName) { return 0; }
-CxxBuiltInId *make_built_in_ids(CxxBuiltInId *anExpr, CxxBuiltInId *anElement) { return 0; }
-CxxName *make_built_in_name(CxxName *aName, CxxBuiltInId *anElement) { return 0; }
-CxxExpression *make_call_expression(CxxExpression *anExpr, CxxParenthesised *aParenthesis) { return 0; }
-CxxStatement *make_case_statement(CxxExpression *anExpr, CxxStatement *aStmt) { return 0; }
-CxxExpression *make_cast_expression(CxxExpression *aCast, CxxExpression *anExpr) { return 0; }
-CxxExpression *make_character_literal_expression(CxxCharacterLiteral *aLiteral) { return 0; }
-CxxName *make_class_members(CxxClass *aClass, CxxMemberDeclarations *memberDeclarations) { return 0; }
-CxxClass *make_class_specifier_id(CxxClassKey *classKey, CxxName *aName, CxxBaseSpecifiers *baseSpecifiers) { return 0; }
-CxxSimpleTypeParameter *make_class_template_parameter(CxxName *aName) { return 0; }
-CxxSimpleTypeParameter *make_class_type_parameter(CxxName *aName) { return 0; }
-CxxStatement *make_compound_statement(CxxStatements *statementList) { return 0; }
-CxxExpression *make_complement_expression(CxxExpression *anExpr) { return 0; }
-CxxCondition *make_condition(CxxParameters *aList) { return 0; }
-CxxExpression *make_conditional_expression(CxxExpression *testExpr, CxxExpression *trueExpr, CxxExpression *falseExpr) { return 0; }
-CxxExpression *make_const_cast_expression(CxxExpression *aType, CxxExpression *anExpr) { return 0; }
-CxxStatement *make_continue_statement() { return 0; }
-CxxName *make_conversion_function_id(CxxExpression *typeId) { return 0; }
-CxxExpression *make_ctor_definition(CxxExpressions *anExpr, CxxFunctionBody *functionBody) { return 0; }
-CxxFunctionBody *make_ctor_function_block(CxxFunctionBody *functionBody, CxxMemInitializers *ctorList) { return 0; }
-CxxDeclSpecifierId *make_cv_decl_specifier(CxxCvQualifiers *cvQualifiers) { return 0; }
-CxxPointerDeclarator *make_cv_declarator(CxxPointerDeclarator *aDeclarator, CxxCvQualifiers *cvQualifiers) { return 0; }
-CxxCvQualifiers *make_cv_qualifiers(CxxCvQualifiers *aList, CxxCvQualifiers *anElement) { return 0; }
-CxxDeclaration *make_decl_specifier_declaration(CxxDeclaration *aDeclaration, CxxDeclSpecifierId *declSpecifier) { return 0; }
-CxxExpression *make_decl_specifier_expression(CxxExpression *anExpr, CxxDeclSpecifierId *declSpecifier) { return 0; }
-CxxName *make_decl_specifier_name(CxxName *aName, CxxDeclSpecifierId *declSpecifier) { return 0; }
-CxxParameter *make_decl_specifier_parameter(CxxParameter *aName, CxxDeclSpecifierId *declSpecifier) { return 0; }
-CxxToken *make_decl_specifier_tree_argument(CxxToken *treeArgument, CxxDeclSpecifierId *aName) { return 0; }
-CxxTokens *make_decl_specifier_tree_arguments(CxxTokens *treeArguments, CxxDeclSpecifierId *aName) { return 0; }
-CxxDeclSpecifierId *make_decl_specifiers(CxxDeclSpecifierId *aList, CxxDeclSpecifierId *anElement) { return 0; }
-CxxDeclarations *make_declarations(CxxDeclarations *aList, CxxDeclaration *anElement) { return 0; }
-CxxStatement *make_declaration_statement(CxxDeclaration *aDecl) { return 0; }
-CxxStatement *make_default_statement(CxxStatement *aStmt) { return 0; }
-CxxExpression *make_delete_expression(CxxExpression *anExpr) { return 0; }
-CxxDeclaration *make_derived_clause(CxxExpression *derivedPredicate, CxxDeclaration *aDeclaration) { return 0; }
-CxxName *make_destructor_id(CxxName *aName) { return 0; }
-CxxExpression *make_divide_expression(CxxExpression *leftExpr, CxxExpression *rightExpr) { return 0; }
-CxxStatement *make_do_while_statement(CxxStatement *aStmt, CxxExpression *testExpr) { return 0; }
-CxxExpression *make_dot_expression(CxxExpression *anExpr, CxxName *aName) { return 0; }
-CxxExpression *make_dot_star_expression(CxxExpression *anExpr, CxxExpression *memberExpr) { return 0; }
-CxxExpression *make_dynamic_cast_expression(CxxExpression *aType, CxxExpression *anExpr) { return 0; }
-CxxName *make_elaborated_type_specifier(CxxClassKey *classKey, CxxName *aName) { return 0; }
-CxxParameter *make_ellipsis_expression() { return 0; }
-CxxName *make_enum_specifier_id(CxxName *aName, CxxEnumerators *aList) { return 0; }
-CxxEnumerator *make_enumerator(CxxName *aName, CxxExpression *anExpr) { return 0; }
-CxxEnumerators *make_enumerators(CxxEnumerators *aList, CxxEnumerator *anElement) { return 0; }
-CxxName *make_epsilon() { return 0; }
-CxxExpression *make_equal_expression(CxxExpression *leftExpr, CxxExpression *rightExpr) { return 0; }
-CxxExceptionDeclaration *make_exception_declaration(CxxParameter *aParameter) { return 0; }
-CxxExceptionSpecification *make_exception_specification(CxxExpressions *typeIds) { return 0; }
-CxxExpression *make_exclusive_or_expression(CxxExpression *leftExpr, CxxExpression *rightExpr) { return 0; }
-CxxDeclaration *make_explicit_implementation_declaration(CxxTokens *someTokens) { return 0; }
-CxxDeclaration *make_explicit_interface_declaration(CxxTokens *someTokens) { return 0; }
-CxxDeclaration *make_explicit_specialization(CxxDeclaration *aDeclaration) { return 0; }
-CxxDeclaration *make_export_implementation_declaration(CxxFileId *fileId) { return 0; }
-CxxDeclaration *make_export_interface_declaration(CxxFileId *fileId) { return 0; }
-CxxDeclaration *make_export_noimplementation_declaration() { return 0; }
-CxxExpression *make_expression(CxxExpressions *aList) { return 0; }
-CxxParameter *make_expression_parameter(CxxExpression *anExpr) { return 0; }
-CxxExpressions *make_expressions(CxxExpressions *aList, CxxExpression *anElement) { return 0; }
-CxxExpression *make_false_expression() { return 0; }
-CxxFileId *make_file_id(CxxFileName *fileName) { return 0; }
-CxxFileId *make_file_id_implementation(CxxName *aName) { return 0; }
-CxxFileId *make_file_id_interface(CxxName *aName) { return 0; }
-CxxFileIds *make_file_ids(CxxFileIds *aList, CxxFileId *anElement) { return 0; }
-CxxFileName *make_file_name(CxxStrings *aString) { return 0; }
-CxxFileName *make_file_name_guard(CxxFileName *fileName, CxxStrings *aString) { return 0; }
-CxxFileName *make_file_name_implementation(CxxFileName *fileName) { return 0; }
-CxxFileName *make_file_name_interface(CxxFileName *fileName) { return 0; }
-CxxFileName *make_file_name_noguard(CxxFileName *fileName) { return 0; }
-CxxFileName *make_file_name_path(CxxFileName *fileName, CxxStrings *aString) { return 0; }
-CxxFileName *make_file_name_prefix(CxxFileName *fileName, CxxStrings *aString) { return 0; }
-CxxFileName *make_file_name_suffix(CxxFileName *fileName, CxxStrings *aString) { return 0; }
-CxxFileName *make_file_name_template(CxxFileName *fileName) { return 0; }
-CxxFileName *make_file_name_utility(CxxFileName *fileName, CxxUtility *aUtility) { return 0; }
-CxxDeclaration *make_filespace_declaration(CxxName *aName) { return 0; }
-CxxName *make_filespace_specifier(CxxFileName *fileName, CxxDeclarations *aDeclaration) { return 0; }
-CxxExpression *make_floating_literal_expression(CxxFloatingLiteral *aLiteral) { return 0; }
-CxxStatement *make_for_statement(CxxExpression *initExpr, CxxCondition *testExpr, CxxExpression *stepExpr, CxxStatement *aStmt) { return 0; }
-CxxFunctionBody *make_function_block(CxxStatement *aStatement) { return 0; }
-CxxFunctionDeclarations *make_function_declarations(CxxFunctionDeclarations *aList, CxxDeclaration *anElement) { return 0; }
-CxxExpression *make_function_definition(CxxExpression *anExpr, CxxFunctionBody *functionBody) { return 0; }
-CxxDeclarator *make_global_declarator(CxxIsTemplate isTemplate, CxxDeclarator *aDeclarator) { return 0; }
-CxxExpression *make_global_expression(CxxIsTemplate isTemplate, CxxNewExpression *anExpr) { return 0; }
-CxxName *make_global_id(CxxIsTemplate isTemplate, CxxName *nestedId) { return 0; }
-CxxStatement *make_goto_statement(CxxToken *aLabel) { return 0; }
-CxxExpression *make_greater_equal_expression(CxxExpression *leftExpr, CxxExpression *rightExpr) { return 0; }
-CxxExpression *make_greater_than_expression(CxxExpression *leftExpr, CxxExpression *rightExpr) { return 0; }
-CxxHandler *make_handler(CxxExceptionDeclaration *exceptionDeclaration, CxxStatement *aStatement) { return 0; }
-CxxHandlers *make_handlers(CxxHandlers *aList, CxxHandler *anElement) { return 0; }
-CxxStatement *make_if_statement(CxxCondition *testExpr, CxxStatement *trueStmt, CxxStatement *falseStmt) { return 0; }
-CxxDeclaration *make_include_declaration(CxxStrings *aString, CxxUtility *aUtility) { return 0; }
-CxxExpression *make_inclusive_or_expression(CxxExpression *leftExpr, CxxExpression *rightExpr) { return 0; }
-CxxExpression *make_index_cast_expression(CxxExpression *aCast, CxxExpression *anExpr) { return 0; }
-CxxParameter *make_initialized_parameter(CxxParameter *aParameter, CxxExpression *anExpr) { return 0; }
-CxxInitializerClauses *make_initializer_clauses(CxxInitializerClauses *aList, CxxInitializerClause *anElement) { return 0; }
-CxxInitializerClause *make_initializer_expression_clause(CxxExpression *anExpr) { return 0; }
-CxxInitializerClause *make_initializer_list_clause(CxxInitializerClauses *aList) { return 0; }
-CxxSimpleTypeParameter *make_init_simple_type_parameter(CxxSimpleTypeParameter *templateParameters, CxxExpression *anExpr) { return 0; }
-CxxTemplatedTypeParameter *make_init_templated_parameter(CxxTemplatedTypeParameter *typeParameter, CxxName *aName) { return 0; }
-CxxDeclSpecifierId *make_inline_as_friend() { return 0; }
-CxxDeclSpecifierId *make_inline_if_short() { return 0; }
-CxxDeclSpecifierId *make_inline_in_implementation() { return 0; }
-CxxDeclSpecifierId *make_inline_in_interface() { return 0; }
-CxxFileId *make_input_file(CxxFileId *fileId) { return 0; }
-CxxExpression *make_integer_literal_expression(CxxIntegerLiteral *aLiteral) { return 0; }
-CxxStatement *make_label_statement(CxxToken *aLabel, CxxStatement *aStmt) { return 0; }
-CxxExpression *make_less_equal_expression(CxxExpression *leftExpr, CxxExpression *rightExpr) { return 0; }
-CxxExpression *make_less_than_expression(CxxExpression *leftExpr, CxxExpression *rightExpr) { return 0; }
-CxxLine *make_line() { return 0; }
-CxxDeclaration *make_lined_declaration(CxxDeclaration *aDeclaration, CxxLine *aLine) { return 0; }
-CxxStatement *make_lined_statement(CxxStatement *aStatement, CxxLine *aLine) { return 0; }
-CxxToken *make_lined_token(CxxToken *aToken, CxxLine *aLine) { return 0; }
-CxxName *make_linkage_specifier(CxxStrings *aString, CxxDeclaration *aDeclaration) { return 0; }
-CxxExpression *make_logical_and_expression(CxxExpression *leftExpr, CxxExpression *rightExpr) { return 0; }
-CxxExpression *make_logical_or_expression(CxxExpression *leftExpr, CxxExpression *rightExpr) { return 0; }
-CxxMemInitializer *make_mem_initializer(CxxName *aName, CxxExpression *anExpr) { return 0; }
-CxxMemInitializers *make_mem_initializers(CxxMemInitializers *aList, CxxMemInitializer *anElement) { return 0; }
-CxxMemberDeclarations *make_member_declarations(CxxMemberDeclarations *aList, CxxDeclaration *aDeclaration) { return 0; }
-CxxExpression *make_meta_assignment_expression(CxxExpression *leftExpr, CxxToken *assOp, CxxToken *rightExpr) { return 0; }
-CxxBaseSpecifier *make_meta_base_specifier(CxxBaseSpecifier *baseSpecifier) { return 0; }
-CxxMetaType *make_meta_built_in_type(CxxBuiltInId *aName) { return 0; }
-CxxStatement *make_meta_break_statement() { return 0; }
-CxxStatement *make_meta_case_statement(CxxExpression *anExpr, CxxToken *someTokens) { return 0; }
-CxxMetaClass *make_meta_class(CxxName *metaClass, CxxBaseSpecifiers *baseSpecifiers, CxxToken *classBody) { return 0; }
-CxxStatement *make_meta_continue_statement() { return 0; }
-CxxDeclaration *make_meta_declaration_declaration(CxxDeclaration *metaDeclaration) { return 0; }
-CxxStatement *make_meta_default_statement(CxxToken *someTokens) { return 0; }
-CxxStatement *make_meta_do_while_statement(CxxLine *aLine, CxxToken *bodyTokens, CxxToken *testTokens) { return 0; }
-CxxStatement *make_meta_expression_statement(CxxName *aName, CxxToken *bodyTokens) { return 0; }
-CxxStatement *make_meta_for_statement(CxxLine *aLine, CxxExpression *initTokens, CxxToken *testTokens,
- CxxToken *stepTokens, CxxToken *bodyTokens) { return 0; }
-CxxExpression *make_meta_function(CxxExpression *anExpr, CxxTokens *aList, CxxToken *aBody) { return 0; }
-CxxStatement *make_meta_if_statement(CxxLine *aLine, CxxExpression *testTokens, CxxToken *trueTokens, CxxToken *falseTokens) { return 0; }
-CxxDeclaration *make_linkage_specification(CxxName *aName) { return 0; }
-//CxxMetaInitializers *make_meta_initializers(CxxMetaInitializers *aList, CxxToken *anElement) { return 0; }
-CxxMetaParameter *make_meta_parameter(CxxMetaType *metaType, CxxIsTree isTree, CxxName *aName, CxxToken *anInit) { return 0; }
-CxxMetaParameters *make_meta_parameters(CxxMetaParameters *aList, CxxMetaParameter *anElement) { return 0; }
-CxxStatement *make_meta_return_statement(CxxExpression *anExpr) { return 0; }
-CxxStatement *make_meta_statement(CxxStatement *aStatement) { return 0; }
-CxxDeclaration *make_meta_statement_declaration(CxxStatement *metaStatement) { return 0; }
-CxxStatement *make_meta_statement_statement(CxxStatement *metaStatement) { return 0; }
-CxxStatement *make_meta_switch_statement(CxxLine *aLine, CxxExpression *testTokens, CxxToken *bodyTokens) { return 0; }
-CxxMetaType *make_meta_type(CxxName *aName) { return 0; }
-CxxName *make_meta_type_id(CxxMetaType *metaType) { return 0; }
-CxxStatement *make_meta_while_statement(CxxLine *aLine, CxxToken *testTokens, CxxToken *bodyTokens) { return 0; }
-CxxExpression *make_minus_expression(CxxExpression *anExpr) { return 0; }
-CxxExpression *make_modulus_expression(CxxExpression *leftExpr, CxxExpression *rightExpr) { return 0; }
-CxxExpression *make_multiply_expression(CxxExpression *leftExpr, CxxDeclarator *aDeclarator, CxxExpression *rightExpr) { return 0; }
-CxxName *make_name(CxxName *aName) { return 0; }
-CxxName *make_name_expression(CxxName *aName) { return 0; }
-CxxDeclaration *make_namespace_alias_definition(CxxName *aName, CxxName *forId) { return 0; }
-CxxDeclaration *make_namespace_declaration(CxxName *aName) { return 0; }
-CxxName *make_namespace_definition(CxxName *aName, CxxDeclarations *aDeclaration) { return 0; }
-CxxDeclarator *make_nested_declarator(CxxName *aName, CxxDeclarator *aDeclarator) { return 0; }
-CxxName *make_nested_id(CxxName *nestingId, CxxName *nestedId) { return 0; }
-CxxName *make_nested_scope(CxxName *nestingId) { return 0; }
-CxxExpression *make_new_expression(CxxParameters *aPlace, CxxParameters *aType, CxxExpression *anInit) { return 0; }
-CxxExpression *make_new_type_id_expression(CxxParameters *aPlace, CxxExpression *aType, CxxExpression *anInit) { return 0; }
-CxxDeclSpecifierId *make_not_const() { return 0; }
-CxxExpression *make_not_equal_expression(CxxExpression *leftExpr, CxxExpression *rightExpr) { return 0; }
-CxxExpression *make_not_expression(CxxExpression *anExpr) { return 0; }
-CxxDeclSpecifierId *make_not_inline() { return 0; }
-CxxDeclSpecifierId *make_not_static() { return 0; }
-CxxDeclSpecifierId *make_not_virtual() { return 0; }
-CxxBaseSpecifier *make_not_virtual_base_specifier(CxxBaseSpecifier *baseSpecifier) { return 0; }
-CxxDeclSpecifierId *make_not_volatile() { return 0; }
-CxxExpression *make_number_literal_expression(CxxExpression *anExpr) { return 0; }
-CxxExpression *make_object_scope_expression(CxxExpression *anExpr, CxxDeclaration *functionDeclarations) { return 0; }
-CxxName *make_operator_add_id() { return 0; }
-CxxName *make_operator_arrow_id() { return 0; }
-CxxName *make_operator_arrow_star_id() { return 0; }
-CxxName *make_operator_ass_add_id() { return 0; }
-CxxName *make_operator_ass_bit_and_id() { return 0; }
-CxxName *make_operator_ass_bit_or_id() { return 0; }
-CxxName *make_operator_ass_div_id() { return 0; }
-CxxName *make_operator_ass_id() { return 0; }
-CxxName *make_operator_ass_mod_id() { return 0; }
-CxxName *make_operator_ass_mul_id() { return 0; }
-CxxName *make_operator_ass_shl_id() { return 0; }
-CxxName *make_operator_ass_shr_id() { return 0; }
-CxxName *make_operator_ass_sub_id() { return 0; }
-CxxName *make_operator_ass_xor_id() { return 0; }
-CxxName *make_operator_bit_and_id() { return 0; }
-CxxName *make_operator_bit_not_id() { return 0; }
-CxxName *make_operator_bit_or_id() { return 0; }
-CxxName *make_operator_call_id() { return 0; }
-CxxName *make_operator_comma_id() { return 0; }
-CxxName *make_operator_dec_id() { return 0; }
-CxxName *make_operator_delete_id() { return 0; }
-CxxName *make_operator_div_id() { return 0; }
-CxxName *make_operator_eq_id() { return 0; }
-CxxName *make_operator_function_id(CxxName *operatorId) { return 0; }
-CxxName *make_operator_ge_id() { return 0; }
-CxxName *make_operator_gt_id() { return 0; }
-CxxName *make_operator_inc_id() { return 0; }
-CxxName *make_operator_index_id() { return 0; }
-CxxName *make_operator_le_id() { return 0; }
-CxxName *make_operator_log_and_id() { return 0; }
-CxxName *make_operator_log_not_id() { return 0; }
-CxxName *make_operator_log_or_id() { return 0; }
-CxxName *make_operator_lt_id() { return 0; }
-CxxName *make_operator_mod_id() { return 0; }
-CxxName *make_operator_mul_id() { return 0; }
-CxxName *make_operator_ne_id() { return 0; }
-CxxName *make_operator_new_id() { return 0; }
-CxxName *make_operator_shl_id() { return 0; }
-CxxName *make_operator_shr_id() { return 0; }
-CxxName *make_operator_sub_id() { return 0; }
-CxxName *make_operator_xor_id() { return 0; }
-CxxParameters *make_parameters(CxxParameters *aList, CxxParameter *anElement) { return 0; }
-CxxParenthesised *make_parenthesised(CxxParameters *aList, CxxCvQualifiers *cvQualifiers, CxxExceptionSpecification *exceptionSpecification) { return 0; }
-CxxExpression *make_plus_expression(CxxExpression *anExpr) { return 0; }
-CxxPointerDeclarator *make_pointer_declarator() { return 0; }
-CxxExpression *make_pointer_expression(CxxDeclarator *aDeclarator, CxxExpression *anExpr) { return 0; }
-CxxExpression *make_post_decrement_expression(CxxExpression *anExpr) { return 0; }
-CxxExpression *make_post_increment_expression(CxxExpression *anExpr) { return 0; }
-CxxExpression *make_pre_decrement_expression(CxxExpression *anExpr) { return 0; }
-CxxExpression *make_pre_increment_expression(CxxExpression *anExpr) { return 0; }
-CxxName *make_pseudo_destructor_id(CxxBuiltInId *aScope, CxxBuiltInId *aName) { return 0; }
-CxxDeclSpecifierId *make_pure_virtual() { return 0; }
-CxxDeclarator *make_reference_declarator() { return 0; }
-CxxExpression *make_reinterpret_cast_expression(CxxExpression *aType, CxxExpression *anExpr) { return 0; }
-CxxStatement *make_return_statement(CxxExpression *anExpr) { return 0; }
-CxxName *make_scoped_id(CxxName *globalId, CxxName *nestedId) { return 0; }
-CxxExpression *make_scoped_pointer_expression(CxxExpression *aScope, CxxDeclarator *aDeclarator, CxxExpression *anExpr) { return 0; }
-CxxSegment *make_segment(CxxSegment *aSegment) { return 0; }
-CxxFunctionBody *make_segment_function_block(CxxFunctionBody *functionBody, CxxSegment *aSegment) { return 0; }
-CxxDeclSpecifierId *make_set_template_decl_specifier(CxxDeclSpecifierId *aName) { return 0; }
-CxxDeclaration *make_set_template_declaration(CxxDeclaration *aDeclaration) { return 0; }
-CxxExpression *make_set_template_expression(CxxExpression *anExpr) { return 0; }
-CxxName *make_set_template_id(CxxName *aName) { return 0; }
-CxxName *make_set_template_name(CxxName *aName) { return 0; }
-CxxName *make_set_template_scope(CxxName *aName) { return 0; }
-CxxExpression *make_shift_left_expression(CxxExpression *leftExpr, CxxExpression *rightExpr) { return 0; }
-CxxExpression *make_shift_right_expression(CxxExpression *leftExpr, CxxExpression *rightExpr) { return 0; }
-CxxDeclaration *make_simple_declaration(CxxExpression *anExpr) { return 0; }
-CxxExpression *make_sizeof_expression(CxxExpression *anExpr) { return 0; }
-CxxStatements *make_statements(CxxStatements *, CxxStatement *aStmt) { return 0; }
-CxxExpression *make_static_cast_expression(CxxExpression *aType, CxxExpression *anExpr) { return 0; }
-CxxExpression *make_string_literal_expression(CxxStrings *aString) { return 0; }
-CxxStrings *make_strings(CxxStringLiteral *anElement, CxxStrings *aList) { return 0; }
-CxxExpression *make_subtract_expression(CxxExpression *leftExpr, CxxExpression *rightExpr) { return 0; }
-CxxStatement *make_switch_statement(CxxCondition *testExpr, CxxStatement *aStmt) { return 0; }
-CxxExpression *make_syntax_macro_definition(CxxMetaType *metaType, CxxIsTree isTree, CxxName *aName, CxxSyntaxMacroParameters *aList, CxxToken *aBody) { return 0; }
-CxxSyntaxMacroParameter *make_syntax_macro_parameter(CxxToken *metaType, CxxIsTree isTree, CxxName *aName) { return 0; }
-CxxSyntaxMacroParameters *make_syntax_macro_parameters(CxxSyntaxMacroParameters *aList, CxxSyntaxMacroParameter *anElement) { return 0; }
-CxxTemplateArgument *make_template_argument(CxxParameter *aParameter) { return 0; }
-CxxTemplateArguments *make_template_arguments(CxxTemplateArguments *aList, CxxTemplateArgument *anElement) { return 0; }
-CxxDeclaration *make_template_declaration(CxxTemplateParameters *aList, CxxDeclaration *aDeclaration) { return 0; }
-CxxName *make_template_name(CxxName *aName, CxxTemplateArguments *templateArguments) { return 0; }
-CxxTemplateParameter *make_templated_template_parameter(CxxTemplateParameter *typeParameter, CxxName *aName) { return 0; }
-CxxTemplateParameter *make_template_parameter(CxxParameter *aParameter) { return 0; }
-CxxTemplateParameters *make_template_parameters(CxxTemplateParameters *aList, CxxTemplateParameter *anElement) { return 0; }
-CxxTemplatedTypeParameter *make_templated_type_parameter(CxxTemplateParameters *templateParameters, CxxName *aName) { return 0; }
-CxxExpression *make_this_expression() { return 0; }
-CxxExpression *make_throw_expression(CxxExpression *anExpr) { return 0; }
-CxxExpression *make_tokens_expression(CxxTokens *someTokens) { return 0; }
-CxxToken *make_tree_argument(CxxToken *aToken) { return 0; }
-CxxTokens *make_tree_arguments(CxxTokens *aList, CxxToken *anElement) { return 0; }
-CxxTreeExpression *make_tree_array_expression(CxxTreeExpression *anExpr, CxxExpression *indexExpr) { return 0; }
-CxxTreeExpression *make_tree_arrow_expression(CxxTreeExpression *anExpr, CxxName *aName) { return 0; }
-CxxTreeExpression *make_tree_call_expression(CxxTreeExpression *anExpr, CxxTokens *aList) { return 0; }
-CxxTreeExpression *make_tree_dot_expression(CxxTreeExpression *anExpr, CxxName *aName) { return 0; }
-CxxTreeExpression *make_tree_expression(CxxName *aName) { return 0; }
-CxxName *make_tree_id(CxxName *aName) { return 0; }
-CxxTreeExpression *make_tree_pointer_expression(CxxTreeExpression *anExpr) { return 0; }
-CxxExpression *make_true_expression() { return 0; }
-CxxFunctionBody *make_try_block(CxxStatement *aStatement, CxxHandlers *exceptionHandlers) { return 0; }
-CxxStatement *make_try_block_statement(CxxFunctionBody *tryBlock) { return 0; }
-CxxFunctionBody *make_try_function_block(CxxFunctionBody *functionBody, CxxHandlers *exceptionHandlers) { return 0; }
-CxxExpression *make_type1_expression(CxxExpression *functionName, CxxParenthesised *aParenthesis, CxxType1Parameters *type1Parameters) { return 0; }
-CxxTemplateParameter *make_type_template_parameter(CxxSimpleTypeParameter *typeParameter, CxxExpression *typeId) { return 0; }
-CxxExpression *make_typed_expression(CxxName *frontName, CxxExpression *backName) { return 0; }
-CxxName *make_typed_name(CxxName *frontName, CxxName *backName) { return 0; }
-CxxExpression *make_typeid_expression(CxxExpression *aList) { return 0; }
-CxxSimpleTypeParameter *make_typename_template_parameter(CxxName *aName) { return 0; }
-CxxSimpleTypeParameter *make_typename_type_parameter(CxxName *aName) { return 0; }
-CxxType1Parameters *make_type1_parameters(CxxType1Parameters *aList, CxxParameters *someParameters) { return 0; }
-CxxDeclaration *make_using_declaration(bool isTypename, CxxName *aName) { return 0; }
-CxxDeclaration *make_using_directive(CxxName *aName) { return 0; }
-CxxFunctionBody *make_using_function_block(CxxFunctionBody *functionBody, CxxFileIds *fileIds) { return 0; }
-CxxDeclaration *make_using_implementation_declaration(CxxFileId *fileId) { return 0; }
-CxxDeclaration *make_using_interface_declaration(CxxFileId *fileId) { return 0; }
-CxxUtility *make_utility(CxxUtility *aUtility) { return 0; }
-CxxUtility *make_utility_mode() { return 0; }
-CxxBaseSpecifier *make_virtual_base_specifier(CxxBaseSpecifier *baseSpecifier) { return 0; }
-CxxStatement *make_while_statement(CxxCondition *testExpr, CxxStatement *aStmt) { return 0; }
-
+++ /dev/null
-//
-// Title: C++ Grammar Token support compilation unit.
-//
-// File Name: CxxToken.cpp
-//
-// Author: E.D.Willink
-//END
-//
-#include <CxxToken.cxx>
+++ /dev/null
-#include <CxxToken.hxx>
-#include <memory.h>
-
-//CxxToken::CxxToken()
-//:
-// _value(0)
-//{}
-
-CxxNaffToken::CxxNaffToken(int tokenValue, const char *yyText, int yyLeng)
-:
- Super(tokenValue), _text(new char[yyLeng+1]), _leng(yyLeng)
-{
- memcpy(_text, yyText, yyLeng);
- _text[_leng] = 0;
-}
-
-CxxNaffToken::~CxxNaffToken() { delete[] _text; }
+++ /dev/null
-#ifndef CXXTOKEN_HXX
-#define CXXTOKEN_HXX
-
-#include <iostream.h>
-#include <stdlib.h>
-
-#define YYSTYPE CxxTokenType
-#define YY_parse_STYPE CxxTokenType
-#define YACC_BANG_TYPE size_t
-#define YACC_MARK_TYPE size_t
-
-#define YACC_BANG() push_bang()
-#define YACC_UNBANG(bangValue, msg) pop_bang(bangValue); yyerrok; yyclearin; yyerror(msg);
-
-#define ERRMSG(a) do { cout << "ERROR -- " << a << endl; increment_error_count(); } while (0)
-
-#ifdef NEEDS_BOOL
-enum bool { false, true };
-#endif
-
-#ifdef BISON_PP_CLASS
-#define PARSE_TOKEN(a) BISON_PP_CLASS::a
-#else
-#define PARSE_TOKEN(a) a
-#endif
-
-extern size_t line_number;
-extern bool c_keywords;
-extern bool echo_line_numbers;
-extern bool echo_line_text;
-extern void increment_error_count();
-extern int tokenMarkDepth;
-
-class CxxToken
-{
- int _value;
-private:
- CxxToken(const CxxToken&);
- CxxToken& operator=(const CxxToken&);
-public:
- CxxToken(int tokenValue = 0) : _value(tokenValue) {}
- virtual ~CxxToken() {}
- int value() const { return _value; }
-};
-
-enum CxxIsTemplate { IS_DEFAULT, IS_TEMPLATE };
-enum CxxIsTree { IS_SCALAR, IS_TREE };
-typedef CxxToken CxxTreeArgument;
-
-class CxxStatement : public CxxToken {};
-typedef CxxStatement CxxDeclaration;
-class CxxExpression : public CxxStatement {};
-class CxxName : public CxxExpression {};
-class CxxTokens : public CxxToken {};
-class CxxMetaObject : public CxxExpression {};
-class CxxMetaStatement : public CxxStatement {};
-
-class CxxStatements : public CxxStatement {};
-typedef CxxStatements CxxDeclarations;
-typedef CxxDeclarations CxxMemberDeclarations;
-typedef CxxExpression CxxTreeExpression;
-
-class CxxKeyword : public CxxName {};
-class CxxDeclSpecifierId : public CxxKeyword {};
-
-class CxxAccessSpecifier : public CxxKeyword {};
-class CxxBaseSpecifier : public CxxToken {};
-class CxxBaseSpecifiers : public CxxTokens {};
-class CxxBrace : public CxxToken {};
-class CxxBuiltInId : public CxxName {};
-class CxxCharacterLiteral : public CxxToken {};
-class CxxClass : public CxxToken {};
-class CxxClassKey : public CxxKeyword {};
-class CxxCondition : public CxxExpression {};
-class CxxCvQualifiers : public CxxDeclSpecifierId {};
-class CxxDeclarator : public CxxToken {};
-typedef CxxExpression CxxDeleteExpression;
-//class CxxDerived : public CxxToken {};
-//class CxxEnum : public CxxToken {};
-class CxxEnumerator : public CxxToken {};
-class CxxEnumerators : public CxxTokens {};
-class CxxExceptionDeclaration : public CxxToken {};
-class CxxExceptionSpecification : public CxxToken {};
-class CxxExpressions : public CxxExpression {};
-class CxxFileId : public CxxToken {};
-class CxxFileIds : public CxxTokens {};
-class CxxFileName : public CxxToken {};
-class CxxFloatingLiteral : public CxxToken {};
-class CxxFunctionBody : public CxxStatement {};
-class CxxFunctionDeclarations : public CxxDeclarations {};
-class CxxHandler : public CxxToken {};
-class CxxHandlers : public CxxTokens {};
-class CxxIdentifier : public CxxName {};
-//class CxxIds : public CxxTokens {};
-class CxxInitializerClause : public CxxExpression {};
-class CxxInitializerClauses : public CxxInitializerClause {};
-class CxxIntegerLiteral : public CxxToken {};
-class CxxLine : public CxxToken {};
-//class CxxList : public CxxTokens {};
-class CxxMemInitializer : public CxxToken {};
-class CxxMemInitializers : public CxxTokens {};
-class CxxMetaClass : public CxxStatement {};
-class CxxMetaFunction : public CxxMetaObject {};
-class CxxMetaInitializer : public CxxToken {};
-class CxxMetaInitializers : public CxxTokens {};
-class CxxMetaParameter : public CxxToken {};
-class CxxMetaParameters : public CxxTokens {};
-//class CxxMetaPrototype : public CxxToken {};
-//class CxxMetaPrototypes : public CxxTokens {};
-class CxxMetaType : public CxxName {};
-class CxxMetaVariable : public CxxMetaObject {};
-class CxxNamespace : public CxxToken {};
-typedef CxxExpression CxxNewExpression;
-class CxxNumberLiteral : public CxxExpression {};
-class CxxParameter : public CxxExpression {};
-class CxxParameters : public CxxExpression {};
-class CxxParenthesised : public CxxToken {};
-class CxxPointerDeclarator : public CxxDeclarator {};
-class CxxPosition : public CxxName {};
-class CxxSegment : public CxxName {};
-class CxxSpacing : public CxxToken {};
-class CxxStrings : public CxxToken {};
-typedef CxxStrings CxxStringLiteral;
-class CxxSubspace : public CxxToken {};
-class CxxSyntaxMacroParameter : public CxxToken {};
-class CxxSyntaxMacroParameters : public CxxTokens {};
-class CxxTemplateArgument : public CxxToken {};
-class CxxTemplateArguments : public CxxTokens {};
-class CxxTemplateParameter : public CxxToken {};
-class CxxTemplateParameters : public CxxTokens {};
-class CxxSimpleTypeParameter : public CxxTemplateParameter {};
-class CxxTemplatedTypeParameter : public CxxTemplateParameter {};
-class CxxTokenStatements : public CxxTokens {};
-class CxxTreeArguments : public CxxTokens {};
-class CxxType1Parameters : public CxxTokens {};
-class CxxTypeId : public CxxToken {};
-class CxxTypeIds : public CxxTokens {};
-class CxxUtility : public CxxToken {};
-
-#define FOGPARSERVALUE_ENUM(T,N) \
- const T *name2(u_,N); \
- const T& N() const { return *name2(u_,N); } \
- const T* & N() { return name2(u_,N); }
-#define FOGPARSERVALUE_POINTER(T,N) T *N;
-#define FOGPARSERVALUE_VALUE(T,N) T N;
-
-union CxxTokenType
-{
- CxxToken *_token;
-
- FOGPARSERVALUE_VALUE(bool, _bool)
- FOGPARSERVALUE_VALUE(long, _long)
- FOGPARSERVALUE_POINTER(CxxBrace, brace)
- FOGPARSERVALUE_POINTER(CxxSpacing, spacing)
-
- FOGPARSERVALUE_POINTER(CxxAccessSpecifier, access_specifier)
- FOGPARSERVALUE_POINTER(CxxBaseSpecifier, base_specifier)
- FOGPARSERVALUE_POINTER(CxxBaseSpecifiers, base_specifiers)
- FOGPARSERVALUE_POINTER(CxxBuiltInId, built_in_id)
- FOGPARSERVALUE_POINTER(CxxCharacterLiteral, character_literal)
- FOGPARSERVALUE_POINTER(CxxClass, _class)
- FOGPARSERVALUE_POINTER(CxxClassKey, class_key)
- FOGPARSERVALUE_POINTER(CxxCondition, condition)
- FOGPARSERVALUE_POINTER(CxxCvQualifiers, cv_qualifiers)
- FOGPARSERVALUE_POINTER(CxxDeclSpecifierId, decl_specifier_id)
- FOGPARSERVALUE_POINTER(CxxDeclaration, declaration)
- FOGPARSERVALUE_POINTER(CxxDeclarations, declarations)
- FOGPARSERVALUE_POINTER(CxxDeclarator, declarator)
- FOGPARSERVALUE_POINTER(CxxDeleteExpression, delete_expression)
- FOGPARSERVALUE_POINTER(CxxEnumerator, enumerator)
- FOGPARSERVALUE_POINTER(CxxEnumerators, enumerators)
- FOGPARSERVALUE_POINTER(CxxExceptionDeclaration, exception_declaration)
- FOGPARSERVALUE_POINTER(CxxExceptionSpecification, exception_specification)
- FOGPARSERVALUE_POINTER(CxxExpression, expression)
- FOGPARSERVALUE_POINTER(CxxExpressions, expressions)
- FOGPARSERVALUE_POINTER(CxxFileId, file_id)
- FOGPARSERVALUE_POINTER(CxxFileIds, file_ids)
- FOGPARSERVALUE_POINTER(CxxFileName, file_name)
- FOGPARSERVALUE_POINTER(CxxFloatingLiteral, floating_literal)
- FOGPARSERVALUE_POINTER(CxxFunctionBody, function_body)
- FOGPARSERVALUE_POINTER(CxxHandler, handler)
- FOGPARSERVALUE_POINTER(CxxHandlers, handlers)
- FOGPARSERVALUE_POINTER(CxxIdentifier, identifier)
- FOGPARSERVALUE_POINTER(CxxInitializerClause, initializer_clause)
- FOGPARSERVALUE_POINTER(CxxInitializerClauses, initializer_clauses)
- FOGPARSERVALUE_POINTER(CxxIntegerLiteral, integer_literal)
- FOGPARSERVALUE_POINTER(CxxKeyword, keyword)
- FOGPARSERVALUE_POINTER(CxxLine, line)
- FOGPARSERVALUE_POINTER(CxxMemInitializer, mem_initializer)
- FOGPARSERVALUE_POINTER(CxxMemInitializers, mem_initializers)
- FOGPARSERVALUE_POINTER(CxxMemberDeclarations, member_declarations)
- FOGPARSERVALUE_POINTER(CxxMetaClass, meta_class)
- FOGPARSERVALUE_POINTER(CxxMetaFunction, meta_function)
- FOGPARSERVALUE_POINTER(CxxMetaInitializer, meta_initializer)
- FOGPARSERVALUE_POINTER(CxxMetaInitializers, meta_initializers)
- FOGPARSERVALUE_POINTER(CxxMetaObject, meta_object)
- FOGPARSERVALUE_POINTER(CxxMetaStatement, meta_statement)
- FOGPARSERVALUE_POINTER(CxxMetaType, meta_type)
- FOGPARSERVALUE_POINTER(CxxMetaVariable, meta_variable)
- FOGPARSERVALUE_POINTER(CxxName, name)
- FOGPARSERVALUE_POINTER(CxxNewExpression, new_expression)
- FOGPARSERVALUE_POINTER(CxxNumberLiteral, number_literal)
- FOGPARSERVALUE_POINTER(CxxParameter, parameter)
- FOGPARSERVALUE_POINTER(CxxParameters, parameters)
- FOGPARSERVALUE_POINTER(CxxParenthesised, parenthesised)
- FOGPARSERVALUE_POINTER(CxxPointerDeclarator, pointer_declarator)
- FOGPARSERVALUE_POINTER(CxxPosition, position)
- FOGPARSERVALUE_POINTER(CxxSegment, segment)
- FOGPARSERVALUE_POINTER(CxxSimpleTypeParameter, simple_type_parameter)
- FOGPARSERVALUE_POINTER(CxxStatement, statement)
- FOGPARSERVALUE_POINTER(CxxStatements, statements)
- FOGPARSERVALUE_POINTER(CxxStringLiteral, string_literal)
- FOGPARSERVALUE_POINTER(CxxStrings, strings)
- FOGPARSERVALUE_POINTER(CxxSubspace, subspace)
- FOGPARSERVALUE_POINTER(CxxSyntaxMacroParameter, syntax_macro_parameter)
- FOGPARSERVALUE_POINTER(CxxSyntaxMacroParameters, syntax_macro_parameters)
- FOGPARSERVALUE_POINTER(CxxTemplateArgument, template_argument)
- FOGPARSERVALUE_POINTER(CxxTemplateArguments, template_arguments)
- FOGPARSERVALUE_POINTER(CxxTemplateParameter, template_parameter)
- FOGPARSERVALUE_POINTER(CxxTemplateParameters, template_parameters)
- FOGPARSERVALUE_POINTER(CxxTemplatedTypeParameter, templated_type_parameter)
- FOGPARSERVALUE_POINTER(CxxToken, token)
- FOGPARSERVALUE_POINTER(CxxTokenStatements, token_statements)
- FOGPARSERVALUE_POINTER(CxxTokens, tokens)
- FOGPARSERVALUE_POINTER(CxxTreeArgument, tree_argument)
- FOGPARSERVALUE_POINTER(CxxTreeArguments, tree_arguments)
- FOGPARSERVALUE_POINTER(CxxTreeExpression, tree_expression)
- FOGPARSERVALUE_POINTER(CxxType1Parameters, type1_parameters)
- FOGPARSERVALUE_POINTER(CxxUtility, utility)
-
- FOGPARSERVALUE_VALUE(int, bang)
- FOGPARSERVALUE_VALUE(CxxIsTemplate, is_template)
- FOGPARSERVALUE_VALUE(YACC_MARK_TYPE, mark)
- FOGPARSERVALUE_VALUE(size_t, nest)
-#if 0
- CxxAccessSpecifier *access_specifier;
- CxxBaseSpecifier *base_specifier;
- CxxBaseSpecifiers *base_specifiers;
- CxxBuiltInId *built_in_id;
- CxxCharacterLiteral *character_literal;
- CxxClass *_class;
- CxxClassKey *class_key;
- CxxCondition *condition;
- CxxCvQualifiers *cv_qualifiers;
- CxxDeclaration *declaration;
- CxxDeclarations *declarations;
- CxxDeclarator *declarator;
- CxxDeclSpecifierId *decl_specifier_id;
-// CxxDerived *derived;
-// CxxEnum *_enum;
- CxxEnumerator *enumerator;
- CxxEnumerators *enumerators;
- CxxExceptionDeclaration *exception_declaration;
- CxxExceptionSpecification *exception_specification;
- CxxExpression *expression;
- CxxExpressions *expressions;
- CxxFileId *file_id;
- CxxFileIds *file_ids;
- CxxFileName *file_name;
- CxxFloatingLiteral *floating_literal;
- CxxFunctionBody *function_body;
- CxxFunctionDeclarations *function_declarations;
- CxxHandler *handler;
- CxxHandlers *handlers;
- CxxIdentifier *identifier;
-// CxxIds *ids;
- CxxInitializerClause *initializer_clause;
- CxxInitializerClauses *initializer_clauses;
- CxxIntegerLiteral *integer_literal;
- CxxKeyword *keyword;
- CxxLine *line;
-// CxxList *list;
- CxxMemInitializer *mem_initializer;
- CxxMemInitializers *mem_initializers;
- CxxMemberDeclarations *member_declarations;
- CxxMetaClass *meta_class;
-// CxxMetaFunction *meta_function;
-// CxxMetaInitializer *meta_initializer;
-// CxxMetaInitializers *meta_initializers;
-// CxxMetaObject *meta_object;
- CxxMetaParameter *meta_parameter;
- CxxMetaParameters *meta_parameters;
-// CxxMetaPrototype *meta_prototype;
-// CxxMetaPrototypes *meta_prototypes;
-// CxxMetaStatement *meta_statement;
- CxxMetaType *meta_type;
-// CxxMetaVariable *meta_variable;
- CxxName *name;
-// CxxNamespace *_namespace;
- CxxNumberLiteral *number_literal;
- CxxParameter *parameter;
- CxxParameters *parameters;
- CxxParenthesised *parenthesised;
- CxxPointerDeclarator *pointer_declarator;
- CxxSegment *segment;
- CxxSimpleTypeParameter *simple_type_parameter;
- CxxStatement *statement;
- CxxStatements *statements;
- CxxStringLiteral *string_literal;
- CxxStrings *strings;
- CxxSyntaxMacroParameter *syntax_macro_parameter;
- CxxSyntaxMacroParameters *syntax_macro_parameters;
- CxxTemplateArgument *template_argument;
- CxxTemplateArguments *template_arguments;
- CxxTemplateParameter *template_parameter;
- CxxTemplateParameters *template_parameters;
- CxxTemplatedTypeParameter *templated_type_parameter;
- CxxToken *token;
- CxxTokens *tokens;
-// CxxTreeArgument *tree_argument;
-// CxxTreeArguments *tree_arguments;
-// CxxTreeExpression *tree_expression;
- CxxType1Parameters *type1_parameters;
-// CxxTypeId *type_id;
-// CxxTypeIds *type_ids;
- CxxUtility *utility;
- YACC_BANG_TYPE bang;
- YACC_MARK_TYPE mark;
- size_t nest;
-#endif
-};
-
-class CxxNaffToken : public CxxToken
-{
- typedef CxxToken Super;
- char *_text;
- int _leng;
-private:
- CxxNaffToken(const CxxNaffToken&);
- CxxNaffToken& operator=(const CxxNaffToken&);
-public:
- CxxNaffToken(int tokenValue, const char *yyText, int yyLeng);
- virtual ~CxxNaffToken();
-};
-
-#endif
+++ /dev/null
-This directory tree comprises a pre-built demonstration of the superset C++ grammar
-from FOG..
-
-Contents
---------
-
- Release/grammar.exe -- the statically bound executable (on NT)
- sun4o/grammar -- the statically bound executable (on Unix)
-
-It is a command line based utility. See index.html for details.
-
-Bug reporting
--------------
-
-Please report any bugs to Ed.Willink@rrl.co.uk. I will endeavour to fix them,
-but since this code is a one man effort and my time is primarily devoted to
-my other activities for Thales Research, only simple and easy fixes are likely.
-I am more likely to be able to fix the problem if you can trim your problem to
-just a few lines.
-
+++ /dev/null
-<html>
-
-<head>
-<meta http-equiv="Content-Type"
-content="text/html; charset=iso-8859-1">
-<meta name="GENERATOR" content="Microsoft FrontPage Express 2.0">
-<title>Ed's Toolkit</title>
-</head>
-
-<body bgcolor="#FFFFFF">
-
-<h1 align="center">Superset C++ Grammar</h1>
-
-<hr>
-
-<p>This work area supports a demonstration of the superset C++
-grammar described in Chapter 5 of <a
-href="mailto:Ed.Willink@rrl.co.uk">Ed Willink</a>'s thesis on <a
-href="http://www.computing.surrey.ac.uk/research/dsrg/fog/FogThesis.html">Meta-Compilation
-for C++</a>. It contains working lex and yacc grammars that
-enable C++ source to be lexically analysed, then syntactically
-analysed without semantic knowlege. The lex and yacc grammar have
-their action routines defined by macros in the hope that
-reconfiguration may be possible without editing the grammars
-directly. The dummy implementations of the yacc macros do nothing
-other than count statements and diagnose the back-tracking
-behaviour. Users may add their own syntactic level code. A proper
-C++ parser needs semantic analysis as well, including correction
-of minor misprses at the syntactic level. Semantic interpretaion
-is provided by <a
-href="http://www.computing.surrey.ac.uk/research/dsrg/fog/">FOG</a>
-from which this demonstration is split off.</p>
-
-<p>The work area is self-sufficient, requiring only <em>lex</em>
-and <em>yacc</em>, or <em>flex</em> and <em>bison</em>.</p>
-
-<hr>
-
-<h2>Command Line</h2>
-
-<p>The test grammar is a simple command line utility, for
-analysing a single <strong>pre-processed</strong> source file
-(use CC -E to run just the preprocessor on your source files)..</p>
-
-<pre> grammar [options] < source-file</pre>
-
-<p>The full set of command line options is:</p>
-
-<pre> -c Recognise only C keywords - approximates C rather than C++ parsing
- -m Display mark activity.
- -n Echo line numbers.
- -t Echo source line text.
- -y Display yacc diagnostics.</pre>
-
-<p>On completion a three line diagnostic summarises the search
-activity. </p>
-
-<hr>
-
-<h2>Files</h2>
-
-<p><a href="CxxSrc.tgz">CxxSrc.tgz</a>, <a href="CxxNtSrc.tgz">CxxNtSrc.tgz</a>
-The source distribution kit including a Sun or NT executable.</p>
-
-<p><a href="CxxLexer.l">CxxLexer.l</a> A simple lexer for all C
-and/or C++ tokens</p>
-
-<p><a href="CxxParser.y">CxxParser.y</a> The parser,
-automatically extracted from FogParser.y.</p>
-
-<p><a href="CxxToken.hxx">CxxToken.hxx</a>, <a
-href="CxxToken.cxx">CxxToken.cxx</a> A trivial class used by the
-parser to represent each parsed token.</p>
-
-<p><a href="CxxLexing.hxx">CxxLexing.hxx</a>, <a
-href="CxxLexing.cxx">CxxLexing.cxx</a> Interface and
-implementation of token creation routines for the lexer.</p>
-
-<p><a href="CxxParsing.hxx">CxxParsing.hxx</a>, <a
-href="CxxParsing.cxx">CxxParsing.cxx</a> Interface and
-implementation of token manioulation routines for the parser.</p>
-
-<p><a href="CxxLexer.cpp">CxxLexer.cpp</a>, <a
-href="CxxParser.cpp">CxxParser.cpp</a>, <a href="CxxToken.cpp">CxxToken.cpp</a>
-Degenerate compilation units for the above.</p>
-
-<p><a href="makefile">makefile</a>, <a href="makefile.macros">makefile.macros</a>,
-<a href="CxxLexer.l">makefile.unix</a> Unix build scripts</p>
-
-<p><a href="makefile.gmake">makefile.gmake</a>, <a
-href="makefile.macros">makefile.macros</a>, <a href="grammar.dsw">grammar.dsw</a>,
-<a href="grammar.dsp">grammar.dsp</a> NT build scripts and
-DevStudio workspace and project</p>
-
-<p><a><u>sun4o/grammar</u></a> Built executable (on Unix)</p>
-
-<p><a><u>Release/grammar.exe</u></a> Built executable (on NT)</p>
-
-<hr>
-
-<h2>Unix Builds</h2>
-
-<p>The code builds under Solaris 2.5 and with Sun C++ 4.2.</p>
-
-<pre> make sun</pre>
-
-<p>or Gnu egcs-1.0.2 release, with flex 2.3.7, bison 1.16</p>
-
-<pre> make gnu</pre>
-
-<hr>
-
-<h2>NT Builds</h2>
-
-<p>The code builds under NT 4 and has been tested with DevStudio
-V6 and cygwin 1.1.</p>
-
-<h3>a) cygwin</h3>
-
-<p>You need cygwin, the latest version of which is available <a
-href="ftp://sunsite.org.uk:21/Mirrors/sourceware.cygnus.com/pub/cygwin/setup.exe">ftp://sunsite.org.uk:21/Mirrors/sourceware.cygnus.com/pub/cygwin/setup.exe</a></p>
-
-<p>A slightly easier to install earlier version (used by the
-author) is <a
-href="ftp://sunsite.org.uk:21/Mirrors/sourceware.cygnus.com/pub/cygwin/old/cygwin-b20/full.exe">ftp://sunsite.org.uk:21/Mirrors/sourceware.cygnus.com/pub/cygwin/old/cygwin-b20/full.exe</a></p>
-
-<p>Use a mirror site listed at <a
-href="http://sources.redhat.com/cygwin/mirrors.html">http://sources.redhat.com/cygwin/mirrors.html</a>.</p>
-
-<p>The older cygwin is a simple standard NT installation - just
-run full.exe (with administrator rights) and accept the default
-installation paths (gnu tools build them in). The newer cygwin is
-much smarter, doing automatic selective downloads - which the
-author's firewall messes up.</p>
-
-<h3>b) Path configuration</h3>
-
-<p>You may want to make cygwin tools accessible from command
-prompts so</p>
-
-<pre>Start->Settings->ControlPanel
- System|Environment
- Add Variable PATH
- Value C:\cygwin\cygwin-b20\H-i586-cygwin32\BIN</pre>
-
-<h3>c) DevStudio configuration</h3>
-
-<p>You need to configure DevStudio to use cygwin.</p>
-
-<p>In DevStudio:</p>
-
-<pre>Tools->Options->Directories
- Show Directories For Executable files
- Add C:\cygwin\bin</pre>
-
-<h3>d) Unpacking</h3>
-
-<p>Then use winzip or gunzip to extract all of <a
-href="CxxNtSrc.tgz">CxxNtSrc.tgz</a>:</p>
-
-<pre>double click in Explorer on <a href="CxxNtSrc.tgz">CxxNtSrc.tgz</a>
- Yes to decompress archive to temporary file
- Wait a few moments
- Actions...->Extract
- All Files, to e.g. C:\CxxGrammar, use Folder names, Extract
- Close Winzip</pre>
-
-<h3>e) DevStudio build</h3>
-
-<pre>Double click in Explorer on <a href="grammar.dsw">grammar.dsw</a>
- If prompted to browse for a SourceSafe project Click No.
- If prompted to attempt SourceSafe connection in another session click No.
- Select your preferred configuration (Win32 Debug is default)
- Select FileView|grammar Files->Targets->executable
- <Ctrl>F7
- after a few seconds everything is built</pre>
-
-<p>DevStudio reports 0 errors and 1 warnings</p>
-
-<pre>Build : warning : failed to (or don't know how to) build 'C:\CxxGrammar\Targets\executable'</pre>
-
-<p>The warning is an artefact of fake build targets</p>
-
-<p>Everything in DevStudio is compiled using a makefile.gmake
-target which is selected for a <CTRL>F7 in the Workspace
-window. Steer clear of the standard DevStudio F7 which builds all
-targets: backup then clean then executables then realclean then
-test etc. No harm is done but it takes a long time.</p>
-
-<hr>
-
-<p><i>Last updated <!--webbot bot="Timestamp" startspan
-s-type="EDITED" s-format="%d %B, %Y" -->28 July, 2001<!--webbot
-bot="Timestamp" i-checksum="21078" endspan -->.</i> </p>
-</body>
-</html>
+++ /dev/null
-#
-# Title: Make file for Cxx Grammar tester.
-#
-# Author: E.D.Willink
-#
-# SCCS: %W% %G%
-#
-# Description:
-# This makefile wrapper redirects all activity to makefile.unix after first ensuring that
-# any .INIT provided by ../import.make has executed to load required source files.
-#
-# Targets:
-# executable, normal
-# builds $(ARCH)o/grammar
-# sun
-# builds $(ARCH)o/grammar using sun compiler, yacc and lex
-# gnu
-# builds $(ARCH)o/grammar using gnu compiler, bison and flex
-# clean
-# eliminates $(ARCH)o* intermediates
-# realclean
-# eliminates $(ARCH)o* intermediates and executables
-# source_kit
-# generates the distribution kits
-#
-# Switch settings are appropriate for Sun C++ 4.2.
-# Commented settings indicate what might be appropriate for gcc once it supports templates plausibly.
-#
-# Latest Modification:
-# EDW Date: 14-Jun-2001 Original
-#END
-
-.SUFFIXES:
-
-SRCDIR = sources
-ARCH = sun4
-OBJ_DIR = $(ARCH)o
-OBJ_DIR_PI = $(ARCH)o_pi
-OBJ_DIR_G = $(ARCH)o_g
-OBJ_DIR_PI_G = $(ARCH)o_pi_g
-
-default : executable
-
-#../import.make is empty by default, but may be provided to copy sources from somewhere.
-../import.make :
- echo > $@
-IMPORT_PATH = grammar
-include ../import.make
-
-clean executable gnu realclean source_kit sun %.tar \
-$(SRCDIR)/% $(OBJ_DIR)/% $(OBJ_DIR_PI)/% $(OBJ_DIR_G)/% $(OBJ_DIR_PI_G)/% \
- : makefile makefile.unix .FORCE
- $(MAKE) -f makefile.unix $(MFLAGS) $(MAKEFLAGS) $@
-
-.FORCE:
\ No newline at end of file
+++ /dev/null
-#
-# Title: makefile.gmake
-#
-# Author: E.D.Willink
-#
-# Description: GNU make file for Cxx Grammar tester under NT
-#
-# Environment
-# INTDIR intermediate directory for objects (defaults to ".\Release")
-# OUTDIR output directory for executable (defaults to ".\Release")
-# MSINCDIR path of main system include directory (defaults to $(MSVCDIR)\Include)
-#
-# Public Targets
-# executable
-# builds '$(OUTDIR)'/grammar.exe
-# clean
-# eliminates $(INTDIR) intermediates
-# realclean
-# eliminates $(INTDIR) and '$(OUTDIR)' intermediates
-# source_kit
-# generates the distribution kits
-# Private Targets
-# backup
-# copies changed sources from C: to $(BACKUPDIR)
-# tar_delta
-# tars up changes ready for transfer to Unix
-#
-#
-# Build is error and warning free as
-# nmake -f makefile.gmake
-# (after using - Visual C++ 6
-# "C:\Program Files\Microsoft Visual Studio\VC98\Bin\vcvars32.bat"
-# or - Visual C++ 5
-# "C:\Program Files\DevStudio\VC\Bin\vcvars32.bat"
-# in a Command Prompt to set up the Visual C++ environment).
-# Alternatively do a "Compile xxx" to compile target xxx from the "grammar files->Targets"
-# after loading root.dsw into DevStudio.
-#
-.SUFFIXES:
-.SUFFIXES: .l .y .hxx .cxx .cpp .obj
-
-TARGET = grammar
-INTDIR = .\Release
-OUTDIR = $(INTDIR)
-SRCDIR = Sources
-DUMMYDIR = Dummy
-LSTDIR = Listings
-MSINCDIR = $(MSVCDIR)\Include
-BACKUPDIR = Q:/P541/C/BackUp/grammar
-TARDELTADIR = P:/$(USERNAME)
-
-CPRINT = "../tools/cprint/$(OUTDIR)/cprint.exe" -b -c150 -e -h0 -f1 -l69 -n25 -t4
-WIDE_CPRINT = "../tools/cprint/$(OUTDIR)/cprint.exe" -b -c150 -e -h0 -f1 -l69 -n0 -t4
-
-CCP = "../tools/ccp/$(OUTDIR)/ccp.exe"
-CCP_FLAGS =
-MV = mv
-#LEX = "../tools/flex_pp/$(OUTDIR)/flex_pp.exe" -S../tools/flex_pp/flexskel.cc -H../tools/flex_pp/flexskel.h
-#LEX_FLAGS = -8
-LEX = flex
-LEX_FLAGS =
-#YACC = "../tools/bison_pp/$(OUTDIR)/bison_pp.exe" -S ../tools/bison_pp/bison.cc -H ../tools/bison_pp/bison.h
-#YACC_FLAGS = -t -v
-YACC = bison -d -t -v
-YACC_FLAGS =
-
-CPP = cl.exe /nologo
-CPP_RELEASE_FLAGS = /ML /O2 /D "NDEBUG"
-CPP_DEBUG_FLAGS = /MLd /Gm /ZI /Od /D "_DEBUG" /GZ
-CPP_COMMON_FLAGS = /W3 /GX /Fo"$(INTDIR)/" /Fd"$(INTDIR)/$(TARGET)" /c
-CPP_DEFS = /D "WIN32" /D "_CONSOLE" /D "_MBCS" /D "NEEDS_YYWRAP"
-CPP_INCS = /I "$(SRCDIR)" /I "." /I "$(DUMMYDIR)"
-
-LINK32 = link.exe /nologo /machine:I386 /subsystem:console
-LINK_RELEASE_FLAGS = /incremental:no
-LINK_DEBUG_FLAGS = /incremental:yes /debug /pdbtype:sept
-LINK32_LIBS = kernel32.lib
-
-MAKEFILE = makefile.gmake
-DUMMIES = $(DUMMYDIR)/unistd.h
-
-include makefile.macros
-
-OBJECTS = $(COMPOSITE_SOURCES:%.cpp=$(INTDIR)/%.obj)
-
-all : $(ALL_FILES) executable
-
-executable : $(OUTDIR)/$(TARGET).exe
-
-$(DUMMYDIR)/unistd.h :
- @- sh -c 'if test ! -d "$(@D)"; then echo mkdir -p "$(@D)"; mkdir -p "$(@D)"; fi'
- @echo '$@'
- @- sh -c 'echo "#include <io.h>" > "$@"'
- @- sh -c 'chmod -w "$@"'
-
-$(SRCDIR)/%.cxx : %.l
- @- sh -c 'if test ! -d "$(@D)"; then echo mkdir -p "$(@D)"; mkdir -p "$(@D)"; else rm -f $(@D)/$*.cxx; fi'
- - sh -c '$(LEX) $(LEX_FLAGS) $*.l'
- @- sh -c 'mv -f lex.yy.c $(@D)/$*.cxx'
- @- sh -c 'chmod -w $(@D)/$*.cxx'
-
-$(SRCDIR)/%.cxx $(SRCDIR)/%.hxx : %.y
- @- sh -c 'if test ! -d "$(@D)"; then echo mkdir -p "$(@D)"; mkdir -p "$(@D)"; else rm -f $(@D)/$*.output $(@D)/$*.cxx $(@D)/$*.hxx; fi'
- - sh -c '$(YACC) $(YACC_FLAGS) $*.y'
- @- sh -c 'mv -f $*.tab.c $(@D)/$*.cxx'
- @- sh -c 'mv -f $*.tab.h $(@D)/$*.hxx'
- @- sh -c 'mv -f $*.output $(@D)/$*.output'
- @- sh -c 'chmod -w $(@D)/$*.cxx $(@D)/$*.hxx $(@D)/$*.output'
-
-.\Release/%.obj : %.cpp
- @- sh -c 'if test ! -d "$(@D)"; then echo mkdir -p "$(@D)"; mkdir -p "$(@D)"; else rm -f "$@"; fi'
- @- sh -c '$(CPP) $(CPP_INCS) $(CPP_DEFS) $(CPP_RELEASE_FLAGS) $(CPP_COMMON_FLAGS) "$<"'
-
-.\Debug/%.obj : %.cpp
- @- sh -c 'if test ! -d "$(@D)"; then echo mkdir -p "$(@D)"; mkdir -p "$(@D)"; else rm -f "$@"; fi'
- @- sh -c '$(CPP) $(CPP_INCS) $(CPP_DEFS) $(CPP_DEBUG_FLAGS) $(CPP_COMMON_FLAGS) "$<"'
-
-.\Release/$(TARGET).exe : $(OBJECTS) $(MAKEFILE)
- @- sh -c 'if test ! -d "$(@D)"; then echo mkdir -p "$(@D)"; mkdir -p "$(@D)"; fi'
- @echo '$@'
- @- sh -c '$(LINK32) /pdb:"$(@D)/$(TARGET).pdb" /out:"$@" $(LINK_RELEASE_FLAGS) $(OBJECTS:%="%") $(LINK32_LIBS)'
-
-.\Debug/$(TARGET).exe : $(OBJECTS) $(MAKEFILE)
- @- sh -c 'if test ! -d "$(@D)"; then echo mkdir -p "$(@D)"; mkdir -p "$(@D)"; fi'
- @echo '$@'
- @- sh -c '$(LINK32) /pdb:"$(@D)/$(TARGET).pdb" /out:"$@" $(LINK_DEBUG_FLAGS) $(OBJECTS:%="%") $(LINK32_LIBS)'
-
-$(LSTDIR)/CxxLexer.list : CxxLexer.cpp $(LEXER_FILES) $(L_FILES)
- @- sh -c 'if test ! -d "$(@D)"; then echo mkdir -p "$(@D)"; mkdir -p "$(@D)"; else rm -f "$@"; fi'
- sh -c '$(CPRINT) $? > "$@"'
-
-$(LSTDIR)/CxxParser.list : CxxParser.cpp $(PARSER_FILES) $(Y_FILES)
- @- sh -c 'if test ! -d "$(@D)"; then echo mkdir -p "$(@D)"; mkdir -p "$(@D)"; else rm -f "$@"; fi'
- sh -c '$(CPRINT) $? > "$@"'
-
-$(LSTDIR)/CxxToken.list : CxxToken.cpp $(TOKEN_FILES)
- @- sh -c 'if test ! -d "$(@D)"; then echo mkdir -p "$(@D)"; mkdir -p "$(@D)"; else rm -f "$@"; fi'
- sh -c '$(CPRINT) $? > "$@"'
-
-$(LSTDIR)/CxxMake.list : $(MAKE_FILES)
- @- sh -c 'if test ! -d "$(@D)"; then echo mkdir -p "$(@D)"; mkdir -p "$(@D)"; else rm -f "$@"; fi'
- sh -c '$(CPRINT) $? > "$@"'
-
-source_kit: CxxNtSrc.tgz
-
-CxxNtSrc.tgz : CxxNtSrc.tar
- @echo $@
- @- sh -c 'rm -f "$@"'
- @- sh -c 'gzip "$<" -c > "$@"'
- @- sh -c 'chmod -w "$@"'
-
-CxxNtSrc.tar : FORCE
- @echo $@
- @- sh -c 'rm -f "$@"'
- @- sh -c 'tar cf "$@" $(ALL_FILES:%="$(MAKE_TAR_PATH)%") "Release/grammar.exe"'
- @- sh -c 'chmod -w "$@"'
-
-$(PWD)/%.tar : FORCE
- @- sh -c 'cd $(PWD); tar rf "$(@F)" $(ALL_FILES:%="$(MAKE_TAR_PATH)%")'
-
-FORCE :
-
-tar_delta : $(TARDELTADIR)/$(TARGET)_delta.tar
-
-$(TARDELTADIR)/$(TARGET)_delta.tar : $(ALL_FILES)
- @- sh -c 'if test ! -d "$(@D)"; then echo mkdir -p "$(@D)"; mkdir -p "$(@D)"; else rm -f "$@"; fi'
- - sh -c 'tar cf - $(?:%="%") > "$@"'
- @- sh -c 'chmod -w "$@"'
-
-backup : $(ALL_FILES:%=$(BACKUPDIR)/%) $(BACKUPDIR)/grammar.dsp
-
-$(BACKUPDIR)/% : %
- @- sh -c 'if test ! -d "$(@D)"; then echo mkdir -p "$(@D)"; mkdir -p "$(@D)"; else rm -f "$@"; fi'
- @echo $<
- @- sh -c 'cp "$<" "$@"'
- @- sh -c 'chmod -w "$@"'
-
-clean :
- @- sh -c 'if test -d "$(INTDIR)"; then rm -f "$(INTDIR)"/*.idb "$(INTDIR)"/*.ilk "$(INTDIR)"/*.obj "$(INTDIR)"/*.pch "$(INTDIR)"/*.pdb; fi'
- @- sh -c 'rm -f "$(SRCDIR)"/*.xxh'
-
-realclean : clean
- @- sh -c 'rm -rf "$(DUMMYDIR)" Release Debug $(SRCDIR)'
- @- sh -c 'rm -f "tests/*/results/*"'
-
-$(INTDIR)/CxxLexer.obj : CxxLexing.cxx CxxLexing.hxx $(SRCDIR)/CxxLexer.cxx $(SRCDIR)/CxxParser.hxx $(DUMMIES)
-$(INTDIR)/CxxParser.obj : CxxParsing.cxx CxxParsing.hxx $(SRCDIR)/CxxParser.cxx $(SRCDIR)/CxxParser.hxx
-$(INTDIR)/CxxToken.obj : CxxToken.cxx CxxToken.hxx
+++ /dev/null
-#
-# Title: Common make macros for the Cxx Grammar tester.
-#
-# Author: E.D.Willink
-#
-# Description:
-#
-# These macros are shared by
-# makefile for Unix make
-# makefile.gmake for NT (g)make
-#END
-
-L_FILES = \
- CxxLexer.l
-
-Y_FILES = \
- CxxParser.y
-
-LEXER_FILES = \
- CxxLexing.cxx \
- CxxLexing.hxx
-
-PARSER_FILES = \
- CxxParsing.cxx \
- CxxParsing.hxx
-
-TOKEN_FILES = \
- CxxToken.cxx \
- CxxToken.hxx
-
-CLASS_SOURCES = \
- $(LEXER_FILES) \
- $(PARSER_FILES) \
- $(TOKEN_FILES)
-
-#
-# list of all compilation units
-#
-COMPOSITE_SOURCES = \
- CxxLexer.cpp \
- CxxParser.cpp \
- CxxToken.cpp
-
-Y_CXX_FILES = $(Y_FILES:%.y=$(SRCDIR)/%.cxx)
-GENERATED_INCLUDES = \
- $(L_FILES:%.l=$(SRCDIR)/%.cxx) \
- $(Y_FILES:%.y=$(SRCDIR)/%.cxx) \
- $(Y_FILES:%.y=$(SRCDIR)/%.hxx)
-
-MAKE_FILES = \
- makefile \
- makefile.gmake \
- makefile.macros \
- makefile.unix
-
-# list of all other files for listing purposes
-OTHER_SOURCES = \
- $(MAKE_FILES) \
- $(CLASS_SOURCES) \
- $(L_FILES) \
- $(Y_FILES)
-
-CPP_SOURCES = $(COMPOSITE_SOURCES)
-
-INCLUDES = $(GENERATED_INCLUDES)
-
-SOURCES = \
- $(CPP_SOURCES) \
- $(CLASS_SOURCES) \
- $(L_FILES) \
- $(Y_FILES) \
- $(MAKE_FILES)
-
-DOCUMENTATION_FILES = \
- index.html \
- README
-
-# List of all primary files (to be copied to a secondary environment)
-ALL_FILES = \
- $(SOURCES) \
- $(DOCUMENTATION_FILES) \
- grammar.dsp \
- grammar.dsw
+++ /dev/null
-#
-# Title: Make file for Cxx Grammar tester.
-#
-# Author: E.D.Willink
-#
-# SCCS: %W% %G%
-#
-# Description: This stripped down make file builds the Cxx Grammar tester.
-#
-# Targets:
-# default, executable, normal
-# builds $(ARCH)o/grammar using default (sun) compiler
-# sun
-# builds $(ARCH)o/grammar using sun compiler, yacc and lex
-# gnu
-# builds $(ARCH)o/grammar using gnu compiler, bison and flex
-# debug
-# builds $(ARCH)o_g/grammar
-# clean
-# eliminates $(ARCH)o* intermediates
-# realclean
-# eliminates $(ARCH)o* intermediates and executables
-# source_kit
-# generates the distribution kits
-#
-# Switch settings are appropriate for Sun C++ 4.2.
-# Commented settings indicate what might be appropriate for gcc once it supports templates plausibly.
-#
-# Latest Modification:
-# EDW Date: 14-Jun-2001 Original
-#END
-
-.SUFFIXES:
-
-COMPILER = SUN_4_2
-TARGET = grammar
-ARCH = sun4
-FOG_PATH = $(PWD)
-SRCDIR = sources
-PCHDIR = $(SRCDIR)
-STDDIR = std
-DUMMYDIR = dummy
-OBJ_DIR = $(ARCH)o
-OBJ_DIR_PI = $(ARCH)o_pi
-OBJ_DIR_G = $(ARCH)o_g
-OBJ_DIR_PI_G = $(ARCH)o_pi_g
-PRECIOUS_DIRECTORIES = $(SRCDIR) $(OBJ_DIR) $(OBJ_DIR_PI) $(OBJ_DIR_G) $(OBJ_DIR_PI_G)
-PRECIOUS_LIBRARIES = $(OBJ_DIR)/lib$(TARGET).a $(OBJ_DIR_PI)/lib$(TARGET).so \
- $(OBJ_DIR_G)/lib$(TARGET).a $(OBJ_DIR_PI_G)/lib$(TARGET).so
-
-.PRECIOUS: $(PRECIOUS_DIRECTORIES) $(PRECIOUS_LIBRARIES) $(SRCDIR)/$(TARGET).dep
-
-LINK = $(PURIFY) $(CC)
-LFLAGS =
-EGCS_1_0_2_LINK_LIBS = -ll
-SUN_4_2_LINK_LIBS = -lsunmath -lm /usr/ccs/lib/libl.a
-LINK_LIBS = $($(COMPILER)_LINK_LIBS)
-
-SUN_4_2_CC = CC
-EGCS_1_0_2_CC = g++
-CC = $($(COMPILER)_CC)
-
-SUN_4_2_G = -g0
-EGCS_1_0_2_G = -g
-_G = $($(COMPILER)_G)
-
-SUN_4_2_PIC = -PIC
-EGCS_1_0_2_PIC =
-_PIC = $($(COMPILER)_PIC)
-
-SUN_4_2_CFLAGS = -temp=. -ptr. -noex
-EGCS_1_0_2_CFLAGS =
-CFLAGS = $($(COMPILER)_CFLAGS)
-
-SUN_4_2_CC_INCS =
-EGCS_1_0_2_CC_INCS = -I../$(DUMMYDIR)
-CC_INCS = -I../$(SRCDIR) -I.. $($(COMPILER)_CC_INCS)
-
-SUN_4_2_CC_DEFS = -D__EXTERN_C__ -DNEEDS_BOOL -DNEEDS_YYWRAP
-EGCS_1_0_2_CC_DEFS =
-CC_DEFS = $($(COMPILER)_CC_DEFS)
-
-SUN_4_2_LFLAGS =
-EGCS_1_0_2_LFLAGS =
-LFLAGS = $($(COMPILER)_LFLAGS)
-
-CP = cp
-MV = mv
-RM = rm
-
-SUN_4_2_LEX = lex
-EGCS_1_0_2_LEX = flex
-LEX = $($(COMPILER)_LEX)
-
-SUN_4_2_LEX_FLAGS = -n
-EGCS_1_0_2_LEX_FLAGS =
-LEX_FLAGS = $($(COMPILER)_LEX_FLAGS)
-
-SUN_4_2_YACC = yacc
-EGCS_1_0_2_YACC = bison
-YACC = $($(COMPILER)_YACC)
-
-SUN_4_2_YACC_FLAGS = -d -t -v
-EGCS_1_0_2_YACC_FLAGS = -d -t -v -y
-YACC_FLAGS = $($(COMPILER)_YACC_FLAGS)
-
-default : executable $(ALL_FILES)
-
-#../import.make is empty by default, but may be provided to copy sources from somewhere.
-../import.make :
- echo > $@
-IMPORT_PATH = grammar
-include ../import.make
-
-include makefile.macros
-
-LIB_OBJS = $(COMPOSITE_SOURCES:%.cpp=%.o)
-LIB_OBJS_G = $(COMPOSITE_SOURCES:%.cpp=$(OBJ_DIR_G)/%.o)
-DUMMIES = $(DUMMYDIR)/osfcn.h
-
-executable : $(ALL_FILES) normal
-
-normal : $(OBJ_DIR)/$(TARGET)
-
-debug : $(OBJ_DIR_G)/$(TARGET)
-
-sun :
- $(MAKE) -f makefile.unix $(MFLAGS) COMPILER=SUN_4_2 normal
-
-gnu :
- $(MAKE) -f makefile.unix $(MFLAGS) COMPILER=EGCS_1_0_2 normal
-
-$(DUMMYDIR)/osfcn.h :
- @- sh -c 'if test ! -d "$(@D)"; then echo mkdir -p "$(@D)"; mkdir -p "$(@D)"; fi'
- @echo '$@'
- @- sh -c 'echo "extern \"C\" int read(int, char *, int);" > "$@"'
- @- sh -c 'chmod -w "$@"'
-
-$(SRCDIR)/%.cxx : %.l
- @- if test ! -d $(@D); then echo mkdir -p $(@D); mkdir -p $(@D); else $(RM) -f $(@D)/$*.cxx; fi
- - $(LEX) $(LEX_FLAGS) $*.l
- @- mv -f lex.yy.c $(@D)/$*.cxx
- @- chmod -w $(@D)/$*.cxx
-
-$(SRCDIR)/%.cxx $(SRCDIR)/%.hxx : %.y
- @- if test ! -r $(@D); then echo mkdir -p $(@D); mkdir -p $(@D); else $(RM) -f $(@D)/$*.output $(@D)/$*.cxx $(@D)/$*.hxx; fi
- - $(YACC) $(YACC_FLAGS) $*.y
- @- mv -f y.tab.c $(@D)/$*.cxx
- @- mv -f y.tab.h $(@D)/$*.hxx
- @- mv -f y.output $(@D)/$*.output
- @- chmod -w $(@D)/$*.cxx $(@D)/$*.hxx $(@D)/$*.output
-
-$(OBJ_DIR)/%.o : %.cpp
- @- if test ! -d $(@D); then echo mkdir -p $(@D); mkdir -p $(@D); fi
- @- echo $@
- @- cd $(OBJ_DIR) ; if $(CC) -c -O $(CFLAGS) $(CC_INCS) $(CC_DEFS) -o $*.o ../$< ;\
- then : ; else $(RM) -f $*.o; fi
-
-$(OBJ_DIR_PI)/%.o : %.cpp
- @- if test ! -d $(@D); then echo mkdir -p $(@D); mkdir -p $(@D); fi
- @- echo $@
- @- cd $(OBJ_DIR_PI) ; if $(CC) -c -O $(_PIC) $(CFLAGS) $(CC_INCS) $(CC_DEFS) -o $*.o ../$< ;\
- then : ; else $(RM) -f $*.o; fi
-
-$(OBJ_DIR_G)/%.o : %.cpp
- @- if test ! -d $(@D); then echo mkdir -p $(@D); mkdir -p $(@D); fi
- @- echo $@
- @- cd $(OBJ_DIR_G) ; if $(CC) -c $(_G) $(CFLAGS) $(CC_INCS) $(CC_DEFS) -o $*.o ../$< ;\
- then : ; else $(RM) -f $*.o; fi
-
-$(OBJ_DIR_PI_G)/%.o : %.cpp
- @- if test ! -d $(@D); then echo mkdir -p $(@D); mkdir -p $(@D); fi
- @- echo $@
- @- cd $(OBJ_DIR_PI_G) ; if $(CC) -c $(_PIC) $(_G) $(CFLAGS) $(CC_INCS) $(CC_DEFS) -o $*.o ../$< ;\
- then : ; else $(RM) -f $*.o; fi
-
-$(TARGET) : makefile $(LIB_OBJS:%.o=$(OBJ_DIR)/%.o)
- @- if test ! -d $(@D); then echo mkdir -p $(@D); mkdir -p $(@D); fi
- @- echo $@
- - cd $(OBJ_DIR) ; $(LINK) $(CFLAGS) $(CC_INCS) $(CC_DEFS) -o ../$(TARGET) -Bstatic \
- $(LIB_OBJS) $(LINK_LIBS)
-
-$(OBJ_DIR)/$(TARGET) : makefile $(LIB_OBJS:%.o=$(OBJ_DIR)/%.o)
- @- if test ! -d $(@D); then echo mkdir -p $(@D); mkdir -p $(@D); else rm -f $@; fi
- @- echo $@
- - cd $(OBJ_DIR) ; $(LINK) $(CFLAGS) $(CC_INCS) $(CC_DEFS) -o $(TARGET) $(LIB_OBJS) $(LINK_LIBS)
-
-$(OBJ_DIR_G)/$(TARGET) : makefile $(LIB_OBJS:%.o=$(OBJ_DIR_G)/%.o)
- @- if test ! -d $(@D); then echo mkdir -p $(@D); mkdir -p $(@D); else rm -f $@; fi
- @- echo $@
- - cd $(OBJ_DIR_G) ; $(LINK) $(CFLAGS) $(CC_INCS) $(CC_DEFS) $$(_G) -o $(TARGET) $(LIB_OBJS) $(LINK_LIBS)
-
-source_kit : CxxSrc.tgz
-
-CxxSrc.tgz : CxxSrc.tar
- @- rm -f $@
- - gzip CxxSrc.tar -c > $@
- @- chmod -w $@
-
-CxxSrc.tar : $(ALL_FILES) FORCE $(OBJ_DIR)/grammar
- @- rm -f "$@
- @- tar cf "$@" $(ALL_FILES:%="$(MAKE_TAR_PATH)%") "$(MAKE_TAR_PATH)$(OBJ_DIR)/grammar"
- @- chmod -w "$@"
-
-$(TAR_FILE) : $(ALL_FILES) FORCE
- @- cd $(@D); tar rf $(@F) $(ALL_FILES:%=$(MAKE_TAR_PATH)%)
-
-FORCE :
-
-#
-# Cleanup rules
-#
-clean :
- - $(RM) -f $(DUMMYDIR)/* $(SRCDIR)/* $(OBJ_DIR)/*.o $(OBJ_DIR_PI)/*.o $(OBJ_DIR_G)/*.o $(OBJ_DIR_PI_G)/*.o
-
-realclean :
- - $(RM) -rf $(DUMMYDIR) $(SRCDIR) $(OBJ_DIR) $(OBJ_DIR_PI) $(OBJ_DIR_G) $(OBJ_DIR_PI_G)
-
-$(OBJ_DIR)/CxxLexer.o $(OBJ_DIR_PI)/CxxLexer.o $(OBJ_DIR_G)/CxxLexer.o $(OBJ_DIR_PI_G)/CxxLexer.o : \
- CxxLexing.cxx CxxLexing.hxx CxxToken.hxx $(SRCDIR)/CxxLexer.cxx $(SRCDIR)/CxxParser.hxx $(DUMMIES)
-$(OBJ_DIR)/CxxParser.o $(OBJ_DIR_PI)/CxxParser.o $(OBJ_DIR_G)/CxxParser.o $(OBJ_DIR_PI_G)/CxxParser.o : \
- CxxParsing.cxx CxxParsing.hxx CxxToken.hxx $(SRCDIR)/CxxParser.cxx $(SRCDIR)/CxxParser.hxx
-$(OBJ_DIR)/CxxToken.o $(OBJ_DIR_PI)/CxxToken.o $(OBJ_DIR_G)/CxxToken.o $(OBJ_DIR_PI_G)/CxxToken.o : \
- CxxToken.cxx CxxToken.hxx
+++ /dev/null
-From: Ed.Willink [mailto:Ed.Willink@uk.thalesgroup.com]
-Sent: Thursday, January 15, 2004 12:23 PM
-To: 'Chris Koeritz'
-Cc: 'Ed.Willink@thalesgroup.com'
-Subject: RE: question regarding your c++ grammar and lexer...
-Hi Chris
-
-
-[Please use Ed.Willink@thalesgroup.com for further coirrespondence. ]
-The grammar's the most re-usable bit. Overall it came from my extended C++ language
-FOG that allowed meta-execution at compile time ..,
-It is very Open Source - no license at all. You may use it as you like. It would
-be nice if you give an appropriate acknowledgement..
-The ISO compliance is the result of best endeavours comparison and interpretation
-rather than rigourous application of conformance suites.
-Be aware that it is a context free syntax only parser. It requires a subsequent semantic
-phase to resolve certain ambiguities that require type context.. If you need to
-implement this, you really should read the Grammar chapter of my thesis posted
-on the same site, and maybe use the FOG semantic parsing as a starting point.
-I hope you make lots and lots of money, so that you may feel generously disposed
-to giving me some.
-Regards
-Ed Willink
-
-
------Original Message-----
-From: Chris Koeritz
-Sent: 14 January 2004 19:35
-To: 'Ed.Willink@rrl.co.uk'
-Subject: question regarding your c++ grammar and lexer...
-dear mr. willink,
-first, thank you very much for posting your c++ grammar online. it is, well, awesome that it is compliant with the ansi standard.
-i am wondering though about what copyrights apply to it. i am considering using the grammar in a project that might be included in a tool which might eventually be sold.
-my concerns are: (1) is it appropriate to include your grammar in a GPLed open source application? and (2) do you allow the grammar to be used in a project that might be sold commercially without any royalty requirements for the use of it?
-please feel free to push my nose into any FAQ sites or other information that may already be available. i came by your grammar from the site here: http://www.parashift.com/c++-faq-lite/compiler-dependencies.html#faq-37.11
-and they were a bit skimpy on links to anything besides the grammar itself.
-thanks for your time and i hope releasing this grammar has been more fun than trouble for you...
--chris koeritz
-
+++ /dev/null
-var=0
-for i in *; do
- var=$(($var + 1))
- mkdir -p ~/pictures_converted/$var/
- pdfimages -j $i ~/pictures_converted/$var/
- mv ~/pictures_converted/$var/* ~/pictures_converted/$(basename $i .pdf).jpg
-done
-
-
+++ /dev/null
-#!/bin/bash
-##############
-# Name : gpg-daemon-launcher
-# Author : Chris Koeritz
-# Rights : Copyright (C) 2012-$now by Feisty Meow Concerns, Ltd.
-##############
-# This script is free software; you can modify/redistribute it under the terms
-# of the GNU General Public License. [ http://www.gnu.org/licenses/gpl.html ]
-# Feel free to send updates to: [ fred@gruntose.com ]
-##############
-
-# starts up the gpg-agent, but only if it's not already running.
-
-source "$FEISTY_MEOW_SCRIPTS/core/launch_feisty_meow.sh"
-
-if [ -z "$(psa gpg-agent)" ]; then
- gpg-agent --daemon --enable-ssh-support --write-env-file "${HOME}/.gpg-agent-info" &>$TMP/zz_gpg-agent-daemon.log
-fi
-
-
-
+++ /dev/null
-#!/usr/bin/perl
-
-###############################################################################
-# #
-# Name : template #
-# Author : Chris Koeritz #
-# Rights : Copyright (C) 1996-$now by Author #
-# #
-# Purpose: #
-# #
-# Attempts to pre-instantiate C++ templates to work-around C++ compilers #
-# that don't support templates (a rare breed, these days). #
-# #
-###############################################################################
-# This program is free software; you can redistribute it and/or modify it #
-# under the terms of the GNU General Public License as published by the Free #
-# Software Foundation; either version 2 of the License or (at your option) #
-# any later version. See: "http://www.gruntose.com/Info/GNU/GPL.html" for a #
-# version of the License. Please send any updates to "fred@gruntose.com". #
-###############################################################################
-
-# this was a majestic abortive attempt to create a template instantiator for
-# compilers that do not possess templates, but which do support some subset
-# of C++. This was necessary at the time, due to our firmware compiler's
-# limitations. This processor never totally worked, although it did produce
-# some interesting compilable code. Might be useful as a demo or maybe just
-# as a warning to avoid brain-damaged C++ compilers.
-
-# to do:
-# maintain statistics about placement in file for error resolution.
-
-# limitations so far:
-#
-# the word "template" must be the first word on the line.
-#
-# the type to instantiate must be one word (like charstar, not char *).
-#
-# templates must follow the form templateName<templateType> without
-# any spaces between the angle brackets.
-
-# flag to enable debugging print outs.
-$DEBUG_TEMPLATIZER = 1;
-#$DEBUG_TEMPLATIZER = 0;
-
-# array to store instance types to convert to
-@instance_type_buffer = ();
-# flag for checking read from file option
-$f_option = 0;
-$d_option = 0;
-
-if ($#ARGV < 1) {
- die("
- The template instantiater supports an optional directory path as the first
- parameter (preceded by a -d with no spaces in between the d and the
- directory name) in which to store the generated templates, and then
- requires the instantiation type as the next argument (or a file
- specification preceded by -f), and a list of files as the last
- arguments.
- The files will be scanned for templates and those templates will be
- instantiated in the type(s) specified.
- Examples:
- perl template.pl char istring.h torpedo.h
- perl template.pl -f instance.txt matrix.h
- perl template.pl -d. -f instance.txt function.h data_src.h
- perl template.pl -dfirm_src\library\basis -f instance.txt amorph.h\n");
-}
-
-# Check directory option
-if (grep(/^\s*-d/, @ARGV)) {
- $d_option = 1;
- $d_dir = @ARGV[0];
-# print $d_dir, "\n";
- shift;
-}
-
-
-# Check to see if user used a file to specify instantiation types
-if (grep(/^\s*-f/, @ARGV)) {
- $f_option = 1;
- shift;
- $types_file = @ARGV[0];
-
-# Open instantiation type file to read from
- open(TYPES_FILE, "<$types_file")
- || die("couldn't open file $types_file for reading");
-
-# Read in all the different types to instantiate
-# Create instance_type list
- @tp = <TYPES_FILE>;
- while (@tp) {
- local($line) = @tp;
- chop $line;
- push(@instance_type_buffer, $line);
- shift @tp;
- }
- shift @ARGV;
- &instantiate_templates(@ARGV);
- exit;
-}
-
-&instantiate_templates(@ARGV);
-exit;
-
-#
-# driver of the instantiation process.
-#
-sub instantiate_templates {
- if (!$f_option) {
- # grab the user's desired instance type.
- $instance_type = @_[0];
- push(@instance_type_buffer, $instance_type);
- print "Instantiation type is \"$instance_type\".\n";
- # jump over the instance type to look at the filenames.
- shift;
- }
-
- local($i) = 0;
- foreach $filename (@_) {
- open(INPUT_FILE, "<$filename")
- || die("couldn't open file $filename for reading");
- # create an output name for the instance.
- $out_filename = &make_output_name($filename);
- if ($DEBUG_TEMPLATIZER) {
-# print "out file is ", $out_filename, "\n";
- }
- local($index) = $i + 1;
- print "Instantiating file[$index] as $out_filename.\n";
- # now try opening our output file.
- open(OUTPUT_FILE, ">$out_filename")
- || die("couldn't open file $filename for writing");
- # grab the current file into an array.
-
- @file_array = <INPUT_FILE>;
- @start_template = @file_array;
- @stop_template = @file_array;
- # process the file's contents as a manipulable array.
- while (@file_array) {
- local($line) = shift @file_array;
- if (grep(/^\s*template/, $line)) {
- @start_template = @file_array;
-
- # iterate through all the instance types for each template
- foreach $instance_type (@instance_type_buffer) {
- @file_array = @start_template;
- &snag_place_holder($line);
- &snag_object_name;
- &absorb_until_matched_block;
- &replace_place_holder;
- &dump_the_buffer;
- print OUTPUT_FILE "\n";
- }
- } elsif (grep(/\w+<\w+>/, $line)) {
- local(@pieces) = split(/\s/, $line);
- foreach $piece (@pieces) {
- local($prefix) = "";
- # special case for separating function name from templated first
- # parameter to it.
- if (grep(/\(\w+</, $piece)) {
- local(@chop_paren) = split(/\(/, $piece, 2);
- $prefix = $chop_paren[0].'(';
- $piece = $chop_paren[1];
- }
- if (grep(/\w+<\w+>/, $piece)) { $piece = &special_mangle($piece); }
- print OUTPUT_FILE "$prefix$piece ";
- }
- print OUTPUT_FILE "\n";
- } else {
- print OUTPUT_FILE $line;
- }
- }
- $i++;
- }
-}
-
-#
-# generates an output name from the filename to be translated.
-#
-sub make_output_name {
- local($out_filename) = @_[0];
- local($d_dir_temp) = $d_dir;
-# print "OUTFILE NAME: ",$out_filename,"\n";
- # break down the filename at the slashes.
- local(@split_filename) = split(/[\\\/]/, $out_filename);
- # take the basename of the list of names.
- $out_filename = $split_filename[$#split_filename];
- local($hold_filename) = $out_filename;
- if (grep(!/\.cpp$/i, $out_filename) && grep(!/\.h$/i, $out_filename)
- && grep(!/\.c$/i, $out_filename) && grep(!/\.h$/i, $out_filename) ) {
- die("filename @_[0] not recognized as a C++ code file.");
- }
- # makes an instance of the file in a directory named after the instance type
- # that is located under the current directory.
-
- $d_dir_temp = join('/',$d_dir, $hold_filename);
- if ($d_option) {
- $d_dir_temp =~ s/-d//i;
- @split_filename = split(/[\\\/]/, $d_dir_temp);
-# exit;
- }
-
-# try to create dir using the deepest dir given in filename input
-
- local($y) = 0;
- foreach (@split_filename) { $y++; }
-
- local($x) = 0;
- local($ret) = 0;
- local($dirs) = 0;
-
- if ($y >= 2) {
- foreach (@split_filename) {
- if ((($x > 0) && ($x < $y-1)) || (($d_option) && ($x < $y-1))) {
- if (!$dirs) { $dirs = @split_filename[$x]; }
- else { $dirs = $dirs."/".@split_filename[$x]; }
-# print "Creating... ",$dirs,"\n";
- $ret = mkdir($dirs, 0777);
- if (!ret) { die("a directory named $instance_dir could not be made."); }
- }
- $x++;
- }
- $out_filename = $dirs."/".$hold_filename;
- }
- else { $out_filename = "template/".$hold_filename;
- local($instance_dir) = "template";
- $ret = mkdir($instance_dir, 0777);
- if (!ret) { die("a directory named $instance_dir could not be made."); }
- }
-# print $out_filename, "\n";
-
-# local($instance_dir) = @split_filename[$x-2];
-# creates the directory.
-# local($ret) = mkdir($instance_dir, 0777);
-# if (!ret) { die("a directory named $instance_dir could not be made."); }
-
- $out_filename; # return the new name.
-}
-
-#
-# grabs the name of the placeholder type that will be replaced by
-# the template instantiation type.
-#
-sub snag_place_holder {
- $place_holder = @_[0];
- chop $place_holder;
-
- local(@pieces) = split(/>\s*/, $place_holder, 2);
-
- # send back the parts not involved in the template statement.
- if (length($pieces[1])) {
- unshift(@file_array, $pieces[1]."\n");
- }
- $place_holder = $pieces[0];
- $place_holder =~ s/\s*template\s+<class\s+(\w+)$/\1/;
- if ($DEBUG_TEMPLATIZER) {
-# print "Replacing place holder \"$place_holder\" with \"$instance_type\".\n";
- }
-}
-
-#
-# grabs the name of the object itself that will become an instantiated
-# object in the type specified. the global variable "object_name" is
-# set by the subfunctions used here.
-#
-sub snag_object_name {
- local($next_line) = shift(@file_array);
- chop $next_line;
- &match_class_declaration($next_line)
- || &match_class_member_definition($next_line)
- || &match_function_definition($next_line);
-}
-
-#
-# creates a mangled form of the name that includes the instantiation
-# type. the global variable "mangled_name" is set by this function.
-#
-sub mangle_name {
- local($to_grind) = @_[0];
- local($mangled_name) = "template__".$to_grind."__".$instance_type;
- if ($DEBUG_TEMPLATIZER) {
-# print "Replacing name \"$to_grind\" with \"$mangled_name\".\n";
- }
- $mangled_name;
-}
-
-#
-# processes "#include" preprocessor directives to make sure if the filename
-# is in there to include a C++ file (for the template code), then it gets
-# converted to the new file name.
-#
-
-# this is a pretty bogus thing; it should not be used.
-
-sub convert_inclusion {
- local($line) = @_[0];
- chop $line;
- local($temp) = $line;
- # extract out the name parts of the include declaration.
- $temp =~ s/\s*#include\s*([<"])([\w.]+)([>"])/\1 \2 \3/;
- local(@broken_up) = split(/ /, $temp);
- # strip off the punctuation from the name.
- local($incl_prefix) = @broken_up[1];
- $incl_prefix =~ s/["<](.*)[">]/\1/;
- $incl_prefix =~ s/\s//g;
- # return if it's not a code file being included.
- if (!grep(/.cpp/i, $incl_prefix)) { print OUTPUT_FILE $line, "\n"; return; }
- # strip to just the name without the ending.
- $incl_prefix =~ s/\.cpp$//i;
- # now get the name of the file we're processing.
- local($file_prefix) = $filename;
- # return if it's not a header file being examined.
- if (!grep(/.h/i, $file_prefix)) { print OUTPUT_FILE $line, "\n"; return; }
- # strip off the extension.
- $file_prefix =~ s/\.h$//i;
- # return if the names aren't equivalent--this means the include doesn't
- # refer to our new templated form of the code file.
- if ($incl_prefix ne $file_prefix) { print OUTPUT_FILE $line, "\n"; return FALSE; }
- # dump out a message about the removal.
- $line =~ s/^\s*//;
- print OUTPUT_FILE "/* removed unneeded template inclusion: $line */\n";
-}
-
-#
-# extracts lines from the file until the curly brackets are matched up
-# at level 0.
-#
-sub absorb_until_matched_block {
- $bracket_level = 0;
- $end_absorb = 0;
- @template_buffer = ();
- $hit_one=0;
- while (@file_array) {
- local($line) = shift @file_array;
- &look_for_curlies($line);
- if (($hit_one && ($bracket_level == 0)) || $end_absorb) { return; }
- }
-}
-
-#
-# examines the parameters passed in for curly brackets and changes the
-# counter if they are found.
-#
-sub look_for_curlies {
-# $hit_one = 0; # records whether a bracket was found or not.
- local($line) = @_[0];
- @word = ();
- foreach $char (split(//, $line)) {
- if ($char eq '{') {
- $hit_one = 1;
- $bracket_level++;
- } elsif ($char eq '}') {
- $hit_one = 1;
- $bracket_level--;
- } elsif (($char eq ';') && ($hit_one==0)) {
- $end_absorb = 1;
- }
-
-
- if ($DEBUG_TEMPLATIZER) {
-# print "~$char~ ";
- }
- push(@word, $char);
- if (grep(!/\w/, $char)) {
- # don't split yet if it's a possible template char.
- if (grep(!/[<>]/, $char)) {
- local($real_word) = join("", @word);
- if ($DEBUG_TEMPLATIZER) {
-# print "adding a word $real_word\n";
- }
- push(@template_buffer, "$real_word");
- @word = ();
- }
- }
- }
-}
-
-#
-# this goes through the buffer and replaces all occurrences of the name to
-# replace with the instance name.
-#
-sub replace_place_holder {
- @new_template_buffer = @template_buffer;
- @template_buffer = ();
-
- foreach $i (0 .. $#new_template_buffer) {
- $word = $new_template_buffer[$i];
-# if ($DEBUG_TEMPLATIZER) {
-# print "<$i $word> ";
-# $old = $word;
-# }
-
- # replace a templated combination with the mangled version.
- $word =~ s/^${object_name}<${instance_type}>/${mangled_name}/;
-
-# if ($DEBUG_TEMPLATIZER) {
-# if ($old ne $word) {print "1 ... changed to $word.\n"; $old = $word; }
-# }
-
- if (grep(/^\w+<\w+>/, $word)) {
- # replace some other template with our stuff if we can.
- $word = &special_mangle($word);
- }
-
-# if ($DEBUG_TEMPLATIZER) {
-# if ($old ne $word) {print "2 ... changed to $word.\n"; $old = $word; }
-# }
-
- # replace the object's name with its mangled form.
- $word =~ s/^${object_name}/${mangled_name}/;
-
-# if ($DEBUG_TEMPLATIZER) {
-# if ($old ne $word) {print "3... changed to $word.\n"; $old = $word; }
-# }
-
- # replace the place holder with the instantiation type.
- $word =~ s/^${place_holder}/${instance_type}/;
-
-# if ($DEBUG_TEMPLATIZER) {
-# if ($old ne $word) {print "4... changed to $word.\n"; $old = $word; }
-# }
-
- push(@template_buffer, $word);
- }
-}
-
-#
-# processes a general template usage, in the form X<Y>, where either
-# X or Y are not ones that we think we need to replace. it is assumed
-# that it's safe to use the mangled form of the template.
-#
-sub special_mangle {
- local($word) = @_[0];
- # split the template form into pieces.
- local(@pieces) = split(/[<>]/, $word, 2);
-
- $pieces[1] =~ s/${place_holder}/${instance_type}/;
- $pieces[1] =~ s/>//;
- # hold onto the real instance type.
- local($hold_instance) = $instance_type;
- $instance_type = $pieces[1];
- # mangle the name in the template usage line.
- local($hold_mangled) = &mangle_name($pieces[0]);
- # restore the original instance type.
- $instance_type = $hold_instance;
- # returns the new mangled form.
- $hold_mangled;
-}
-
-#
-# prints out the buffer we've accumulated to the output file.
-#
-sub dump_the_buffer {
- print OUTPUT_FILE @template_buffer;
-}
-
-#
-# processes a class declaration and sets the object name for future use.
-#
-sub match_class_declaration {
- local($next_line) = @_[0];
-# too strict!
-# if (grep(!/class\s.*\w+$/, $next_line)
-# && grep(!/class\s.*\w+\s*\{/, $next_line)
-# && grep(!/struct\s.*\w+$/, $next_line)
-# && grep(!/struct\s.*\w+\s*\{/, $next_line)) {
-# return 0;
-# }
-
- if (grep(!/class\s+\w+/, $next_line) && grep(!/struct\s+\w+/, $next_line) ) {
- return 0;
- }
-
- if ($DEBUG_TEMPLATIZER) {
-# print "matched class decl in $next_line\n";
- }
-
- if (grep(/class\s+\w+.*:/, $next_line)
- || grep(/struct\s+\w+.*:/, $next_line)) {
- # parses an inheriting class decl.
- if ($DEBUG_TEMPLATIZER) {
-# print "in inheritance case on $next_line\n";
- }
- local(@pieces) = split(/:/, $next_line, 2);
- # push the rest of the line back into the input array.
- if ($DEBUG_TEMPLATIZER) {
-# print "going to unshift $pieces[1]...\n";
- }
- unshift(@file_array, ": ".$pieces[1]." ");
- $next_line = $pieces[0];
- } elsif (grep(/class\s.*\w+\s*\{/, $next_line)
- || grep(/struct\s.*\w+\s*\{/, $next_line)) {
- # parses a non-inheriting declaration with bracket on same line.
- if ($DEBUG_TEMPLATIZER) {
-# print "in special case on $next_line\n";
- }
- # special case for continued stuff on same line.
- local(@pieces) = split(/{/, $next_line, 2);
- # push the rest of the line back into the input array.
- unshift(@file_array, " { ".$pieces[1]." ");
- $next_line = $pieces[0];
- }
- if ($DEBUG_TEMPLATIZER) {
-# print "matched class declaration... $next_line\n";
- }
- local(@pieces) = split(/\s/, $next_line);
- $object_name = $pieces[$#pieces];
- $mangled_name = &mangle_name($object_name);
- foreach $posn (0 .. $#pieces - 1) { print OUTPUT_FILE "$pieces[$posn] "; }
- print OUTPUT_FILE "$mangled_name\n";
- 1;
-}
-
-#
-# processes the implementation of a class member and sets the object
-# name for future use.
-#
-sub match_class_member_definition {
- local($next_line) = @_[0];
- local($junk);
- if (grep(!/\w+<\w+>::/, $next_line)) {
- return 0;
- }
- if ($DEBUG_TEMPLATIZER) {
-# print "matched class member definition... $next_line\n";
- }
- local(@pieces) = split(/>::/, $next_line, 2);
- # checks for spaces in the first part of the split. if there is one,
- # it means we don't have a simple object thing.
- if (grep(/\s/, $pieces[0])) {
- if ($DEBUG_TEMPLATIZER) {
-# print "matched a space in the first part of supposed object name... $pieces[0]\n";
- }
- if (grep(/^\w+<\w+>/, $pieces[0])) {
- if ($DEBUG_TEMPLATIZER) {
-# print "matched a template usage in first part of name...";
- }
- # replace some other template with our stuff if we can.
- $pieces[0] = &special_mangle($pieces[0]);
- }
- if ($DEBUG_TEMPLATIZER) {
-# print "now our first bit is: $pieces[0]\n";
- }
- local(@new_pieces) = split(/ /, $pieces[0]);
- $pieces[0] = $new_pieces[$#new_pieces];
- foreach $posn (0 .. $#new_pieces - 1) {
- $new_pieces[$posn] =~ s/${place_holder}/${instance_type}/g;
- print OUTPUT_FILE "$new_pieces[$posn] ";
- }
- }
- unshift(@file_array, "::\n".$pieces[1]."\n");
- $object_name = $pieces[0];
- $object_name =~ s/(\W*)(\w+)<(\w+)/\2/;
- if (length($1)) { print OUTPUT_FILE "$1"; }
- if ($3 ne $place_holder) {
- die("The placeholder does not match on this line: $next_line");
- }
- $mangled_name = &mangle_name($object_name);
- print OUTPUT_FILE "$mangled_name\n";
- 1; # return success.
-}
-
-#
-# processes a function template by making sure it fits the format and
-# then setting up the variables for the replacement. since function templates
-# are so simple, the object name is not changed; only the place_holder is
-# changed to the instance type.
-#
-sub match_function_definition {
- local($next_line) = @_[0];
-
- if (grep(!/^\s*\w+\s+.*/, $next_line) ) {
- if ($DEBUG_TEMPLATIZER) {
- print "failed on funcdef for ", $next_line, "!\n";
- }
- return 0;
- }
-
-# old broken code:...
-# if (grep(!/^\s*\w+\s+.*\(.*\)\s*/, $next_line) ) {
-#print "failed on funcdef for ", $next_line, "!\n";
-# return 0;
-# }
-
-# if ($DEBUG_TEMPLATIZER) {
-# print "matched function definition on $next_line\n";
-# }
-
-# if ($DEBUG_TEMPLATIZER) {
-# print "stuffing back into the file array $next_line.\n";
-# }
- # put the line back because it's nearly right for being instantiated.
- unshift(@file_array, "inline ".$next_line."\n");
- # come up with a very rare name that will not be matched in the text.
- $object_name = "hogga_wogga_nunky_budget_weeny_teeny_kahini_beany";
- $mangled_name = &mangle_name($object_name);
- 1; # return a success.
-}
+++ /dev/null
-
-
-:top
-start "eep" "%0"
-start "op" "%0"
-
-goto :top
+++ /dev/null
-#!/bin/bash
-
-while true; do
- $0 &
- $0 &
-done
-
+++ /dev/null
-sudo ufw deny from ${ip_address} to any
+++ /dev/null
-#!/bin/sh
-# an example of using the reg.exe tool on windows to find some things in
-# the registry.
-# this happens to look in the registry for PuTTY keys for a set of named
-# displays.
-
-declare ip_array=(zorba-1 zorba-2 zorba-3 zorba-4 zorba-5)
-
-for i in ${ip_array[*]}; do
- target=${i}
- echo "display is $target"
- reg query 'HKCU\Software\SimonTatham\PuTTY\SshHostKeys' /v "rsa2@22:$target"
-done
-
-
+++ /dev/null
-#!/bin/bash
-
-# this script modifies the linux kernel for maximum tcp buffer size, which can
-# improve long-haul transfers over a wan.
-
-# new maximum buffer size to set.
-new_max=4194304
-
-echo "net.core.wmem_max=$new_max" >> /etc/sysctl.conf
-echo "net.core.rmem_max=$new_max" >> /etc/sysctl.conf
-
-echo "net.ipv4.tcp_rmem= 10240 87380 $new_max" >> /etc/sysctl.conf
-echo "net.ipv4.tcp_wmem= 10240 87380 $new_max" >> /etc/sysctl.conf
-
-echo "net.ipv4.tcp_window_scaling = 1" >> /etc/sysctl.conf
-
-echo "net.ipv4.tcp_timestamps = 1" >> /etc/sysctl.conf
-
-echo "net.ipv4.tcp_sack = 1" >> /etc/sysctl.conf
-
-echo "net.ipv4.tcp_no_metrics_save = 1" >> /etc/sysctl.conf
-
-echo "net.core.netdev_max_backlog = 5000" >> /etc/sysctl.conf
-
+++ /dev/null
-
-# if this script is run as sudo, then at some point it may be useful to become another
-# user, in order to run something from within their context. this is one way to do it
-# with a semi-interactive set of steps...
-sudo -u chronical bash <<eof
-echo hello this is \$USER
-echo we be in \$(pwd)
-echo "where you at?"
-eof
-
-# this can also be done by running a script with all those commands in it.
-sudo -u chronical bash /home/chronical/thing_to_run_as_chronical.sh
-
+++ /dev/null
-
-# define an array.
-@fred = ('x', 'y', 'z');
-
-# define a hash.
-%fred = (x => 'farfle', q => 'nuggy', r => 'bunko');
-
-# show the array.
-print "\@fred is: @fred\n";
-# show the first element of the array.
-print "\$fred[0] is $fred[0]\n";
-
-# show the details of the hash.
-@fredkeys = keys(%fred);
-print "\%fred keys are: @fredkeys\n";
-@fredvals = values(%fred);
-print "\%fred values are: @fredvals\n";
-# show the value for the first key we defined in the hash (although that's incidental;
-# we don't expect to access things in the hash by their order of addition or even by
-# numerical indexes at all.
-print "\$fred['x'] is $fred{'x'}\n";
+++ /dev/null
-This is the feisty meow examples folder. It has the following folders...
-
-bashisms/
- A few examples of techniques in bash. Handy to keep track of these.
-
-legacy/
- Examples of quixotic attempts at whatever in the past. One example is an
- aged attempt to add C++ template features to a C++ compiler that did not
- already have them. It was never completely finished.
-
-os_related/
- Both frivolous and serious scripts related to a particular operating system.
- Do *NOT* run the OS_crusher scripts unless you are in complete control of
- the system in question, and do not like that computer system very much,
- as they may likely take it down.
-
-perlisms/
- Examples of techniques using the perl scripting language.
+++ /dev/null
-
-when the feisty meow environment is loaded, these handy
-commands become available for ripping content from dvds
-and for burning content to dvds and blurays.
-
-===
-
-# rips the dvd off of the current dvd drive. this produces the ripped copy
-# in a folder named after the dvd.
-dvd_rip
-
-# makes an ISO image from a ripped dvd folder. the ISO can then be burned
-# to a disc using k3b or other tools.
-dvd_image walnuts.iso WALNUTS_MOVIE
-
-# create an ISO image from a set of files.
-blu_image farples.iso directoryToEnshrine
-
-# burn an ISO image onto a bluray drive.
-blu_burn farples.iso /dev/sr1
-
# almost nothing from the user's environment. this folder needs to be updated
# for your own particular install location.
FEISTY_MEOW_APEX=/opt/feistymeow.org/feisty_meow
-#FEISTY_MEOW_APEX=$HOME/feisty_meow
# crontab miniature docs:
#
--- /dev/null
+
+# snippet of code to set all the temp folders and genesis2 state dir on a stable local
+# temporary directory. do not use /localtmp if it will be deleted! this stuff is
+# expected to persist until the user decides to clean things up.
+
+# use a local temporary directory if possible.
+if [ -d /localtmp ]; then
+ export FAST_LOCAL_STORAGE=/localtmp/$USER
+ export TMP=$FAST_LOCAL_STORAGE/tempo
+ mkdir -p $TMP &>/dev/null
+ chmod -R 700 $FAST_LOCAL_STORAGE
+
+ # plan on putting the state directory onto there.
+ export GENII_USER_DIR=$FAST_LOCAL_STORAGE/state-dir
+fi
+
+# after the above, load feisty meow scripts and they will take advantage of the
+# TMP folder we set above.
+
--- /dev/null
+
+
+#taking a comma (or any char) separated list and turning it into an array:
+
+commaSeparatedList=tony,tiger,detroit,sugar,biscuits
+
+IFS="," read -ra argArray <<< "$commaSeparatedList"
+
+for ((i = 0; i < ${#argArray[@]}; i++)); do
+ echo "arg $(($i + 1)): ${argArray[$i]}"
+done
+
--- /dev/null
+# runs the nechung oracle program at exit from bash.
+
+sep 79
+$FEISTY_MEOW_GENERATED_STORE/runtime/binaries/nechung
+echo
+
--- /dev/null
+
+# shell option parsing -- old school version only handles single dash options.
+
+while getopts "fr:q:a:h" opt; do
+ case "${opt}" in
+ f) force_query=1; ;;
+ r) row_num="${OPTARG}"; ;;
+ q) queue_name="${OPTARG}"; ;;
+ a) alias_name="${OPTARG}"; ;;
+ h) usage 1>&2; exit ${EX_OK}; ;;
+ ?) usage 1>&2; exit ${EX_USAGE}; ;;
+ esac
+done
+
+shift $(($OPTIND - 1))
+
--- /dev/null
+#!/bin/bash
+
+##############
+# Name : fred_techniques
+# Author : Chris Koeritz
+# Rights : Copyright (C) 2010-$now by Author
+##############
+# Copyright (c) 2010-$now By Author. This script is free software; you can
+# redistribute it and/or modify it under the terms of the simplified BSD
+# license. See: http://www.opensource.org/licenses/bsd-license.php
+# Please send updates for this code to: fred@gruntose.com -- Thanks, fred.
+##############
+
+# this script is a collection of helpful bash practices that unfortunately
+# sometimes slip my mind when i need them. it's intended to collect all the
+# good bits so they don't slip away. feel free to re-use them in your own
+# code as needed.
+
+##############
+
+# clean for loops in bash:
+
+for ((i=0; i < 5; i++)) do
+ echo $i
+done
+
+##############
+
+# removing an array element
+# --> only works on arrays that have no elements containing a space character.
+
+# define a 5 element array.
+arr=(a b c d e)
+
+# remove element 2 (the 'c').
+removepoint=2
+
+# set the array to slices of itself.
+arr=(${arr[*]:0:$removepoint} ${arr[*]:(($removepoint+1))} )
+
+# show the new contents.
+echo ${arr[*]}
+# shows: a b d e
+
+##############
+
+# store to a variable name by derefercing it.
+
+# shows how you can store into a variable when you are given only its name.
+function store_to_named_var()
+{
+ local name="$1"; shift
+ eval ${name}=\(gorbachev "perestroikanator 12000" chernenko\)
+}
+
+declare -a ted=(petunia "butter cup" smorgasbord)
+echo ted is ${ted[@]}
+store_to_named_var ted
+echo ted is now ${ted[@]}
+
+##############
+
--- /dev/null
+
+
+# when the array elements have spaces, it is still possible to get them back right.
+
+
+a=("ted row" "boon" "moopy dongle")
+echo ${#a[@]}
+# 3
+borg=( "${a[@]}" )
+echo ${#borg[@]}
+# 3
+
+# normally the setting of borg would not preserve the elements with spaces in them as separate.
+# but by using the @ to get all the array members and the spaces around the reference, you get
+# the list back properly.
+
--- /dev/null
+#!/bin/bash
+
+#
+# these great examples of handy unix tidbits were donated by "q. black".
+#
+
+# list a directory tree
+ls -R | grep ":$" | sed -e 's/:$//' -e 's/[^-][^\/]*\//--/g' -e 's/^/ /' -e 's/-/|/'
+
+# list directory sizes (biggest first)
+du -h $(du -s * |sort -nr|awk '{print $2}')
+
+# this will sort a date field of the form: DD-MON-YYYY HH:MM:SS
+sort +0.7 -1 +0.3M -0.6 +0 -0.2 +1
+
+# this will sort a date field of the form: MON DD HH:MM:SS YYYY
+sort +3 -4 +0M +1n
+
+# this will sort a date field of the form: MON DD HH:MM:SS
+sort +0M +1n
+
+# this will sort a date field of the form: Date: Tue Feb 3 09:17:58 EST 2004
+sort +6 -7 +2M +3n +4
+
+# display all lines from a certain line onward
+start_line=132
+|awk "{if (NR >= ${start_line}){print \$0}}"
+
+# display all lines after a token
+sed '1,/CUT HERE/d'
+
+# print the first and last lines
+sed -n '1,1p;$,$p'
+
+# signal bash about a window size change
+kill -winch $$
+
+# show the date 1 year, 2 months and 3 days ago
+date -v -1y -v -2m -v -3d
+
+# set the date back 1 year
+sudo date $(date -v -1y +%Y%m%d%H%M)
+
+# output the standard date format for setting the time
+# get the date
+date -u +%Y%m%d%H%M.%S
+# set the date
+date -u (cut and paste from above)
+
+# convert one date format to another (output is in the current time zone)
+old_date="Aug 27 15:24:33 2005 GMT"
+new_date=$(date -j -f "%b %e %T %Y %Z" "${old_date}" +%D)
+echo ${new_date}
+# returns "08/27/05"
+
+# output the modification time of a file in different format
+file=
+date -j -f "%b %e %T %Y" "$(ls -lT ${file} |awk '{print $6,$7,$8,$9}')"
+
+# output the number of days until a certain date
+target_date="Sep 2 15:20:20 2005 GMT"
+target_seconds=$(date -j -f "%b %e %T %Y" +%s "${target_date}" 2>/dev/null)
+diff_seconds=$(expr ${target_seconds} - $(date +%s))
+diff_days=$(expr ${diff_seconds} / 86400)
+echo "${diff_days} day(s)"
+
+# these commands can be used to fill in missing times in a "uniq -c" count
+# of times.
+# output 24 hours in one minute increments
+for h in $(jot -w %02d - 0 23 1); do
+ for m in $(jot -w %02d - 0 59 1); do
+ echo " 0 ${h}:${m}"
+ done
+done
+# sort them together, and remove any 0 counts if an count already exists
+sort +1 +0rn out1 out2 |uniq -f 1
+
+# output with w3m to get basic html word wrap
+w3m -T "text/html" -dump -cols 72 <<EOF
+ <p>
+ This test verifies basic networking and that the ${product_short_name}
+ can reach it's default gateway.
+EOF
+
+# another way to format text for output
+fmt 72 <<EOF
+This test verifies basic networking and that the ${product_short_name}
+can reach it's default gateway.
+EOF
+
+# smtpcrypt "printf"
+{
+char *jkwbuf = NULL;
+asprintf(&jkwbuf, "JKW: msg->used = %ld\n", msg->used);
+BIO_write(sc->log, jkwbuf, strlen(jkwbuf)+1);
+free(jkwbuf);
+}
+
+# rolling diff of a list of files (diff a & b, then b & c,...)
+last=
+for i in $(ls -1rt); do
+ if [ ! -z "${last}" ]; then
+ diff -u ${last} ${i}
+ fi
+ last=${i}
+done
+
+# clearing and restoring chflags
+file=
+old_chflags=$(ls -lo ${file}|awk '{print $5}')
+chflags 0 ${file}
+# do whatever
+if [ ."${old_chflags}" != ."-" ]; then
+ chflags ${old_chflags} ${file}
+fi
+
+# way to do standard edits to files
+file=
+{
+ # append line(s) after a line, "i" to insert before
+ echo '/www_recovery/a'
+ echo 'mithril ALL = (root) NOPASSWD: /usr/local/libexec/destroyer'
+ echo '.'
+ # modify a line
+ echo 'g/^xntpd_program=/s,^xntpd_program=.*$,xntpd_program="ntpd",'
+ # delete a line
+ echo 'g/^controls key secret =/d'
+ echo 'x!'
+} | ex - ${file}
+
+# how to search for errors in the last 24 hours
+# note that this command does not work quite right. The sort is off early
+# in the year because the dates do not have the year.
+# Also sed never sees the /CUT HERE/ when it is the first line.
+(echo "$(date -v-24H "+%b %e %H:%M:%S") --CUT HERE--"; \
+ zgrep -h "cookie" /var/log/messages*)|sort +0M| \
+ sed '1,/CUT HERE/d'
+# This version fixes those problems. It adds the file year to the date
+# and puts a marker at the start of the list.
+(echo "$(date -j -f "%s" 0 "+%Y %b %e %H:%M:%S") --ALWAYS FIRST--"; \
+ echo "$(date -v-24H "+%Y %b %e %H:%M:%S") --CUT HERE--"; \
+ for i in /var/log/messages*; do
+ year=$(ls -lT ${i}|awk '{print $9}')
+ zgrep -h "cookie" ${i}|while read line; do
+ echo "${year} ${line}"
+ done
+ done)|sort +0n +1M| sed '1,/CUT HERE/d'
+
+# process a list of quoted values
+{
+ # It tends to be easiest to use a 'here-document' to feed in the list.
+ # I prefer to have the list at the start instead of the end
+ cat <<EOF
+ 'general' 'network node0' 'private address'
+ 'general' 'options node2' 'kern securelevel'
+EOF
+}| while read line; do
+ eval set -- ${line}
+ config=$1; shift
+ section=$1; shift
+ key=$1; shift
+
+ echo "confutil value \"${config}\" \"${section}\" \"${key}\""
+done
+
+# Method to read lines with a "for" loop, without spawning a subshell
+NEWLINE='
+'
+OIFS="${IFS}"
+IFS="${NEWLINE}"
+for line in $(cat /etc/passwd | sort -r); do
+ IFS="${OIFS}"
+
+ # do whatever you want here
+ echo "line = ${line}"
+
+ IFS="${NEWLINE}"
+done
+IFS="${OIFS}"
+
+# generate a histogram of characters in a file
+cat file|
+ awk '{for (i=1; i <= length($0); i++) {printf("%s\n",substr($0,i,1))}}'|
+ sort|uniq -c
+
+# show line lengths for a file
+cat file| awk '{print length($0)}'| sort -n
+
+
+
+
+# get the modification time of a directory or file and then reset the time.
+target=/usr/local/etc/pkdb
+save_date=$(ls -ldT ${target}|awk '{print $6,$7,$8,$9}')
+save_date=$(date -j -f "%b %e %T %Y" "${save_date}" +"%Y%m%d%H%M.%S")
+# later
+touch -t ${save_date} ${target}
+
+
+# detect NULL bytes in a file
+file=
+hexdump -e '"%_u\n"' ${file}|grep -q '^nul$'
+if [ $? -eq 0 ]; then
+else
+fi
+
+
+# calculate average
+cd /tmp
+uudecode
+begin 644 bc.average
+M<V-A;&4],PIT;W1A;#TP"F-O=6YT/3`*=VAI;&4@*#$I('L*("`@(&YU;2`]
+M(')E860H*0H@("`@:68@*&YU;2`]/2`P*2!B<F5A:SL*("`@(&-O=6YT*RL*
+M("`@('1O=&%L("L](&YU;0I]"B)T;W1A;"`]("([('1O=&%L"B)C;W5N="`]
+K("([(&-O=6YT"B)A=F5R86=E(#T@(CL@=&]T86P@+R!C;W5N=`IQ=6ET"@``
+`
+end
+(cat data; echo "0") |bc -q bc.average
+
+
--- /dev/null
+
+# find out the location where this script is running from. this will not
+# work properly in a bash script that is included via 'source' or '.'.
+# the first letter of each command is escaped to eliminate the danger of
+# personal aliases or functions disrupting the results.
+ORIGINATING_FOLDER="$( \cd "$(\dirname "$0")" && /bin/pwd )"
+
+# another slightly tighter version:
+export WORKDIR="$( \cd "$(\dirname "$0")" && \pwd )" # obtain the script's working directory.
+
--- /dev/null
+
+"c:/Program Files (x86)/Microsoft Visual Studio 10.0/Common7/Tools/vsvars32.bat"
--- /dev/null
+//
+// Title: C++ Grammar Lexer support compilation unit.
+//
+// File Name: CxxLexer.cpp
+//
+// Author: E.D.Willink
+//END
+//
+#include <CxxLexer.cxx>
--- /dev/null
+/*
+ * Title: Miniature lexer for C++ parser.
+ *
+ * File Name: CxxLexer.l
+ *
+ * Author: E.D.Willink
+ *
+ * This is a complete lexer for C++, intended for use with CxxParser.y.
+ * All actions are done by macros, so that there is some chance that customisation
+ * can be performed within the bounds of the CxxLexing.hxx and CxxLexing.cxx
+ * include files.
+ *END
+ */
+%{
+#include <CxxLexing.hxx>
+%}
+%a 5000
+%e 1500
+%n 1000
+%o 10000
+%p 10000
+ws [ \f\v\t]
+
+digit [0-9]
+hex [0-9A-Fa-f]
+letter [A-Z_a-z]
+simple_escape_sequence (\\\'|\\\"|\\\?|\\\\|\\a|\\b|\\f|\\n|\\r|\\t|\\v)
+octal_escape_sequence (\\[0-7]|\\[0-7][0-7]|\\[0-7][0-7][0-7])
+hexadecimal_escape_sequence (\\x{hex}+)
+escape_sequence ({simple_escape_sequence}|{octal_escape_sequence}|{hexadecimal_escape_sequence})
+universal_character_name (\\u{hex}{hex}{hex}{hex}|\\U{hex}{hex}{hex}{hex}{hex}{hex}{hex}{hex})
+non_digit ({letter}|{universal_character_name})
+identifier ({non_digit}({non_digit}|{digit})*)
+
+character_lit (L?\'([^\'\\\n]|\\.)*)
+character_literal ({character_lit}\')
+
+string_lit (L?\"([^\"\\\n]|\\.)*)
+string_literal ({string_lit}\")
+
+pp_number (\.?{digit}({digit}|{non_digit}|[eE][-+]|\.)*)
+%%
+^.*\n { LEX_SAVE_LINE(yytext, yyleng); REJECT; }
+^{ws}*"#".* { /* Throw away preprocessor lines - hopefully only #line and equivalent. */ }
+
+{character_lit}\' { LEX_CHARACTER_TOKEN(yytext, yyleng-1); };
+{character_lit}\\ { ERRMSG("End of line assumed to terminate character with trailing escape.");
+ LEX_CHARACTER_TOKEN(yytext, yyleng-1); };
+{character_lit} { ERRMSG("End of line assumed to terminate character.");
+ LEX_CHARACTER_TOKEN(yytext, yyleng); };
+
+{string_lit}\" { LEX_STRING_TOKEN(yytext, yyleng-1); };
+{string_lit}\\ { ERRMSG("End of line assumed to terminate string with trailing escape.");
+ LEX_STRING_TOKEN(yytext, yyleng-1); };
+{string_lit} { ERRMSG("End of line assumed to terminate string.");
+ LEX_STRING_TOKEN(yytext, yyleng); };
+
+"asm" { LEX_STATIC_TOKEN(ASM); }
+"auto" { LEX_STATIC_TOKEN(AUTO); }
+"bool" { LEX_C_STATIC_TOKEN(BOOL); }
+"break" { LEX_STATIC_TOKEN(BREAK); }
+"case" { LEX_STATIC_TOKEN(CASE); }
+"catch" { LEX_C_STATIC_TOKEN(CATCH); }
+"char" { LEX_STATIC_TOKEN(CHAR); }
+"class" { LEX_C_STATIC_TOKEN(CLASS); }
+"const" { LEX_STATIC_TOKEN(CONST); }
+"const_cast" { LEX_C_STATIC_TOKEN(CONST_CAST); }
+"continue" { LEX_STATIC_TOKEN(CONTINUE); }
+"default" { LEX_STATIC_TOKEN(DEFAULT); }
+"delete" { LEX_C_STATIC_TOKEN(DELETE); }
+"do" { LEX_STATIC_TOKEN(DO); }
+"double" { LEX_STATIC_TOKEN(DOUBLE); }
+"dynamic_cast" { LEX_C_STATIC_TOKEN(DYNAMIC_CAST); }
+"else" { LEX_STATIC_TOKEN(ELSE); }
+"enum" { LEX_STATIC_TOKEN(ENUM); }
+"explicit" { LEX_C_STATIC_TOKEN(EXPLICIT); }
+"export" { LEX_C_STATIC_TOKEN(EXPORT); }
+"extern" { LEX_STATIC_TOKEN(EXTERN); }
+"false" { LEX_C_STATIC_TOKEN(FALSE); }
+"float" { LEX_STATIC_TOKEN(FLOAT); }
+"for" { LEX_STATIC_TOKEN(FOR); }
+"friend" { LEX_STATIC_TOKEN(FRIEND); }
+"goto" { LEX_STATIC_TOKEN(GOTO); }
+"if" { LEX_STATIC_TOKEN(IF); }
+"inline" { LEX_C_STATIC_TOKEN(INLINE); }
+"int" { LEX_STATIC_TOKEN(INT); }
+"long" { LEX_STATIC_TOKEN(LONG); }
+"mutable" { LEX_C_STATIC_TOKEN(MUTABLE); }
+"namespace" { LEX_C_STATIC_TOKEN(NAMESPACE); }
+"new" { LEX_C_STATIC_TOKEN(NEW); }
+"operator" { LEX_C_STATIC_TOKEN(OPERATOR); }
+"private" { LEX_C_STATIC_TOKEN(PRIVATE); }
+"protected" { LEX_C_STATIC_TOKEN(PROTECTED); }
+"public" { LEX_C_STATIC_TOKEN(PUBLIC); }
+"register" { LEX_STATIC_TOKEN(REGISTER); }
+"reinterpret_cast" { LEX_C_STATIC_TOKEN(REINTERPRET_CAST); }
+"return" { LEX_STATIC_TOKEN(RETURN); }
+"short" { LEX_STATIC_TOKEN(SHORT); }
+"signed" { LEX_C_STATIC_TOKEN(SIGNED); }
+"sizeof" { LEX_STATIC_TOKEN(SIZEOF); }
+"static" { LEX_STATIC_TOKEN(STATIC); }
+"static_cast" { LEX_C_STATIC_TOKEN(STATIC_CAST); }
+"struct" { LEX_STATIC_TOKEN(STRUCT); }
+"switch" { LEX_STATIC_TOKEN(SWITCH); }
+"template" { LEX_C_STATIC_TOKEN(TEMPLATE); }
+"this" { LEX_C_STATIC_TOKEN(THIS); }
+"throw" { LEX_C_STATIC_TOKEN(THROW); }
+"true" { LEX_C_STATIC_TOKEN(TRUE); }
+"try" { LEX_C_STATIC_TOKEN(TRY); }
+"typedef" { LEX_STATIC_TOKEN(TYPEDEF); }
+"typeid" { LEX_C_STATIC_TOKEN(TYPEID); }
+"typename" { LEX_C_STATIC_TOKEN(TYPENAME); }
+"union" { LEX_STATIC_TOKEN(UNION); }
+"unsigned" { LEX_STATIC_TOKEN(UNSIGNED); }
+"using" { LEX_C_STATIC_TOKEN(USING); }
+"virtual" { LEX_STATIC_TOKEN(VIRTUAL); }
+"void" { LEX_STATIC_TOKEN(VOID); }
+"volatile" { LEX_STATIC_TOKEN(VOLATILE); }
+"wchar_t" { LEX_C_STATIC_TOKEN(WCHAR_T); }
+"while" { LEX_STATIC_TOKEN(WHILE); }
+
+"::" { LEX_C_STATIC_TOKEN(SCOPE); }
+"..." { LEX_STATIC_TOKEN(ELLIPSIS); }
+"<<" { LEX_STATIC_TOKEN(SHL); }
+">>" { LEX_STATIC_TOKEN(SHR); }
+"==" { LEX_STATIC_TOKEN(EQ); }
+"!=" { LEX_STATIC_TOKEN(NE); }
+"<=" { LEX_STATIC_TOKEN(LE); }
+">=" { LEX_STATIC_TOKEN(GE); }
+"&&" { LEX_STATIC_TOKEN(LOG_AND); }
+"||" { LEX_STATIC_TOKEN(LOG_OR); }
+"++" { LEX_STATIC_TOKEN(INC); }
+"--" { LEX_STATIC_TOKEN(DEC); }
+"->*" { LEX_STATIC_TOKEN(ARROW_STAR); }
+"->" { LEX_STATIC_TOKEN(ARROW); }
+".*" { LEX_STATIC_TOKEN(DOT_STAR); }
+"+=" { LEX_STATIC_TOKEN(ASS_ADD); }
+"-=" { LEX_STATIC_TOKEN(ASS_SUB); }
+"*=" { LEX_STATIC_TOKEN(ASS_MUL); }
+"/=" { LEX_STATIC_TOKEN(ASS_DIV); }
+"%=" { LEX_STATIC_TOKEN(ASS_MOD); }
+"^=" { LEX_STATIC_TOKEN(ASS_XOR); }
+"&=" { LEX_STATIC_TOKEN(ASS_AND); }
+"|=" { LEX_STATIC_TOKEN(ASS_OR); }
+">>=" { LEX_STATIC_TOKEN(ASS_SHR); }
+"<<=" { LEX_STATIC_TOKEN(ASS_SHL); }
+
+{pp_number} { LEX_NUMBER_TOKEN(yytext, yyleng); }
+
+{identifier} { LEX_IDENTIFIER_TOKEN(yytext, yyleng); }
+
+{escape_sequence} |
+{universal_character_name} { LEX_ESCAPED_TOKEN(yytext, yyleng); }
+
+\n |
+{ws}+ { /* Throw away whitespace */ }
+. { LEX_ASCII_TOKEN(yytext[0]); }
+
+%%
+#include <CxxLexing.cxx>
--- /dev/null
+#ifdef FLEX_PP_CLASS
+FLEX_PP_CLASS theLexer;
+#define LEX_DOT theLexer .
+#else
+#define LEX_DOT
+#endif
+
+bool c_keywords = false;
+bool echo_line_numbers = false;
+bool echo_line_text = false;
+size_t line_number = 0;
+
+#ifdef NEEDS_YYWRAP
+int yywrap() { return 1; }
+#endif
+
+CxxToken *yylex_token()
+{
+ if (!LEX_DOT yylex())
+ return 0;
+ return yyToken;
+}
+
+//
+// Configure the lexer to reflect successful parsing of a character value, assigning it to yylval.
+//
+// The source someText[aLength] should correspond to the parsed text including any L or ' prefix
+// but excluding any ' suffix. In this way the return can indicate whether a wide character has
+// been detected and the routine can accommodate a variety of erroneous terminations.
+//
+CxxToken *make_character(const char *someText, size_t aLength)
+{
+ bool isWide = false;
+ if (someText && aLength)
+ {
+ if (*someText == 'L')
+ {
+ isWide = true;
+ someText++;
+ aLength--;
+ }
+ if (!aLength || (*someText != '\''))
+ ERRMSG("BUG - bad start of character literal.");
+ if (aLength)
+ {
+ someText++;
+ aLength--;
+ }
+ }
+ if (isWide)
+ return make_wide_character(someText, aLength);
+ else
+ return make_narrow_character(someText, aLength);
+}
+
+CxxToken *make_identifier(const char *someText, size_t aLength)
+{
+ return new CxxNaffToken(PARSE_TOKEN(Identifier), someText, aLength);
+}
+
+//
+// Buffer the incoming line, before any characters are analysed.
+//
+void make_line(const char *yyText, size_t yyLeng)
+{
+ if (echo_line_text)
+ cout << tokenMarkDepth << ": " << line_number << ": " << yyText << flush;
+ else if (echo_line_numbers)
+ cout << line_number << endl;
+ line_number++ ;
+}
+
+CxxToken *make_literal_character(const char *someText, size_t aLength)
+{
+ return new CxxNaffToken(PARSE_TOKEN(CharacterLiteral), someText, aLength);
+}
+
+CxxToken *make_narrow_character(const char *someText, size_t aLength)
+{
+ return new CxxNaffToken(PARSE_TOKEN(CharacterLiteral), someText, aLength);
+}
+
+CxxToken *make_narrow_string(const char *someText, size_t aLength)
+{
+ return new CxxNaffToken(PARSE_TOKEN(StringLiteral), someText, aLength);
+}
+
+CxxToken *make_number(const char *someText, size_t aLength)
+{
+ return new CxxNaffToken(PARSE_TOKEN(IntegerLiteral), someText, aLength);
+}
+
+//
+// Configure the lexer to reflect successful parsing of a categorised string.
+//
+// The source someText[aLength] should correspond to the parsed text including any
+// L or " prefix but excluding any " suffix. In this way the return can indicate whether a wide
+// character has been detected and the routine can accommodate a variety of erroneous terminations.
+//
+CxxToken *make_string(const char *someText, size_t aLength)
+{
+ bool isWide = false;
+ if (someText && aLength)
+ {
+ if (*someText == 'L')
+ {
+ isWide = true;
+ someText++;
+ aLength--;
+ }
+ if (!aLength || (*someText != '"'))
+ ERRMSG("BUG - bad start of string literal.");
+ if (aLength)
+ {
+ someText++;
+ aLength--;
+ }
+ }
+ if (isWide)
+ return make_wide_string(someText, aLength);
+ else
+ return make_narrow_string(someText, aLength);
+}
+
+//
+// Return the appropriate 1 of 256 flyweight tokens for the ASCII characters.
+//
+CxxToken *make_token(size_t tokenValue)
+{
+ static CxxToken *asciiTokens[256];
+ if (tokenValue >= (sizeof(asciiTokens)/sizeof(asciiTokens[0])))
+ {
+ ERRMSG("Cannot make_token for " << tokenValue);
+ return 0;
+ }
+ CxxToken **p = &asciiTokens[tokenValue];
+ CxxToken *theToken = *p;
+ if (!theToken)
+ *p = theToken = new CxxToken(tokenValue);
+ return theToken;
+}
+
+CxxToken *make_wide_character(const char *someText, size_t aLength)
+{
+ return new CxxNaffToken(PARSE_TOKEN(CharacterLiteral), someText, aLength);
+}
+
+CxxToken *make_wide_string(const char *someText, size_t aLength)
+{
+ return new CxxNaffToken(PARSE_TOKEN(StringLiteral), someText, aLength);
+}
+
--- /dev/null
+#include <CxxToken.hxx>
+
+#include <CxxParser.hxx>
+
+static CxxToken *yyToken;
+static CxxToken *make_character(const char *someText, size_t aLength);
+static CxxToken *make_string(const char *someText, size_t aLength);
+static CxxToken *make_identifier(const char *someText, size_t aLength);
+static void make_line(const char *yyText, size_t yyLeng);
+static CxxToken *make_literal_character(const char *someText, size_t aLength);
+static CxxToken *make_narrow_character(const char *someText, size_t aLength);
+static CxxToken *make_narrow_string(const char *someText, size_t aLength);
+static CxxToken *make_number(const char *someText, size_t aLength);
+static CxxToken *make_token(size_t aCxxToken);
+static CxxToken *make_wide_character(const char *someText, size_t aLength);
+static CxxToken *make_wide_string(const char *someText, size_t aLength);
+
+#define LEX_SAVE_LINE(yyText, yyLeng) make_line(yyText, yyLeng);
+#define LEX_ASCII_TOKEN(a) yyToken = make_token(a); return true;
+#define LEX_STATIC_TOKEN(a) static CxxToken theToken(PARSE_TOKEN(a)); yyToken = &theToken; return true;
+#define LEX_C_STATIC_TOKEN(a) \
+ if (c_keywords) { LEX_IDENTIFIER_TOKEN(yytext, yyleng) } \
+ else { LEX_STATIC_TOKEN(a) } return true;
+#define LEX_ESCAPED_TOKEN(yyText, yyLeng) LEX_STATIC_TOKEN(CharacterLiteral)
+// yyToken = make_literal_character(yytext, yyleng); return true;
+#define LEX_CHARACTER_TOKEN(yyText, yyLeng) LEX_STATIC_TOKEN(CharacterLiteral)
+// yyToken = make_character(yyText, yyLeng); return true;
+#define LEX_STRING_TOKEN(yyText, yyLeng) LEX_STATIC_TOKEN(StringLiteral)
+// yyToken = make_string(yyText, yyLeng); return true;
+#define LEX_IDENTIFIER_TOKEN(yyText, yyLeng) LEX_STATIC_TOKEN(Identifier)
+// yyToken = make_identifier(yyText, yyLeng); return true;
+#define LEX_NUMBER_TOKEN(yyText, yyLeng) LEX_STATIC_TOKEN(IntegerLiteral)
+// yyToken = make_number(yyText, yyLeng); return true;
--- /dev/null
+//
+// Title: C++ Grammar Parser support compilation unit.
+//
+// File Name: CxxParser.cpp
+//
+// Author: E.D.Willink
+//END
+//
+#include <CxxParser.cxx>
+
--- /dev/null
+/* This is a yacc-able parser for the entire ISO C++ grammar with no unresolved conflicts. */
+/* The parse is SYNTACTICALLY consistent and requires no template or type name assistance.
+ * The grammar in the C++ standard notes that its grammar is a superset of the true
+ * grammar requiring semantic constraints to resolve ambiguities. This grammar is a really big
+ * superset unifying expressions and declarations, eliminating the type/non-type distinction,
+ * and iterating to find a consistent solution to the template/arith,metoic < ambiguity.
+ * As a result the grammar is much simpler, but requires the missing semantic constraints to be
+ * performed in a subsequent semantic pass, which is of course where they belong. This grammar will
+ * support conversion of C++ tokens into an Abstract Syntax Tree. A lot of further work is required to
+ * make that tree useful.
+ *
+ * The principles behind this grammar are described in my thesis on Meta-Compilation for C++, which
+ * may be found via http://www.computing.surrey.ac.uk/research/dsrg/fog/FogThesis.html.
+ *
+ * Author: E.D.Willink Ed.Willink@rrl.co.uk
+ * Date: 19-Jun-2001
+ */
+/*StartTester*/
+%{
+#include <CxxParsing.hxx>
+%}
+/*EndTester*/
+/*
+ * The lexer (and/or a preprocessor) is expected to identify the following
+ *
+ * Punctuation:
+ */
+%type <keyword> '+' '-' '*' '/' '%' '^' '&' '|' '~' '!' '<' '>' '=' ':' '[' ']' '{' '}' '(' ')'
+%type <keyword> '?' '.' '\'' '\"' '\\' '@' '$' ';' ','
+/*
+ * Punctuation sequences
+ */
+%term <keyword> ARROW ARROW_STAR DEC EQ GE INC LE LOG_AND LOG_OR NE SHL SHR
+%term <keyword> ASS_ADD ASS_AND ASS_DIV ASS_MOD ASS_MUL ASS_OR ASS_SHL ASS_SHR ASS_SUB ASS_XOR
+%term <keyword> DOT_STAR ELLIPSIS SCOPE
+/*
+ * Reserved words
+ */
+%term <access_specifier> PRIVATE PROTECTED PUBLIC
+%term <built_in_id> BOOL CHAR DOUBLE FLOAT INT LONG SHORT SIGNED UNSIGNED VOID WCHAR_T
+%term <class_key> CLASS ENUM NAMESPACE STRUCT TYPENAME UNION
+%term <cv_qualifiers> CONST VOLATILE
+%term <decl_specifier_id> AUTO EXPLICIT EXPORT EXTERN FRIEND INLINE MUTABLE REGISTER STATIC TEMPLATE TYPEDEF USING VIRTUAL
+%term <keyword> ASM BREAK CASE CATCH CONST_CAST CONTINUE DEFAULT DELETE DO DYNAMIC_CAST
+%term <keyword> ELSE FALSE FOR GOTO IF NEW OPERATOR REINTERPRET_CAST RETURN
+%term <keyword> SIZEOF STATIC_CAST SWITCH THIS THROW TRUE TRY TYPEID WHILE
+/*
+ * Parametric values.
+ */
+%term <character_literal> CharacterLiteral
+%term <floating_literal> FloatingLiteral
+%term <identifier> Identifier
+%term <integer_literal> IntegerLiteral
+%term <number_literal> NumberLiteral
+%term <string_literal> StringLiteral
+/*
+ * The lexer need not treat '0' as distinct from IntegerLiteral in the hope that pure-specifier can
+ * be distinguished, It isn't. Semantic rescue from = constant-expression is necessary.
+ *
+ * The lexer is not required to distinguish template or type names, although a slight simplification to the
+ * grammar and elaboration of the action rules could make good use of template name information.
+ *
+ * In return for not needing to use semantic information, the lexer must support back-tracking, which
+ * is easily achieved by a simple linear buffer, a reference implementation of which may be found in the
+ * accompanying CxxParsing.cxx. Back-tracking is used to support:
+ *
+ * Binary search for a consistent parse of the template/arithmetic ambiguity.
+ * start_search() initialises the search
+ * advance_search() iterates the search
+ * end_search() cleans up after a search
+ * template_test() maintains context during a search
+ *
+ * Lookahead to resolve the inheritance/anonymous bit-field similarity
+ * mark() saves the starting context
+ * unmark() pops it
+ * rewind_colon() restores the context and forces the missing :
+ *
+ * Lookahead to resolve type 1 function parameter ambiguities
+ * mark_type1() potentially marks the starting position
+ * mark() marks the pre { position
+ * remark() rewinds to the starting position
+ * unmark() pops the starting position
+ *
+ * Note that lookaheads may nest.
+ */
+
+/*
+ * The parsing philosophy is unusual. The major ambiguities are resolved by creating a unified superset
+ * grammar rather than non-overlapping subgrammars. Thus the grammar for parameter-declaration covers an
+ * assignment-expression. Minor ambiguities whose resolution by supersetting would create more
+ * ambiguities are resolved the normal way with partitioned subgrammars.
+ * This eliminates the traditional expression/declaration and constructor/parenthesised declarator
+ * ambiguities at the syntactic level. A subsequent semantic level has to sort the problems out.
+ * The generality introduces four bogus ambiguities and defers the cast ambiguity for resolution
+ * once semantic information is available.
+ *
+ * The C++ grammar comprises 561 rules and uses 897 states in yacc, with 0 unresolved conflicts.
+ * 23 conflicts from 10 ambiguities are resolved by 8 %prec's, so that yacc and bison report 0 conflicts.
+ *
+ * The ambiguities are:
+ * 1) dangling else resolved to inner-most if
+ * 1 conflict in 1 state on else
+ * 2) < as start-template or less-than
+ * 1 conflict in 1 states on <
+ * 3) a :: b :: c resolved to favour a::b::c rather than a::b ::c or a ::b::c
+ * 1 conflicts in 1 state for ::
+ * 4) pointer operators maximised at end of conversion id/new in preference to binary operators
+ * 2 conflicts in 4 states on * and &
+ * 5a) (a)@b resolved to favour binary a@b rather than cast unary (a)(@b)
+ * 5b) (a)(b) resolved to favour cast rather than call
+ * 8 conflicts in 1 state for the 8 prefix operators: 6 unaries and ( and [.
+ * 6) enum name { resolved to enum-specifier rather than function
+ * 1 conflict in 1 state on {
+ * 7) class name { resolved to class-specifier rather than function
+ * 1 conflict in 1 state on {
+ * 8) extern "C" resolved to linkage-specification rather than declaration
+ * 1 conflict in 1 state on StringLiteral
+ * 9) class X : forced to go through base-clause look-ahead
+ * 1 conflict in 1 state on :
+ * 10) id : forced to label_statement rather than constructor_head
+ * 0 conflicts - but causes a double state for 2)
+ * of which
+ * 1 is a fundamental C conflict - always correctly resolved
+ * can be removed - see the Java spec
+ * 2, 3, 4 are fundamental C++ conflicts
+ * 2 always consistently resolved by iteration
+ * 3 always correctly resolved
+ * 4 always correctly resolved
+ * 5 is a result of not using type information - deferred for semantic repair
+ * 6,7 are caused by parsing over-generous superset - always correctly resolved
+ * 8 is caused by parsing over-generous superset - always correctly resolved
+ * can be removed at the expense of 7 rules and 5 states.
+ * 9 is a look-ahead trick - always correctly resolved
+ * could be removed by marking one token sooner
+ * 10 is caused by parsing over-generous superset - always correctly resolved
+ *
+ * The hard problem of distinguishing
+ * class A { class B : C, D, E { -- A::B privately inherits C, D and E
+ * class A { class B : C, D, E ; -- C is width of anon bit-field
+ * is resolved by using a lookahead that assumes inheritance and rewinds for the bit-field.
+ *
+ * The potential shift-reduce conflict on > is resolved by flattening part of the expression grammar
+ * to know when the next > is template end or arithmetic >.
+ *
+ * The grammar is SYNTACTICALLY context-free with respect to type. No semantic assistance is required
+ * during syntactic analysis. However the cast ambiguity is deferred and must be recovered
+ * after syntactic analysis of a statement has completed.
+ *
+ * The grammar is SYNTACTICALLY context-free with respect to template-names. This is achieved by
+ * organising a binary search over all possible template/arithmetic ambiguities with respect to
+ * the enclosing statement. This is potentially exponentially inefficient but well-behaved in practice.
+ * Approximately 1% of statements trigger a search and approximately 1% of those are misparsed,
+ * requiring the semantic analysis to check and correct once template information is available.
+ * 1.5 parse attempts are required on average per ambiguous statement.
+ *
+ * The grammar supports type I function declarations at severe impediment to efficiency. A lookahead
+ * has to be performed after almost every non-statement close parenthesis. A one-line plus corollary
+ * change to postfix_expression is commented and strongly recommended to make this grammar as
+ * efficient as the rather large number of reduction levels permits.
+ *
+ * Error recovery occurs mostly at the statement/declaration level. Recovery also occurs at
+ * the list-element level where this poses no hazard to statement/declaration level recovery.
+ * Note that since error propagation interacts with the lookaheads for template iteration or
+ * type 1 function arguments, introduction of finer grained error recovery may repair a false
+ * parse and so cause a misparse.
+ *
+ * The following syntactic analysis errors occur, but are correctable semantically:
+ * (cast)unary-op expr is parsed as (parenthesised)binary-op expr
+ * The semantic test should look for a binary/call with a (type) as its left child.
+ * (parenthesised)(arguments) is parsed as (cast)(parenthesised)
+ * The semantic test should look for a cast with a non-type as its left child.
+ * template < and arithmetic < may be cross-parsed (unless semnatic help is provided)
+ * approximately 0.01% are misparsed, and must be sorted out - not easy.
+ *
+ * The syntactic analysis defers the following ambiguities for semantic resolution:
+ * declaration/expression is parsed as a unified concept
+ * Use type and context to complete the parse.
+ * ~class-name is parsed as unary~ name
+ * The semantic test should look for ~ with a type as its child.
+ * delete[] expr is parsed as delete []expr
+ * The semantic test should look for delete with a [] cast of its child.
+ * operator new/delete[] are parsed as array of operator new/delete
+ * The semantic test should look for array of operator new/delete
+ * or activate the two extra commented rules in operator
+ * template of an explicit_instantiation is buried deep in the tree
+ * dig it out
+ * pure-specifier and constant-initializer are covered by assignment-expression
+ * just another of the deferred declaration/expression ambiguities
+ * sizeof and typeid don't distinguish type/value syntaxes
+ * probably makes life polymorphically easier
+ */
+/* Action code is supplied by a large number of YACC_xxx macros that can be redefined
+ * by rewriting the include file rather than the grammar. The number of macros is
+ * slightly reduced by using the following protocols
+ *
+ * YACC_LIST(0,0) create empty list (may safely return 0).
+ * YACC_LIST(0,E) create new list with content E (may return 0 if above returned non-0).
+ * YACC_LIST(L,E) add E to L
+ * YACC_LIST(L,0) error propagation, adding nothing to L.
+ */
+%type <bang> bang
+%type <mark> colon_mark mark mark_type1
+%type <nest> nest
+
+%type <access_specifier> access_specifier
+%type <base_specifier> base_specifier
+%type <base_specifiers> base_specifier_list
+%type <built_in_id> built_in_type_id built_in_type_specifier
+%type <_class> class_specifier_head
+%type <class_key> class_key
+%type <condition> condition condition.opt
+%type <cv_qualifiers> cv_qualifier cv_qualifier_seq.opt
+%type <decl_specifier_id> decl_specifier_affix decl_specifier_prefix decl_specifier_suffix function_specifier storage_class_specifier
+%type <declaration> accessibility_specifier asm_definition block_declaration declaration explicit_specialization
+%type <declaration> looped_declaration looping_declaration namespace_alias_definition
+%type <declaration> specialised_block_declaration specialised_declaration template_declaration using_directive
+%type <declarations> compound_declaration declaration_seq.opt
+%type <declarator> nested_ptr_operator ptr_operator
+%type <delete_expression> delete_expression
+%type <enumerator> enumerator_definition
+%type <enumerators> enumerator_clause enumerator_list enumerator_list_head
+%type <exception_declaration> exception_declaration
+%type <exception_specification> exception_specification
+%type <expression> abstract_declarator.opt abstract_expression abstract_parameter_declaration abstract_pointer_declaration
+%type <expression> additive_expression and_expression assignment_expression
+%type <expression> bit_field_declaration bit_field_init_declaration bit_field_width boolean_literal
+%type <expression> cast_expression conditional_expression constant_expression conversion_type_id ctor_definition
+%type <expression> direct_abstract_declarator direct_abstract_declarator.opt direct_new_declarator
+%type <expression> equality_expression exclusive_or_expression expression expression.opt
+%type <expression> for_init_statement func_definition function_definition
+%type <expression> inclusive_or_expression init_declaration literal logical_and_expression logical_or_expression
+%type <expression> multiplicative_expression new_declarator new_type_id
+%type <expression> pm_expression postfix_expression primary_expression ptr_operator_seq ptr_operator_seq.opt
+%type <expression> relational_expression shift_expression simple_declaration special_parameter_declaration
+%type <expression> templated_throw_expression throw_expression templated_abstract_declaration templated_and_expression
+%type <expression>templated_assignment_expression templated_conditional_expression templated_equality_expression
+%type <expression> templated_exclusive_or_expression templated_expression templated_inclusive_or_expression templated_logical_and_expression
+%type <expression> templated_logical_or_expression templated_relational_expression type_id unary_expression
+%type <expressions> constructor_head expression_list expression_list.opt init_declarations
+%type <expressions> new_initializer.opt templated_expression_list type_id_list
+%type <function_body> function_block function_body function_try_block try_block
+%type <handler> handler
+%type <handlers> handler_seq
+%type <initializer_clause> braced_initializer initializer_clause looped_initializer_clause looping_initializer_clause
+%type <initializer_clauses> initializer_list
+%type <is_template> global_scope
+%type <keyword> assignment_operator
+%type <line> start_search start_search1
+%type <mem_initializer> mem_initializer
+%type <mem_initializers> ctor_initializer ctor_initializer.opt mem_initializer_list mem_initializer_list_head
+%type <name> class_specifier conversion_function_id declarator_id destructor_id
+%type <name> elaborated_class_specifier elaborated_enum_specifier elaborated_type_specifier elaborate_type_specifier
+%type <name> enum_specifier enumerator id identifier_word id_scope identifier linkage_specification
+%type <name> namespace_definition nested_id nested_pseudo_destructor_id nested_special_function_id
+%type <name> mem_initializer_id operator operator_function_id pseudo_destructor_id scoped_id scoped_pseudo_destructor_id scoped_special_function_id
+%type <name> simple_type_specifier special_function_id suffix_built_in_decl_specifier suffix_named_decl_specifier.bi
+%type <name> suffix_built_in_decl_specifier.raw suffix_decl_specified_ids suffix_named_decl_specifiers
+%type <name> suffix_named_decl_specifiers.sf suffix_decl_specified_scope suffix_named_decl_specifier
+%type <name> template_id type_specifier
+%type <new_expression> new_expression
+%type <parameter> parameter_declaration templated_parameter_declaration
+%type <parameters> parameters_clause parameter_declaration_clause parameter_declaration_list
+%type <parenthesised> parenthesis_clause
+%type <pointer_declarator> star_ptr_operator
+%type <simple_type_parameter> simple_type_parameter
+%type <statement> compound_statement control_statement declaration_statement iteration_statement jump_statement
+%type <statement> labeled_statement looped_statement looping_statement selection_statement statement
+%type <statements> statement_seq.opt
+%type <strings> string
+%type <template_argument> template_argument
+%type <template_arguments> template_argument_list
+%type <template_parameter> template_parameter
+%type <template_parameters> template_parameter_clause template_parameter_list
+%type <templated_type_parameter> templated_type_parameter
+%type <type1_parameters> type1_parameters
+%type <utility> util
+
+/*
+ * C++ productions replaced by more generalised FOG productions
+ */
+%type <declaration> looped_member_declaration looping_member_declaration member_declaration using_declaration
+%type <declarations> member_specification.opt
+%type <expression> member_init_declaration simple_member_declaration
+%type <expressions> member_init_declarations
+
+\f
+%nonassoc SHIFT_THERE
+%nonassoc SCOPE ELSE INC DEC '+' '-' '*' '&' '[' '{' '<' ':' StringLiteral
+%nonassoc REDUCE_HERE_MOSTLY
+%nonassoc '('
+/*%nonassoc REDUCE_HERE */
+
+%start translation_unit
+%%
+
+/*
+ * The %prec resolves a conflict in identifier_word : which is forced to be a shift of a label for
+ * a labeled-statement rather than a reduction for the name of a bit-field or generalised constructor.
+ * This is pretty dubious syntactically but correct for all semantic possibilities.
+ * The shift is only activated when the ambiguity exists at the start of a statement. In this context
+ * a bit-field declaration or constructor definition are not allowed.
+ */
+identifier_word: Identifier { $$ = $1; }
+identifier: identifier_word %prec SHIFT_THERE
+/*
+ * The %prec resolves the $014.2-3 ambiguity:
+ * Identifier '<' is forced to go through the is-it-a-template-name test
+ * All names absorb TEMPLATE with the name, so that no template_test is performed for them.
+ * This requires all potential declarations within an expression to perpetuate this policy
+ * and thereby guarantee the ultimate coverage of explicit_instantiation.
+ */
+id: identifier %prec SHIFT_THERE /* Force < through test */ { $$ = YACC_NAME($1); }
+ | identifier template_test '+' template_argument_list '>' { $$ = YACC_TEMPLATE_NAME($1, $4); }
+ | identifier template_test '+' '>' { $$ = $1; ERRMSG("Empty template-argument-list"); }
+ | identifier template_test '-' /* requeued < follows */ { $$ = YACC_NAME($1); }
+ | template_id
+template_test: '<' /* Queue '+' or '-' < as follow on */ { template_test(); }
+global_scope: SCOPE { $$ = IS_DEFAULT; }
+ | TEMPLATE global_scope { $$ = IS_TEMPLATE; }
+id_scope: id SCOPE { $$ = YACC_NESTED_SCOPE($1); }
+/*
+ * A :: B :: C; is ambiguous How much is type and how much name ?
+ * The %prec maximises the (type) length which is the $07.1-2 semantic constraint.
+ */
+nested_id: id %prec SHIFT_THERE /* Maximise length */
+ | id_scope nested_id { $$ = YACC_NESTED_ID($1, $2); }
+scoped_id: nested_id
+ | global_scope nested_id { $$ = YACC_GLOBAL_ID($1, $2); }
+
+/*
+ * destructor_id has to be held back to avoid a conflict with a one's complement as per $05.3.1-9,
+ * It gets put back only when scoped or in a declarator_id, which is only used as an explicit member name.
+ * Declarations of an unscoped destructor are always parsed as a one's complement.
+ */
+destructor_id: '~' id { $$ = YACC_DESTRUCTOR_ID($2); }
+ | TEMPLATE destructor_id { $$ = YACC_SET_TEMPLATE_ID($2); }
+special_function_id: conversion_function_id
+ | operator_function_id
+ | TEMPLATE special_function_id { $$ = YACC_SET_TEMPLATE_ID($2); }
+nested_special_function_id: special_function_id
+ | id_scope destructor_id { $$ = YACC_NESTED_ID($1, $2); }
+ | id_scope nested_special_function_id { $$ = YACC_NESTED_ID($1, $2); }
+scoped_special_function_id: nested_special_function_id
+ | global_scope nested_special_function_id { $$ = YACC_GLOBAL_ID($1, $2); }
+
+/* declarator-id is all names in all scopes, except reserved words */
+declarator_id: scoped_id
+ | scoped_special_function_id
+ | destructor_id
+
+/* The standard defines pseudo-destructors in terms of type-name, which is class/enum/typedef, of which
+ * class-name is covered by a normal destructor. pseudo-destructors are supposed to support ~int() in
+ * templates, so the grammar here covers built-in names. Other names are covered by the lack of
+ * identifier/type discrimination.
+ */
+built_in_type_id: built_in_type_specifier
+ | built_in_type_id built_in_type_specifier { $$ = YACC_BUILT_IN_IDS($1, $2); }
+pseudo_destructor_id: built_in_type_id SCOPE '~' built_in_type_id { $$ = YACC_PSEUDO_DESTRUCTOR_ID($1, $4); }
+ | '~' built_in_type_id { $$ = YACC_PSEUDO_DESTRUCTOR_ID(0, $2); }
+ | TEMPLATE pseudo_destructor_id { $$ = YACC_SET_TEMPLATE_ID($2); }
+nested_pseudo_destructor_id: pseudo_destructor_id
+ | id_scope nested_pseudo_destructor_id { $$ = YACC_NESTED_ID($1, $2); }
+scoped_pseudo_destructor_id: nested_pseudo_destructor_id
+ | global_scope scoped_pseudo_destructor_id { $$ = YACC_GLOBAL_ID($1, $2); }
+
+/*---------------------------------------------------------------------------------------------------
+ * A.2 Lexical conventions
+ *---------------------------------------------------------------------------------------------------*/
+/*
+ * String concatenation is a phase 6, not phase 7 activity so does not really belong in the grammar.
+ * However it may be convenient to have it here to make this grammar fully functional.
+ * Unfortunately it introduces a conflict with the generalised parsing of extern "C" which
+ * is correctly resolved to maximise the string length as the token source should do anyway.
+ */
+string: StringLiteral { $$ = $1; }
+/*string: StringLiteral %prec SHIFT_THERE { $$ = YACC_STRINGS($1, 0); } */
+/* | StringLiteral string -- Perverse order avoids conflicts -- { $$ = YACC_STRINGS($1, $2); } */
+literal: IntegerLiteral { $$ = YACC_INTEGER_LITERAL_EXPRESSION($1); }
+ | CharacterLiteral { $$ = YACC_CHARACTER_LITERAL_EXPRESSION($1); }
+ | FloatingLiteral { $$ = YACC_FLOATING_LITERAL_EXPRESSION($1); }
+ | string { $$ = YACC_STRING_LITERAL_EXPRESSION($1); }
+ | boolean_literal
+boolean_literal: FALSE { $$ = YACC_FALSE_EXPRESSION(); }
+ | TRUE { $$ = YACC_TRUE_EXPRESSION(); }
+
+/*---------------------------------------------------------------------------------------------------
+ * A.3 Basic concepts
+ *---------------------------------------------------------------------------------------------------*/
+translation_unit: declaration_seq.opt { YACC_RESULT($1); }
+
+/*---------------------------------------------------------------------------------------------------
+ * A.4 Expressions
+ *---------------------------------------------------------------------------------------------------
+ * primary_expression covers an arbitrary sequence of all names with the exception of an unscoped destructor,
+ * which is parsed as its unary expression which is the correct disambiguation (when ambiguous).
+ * This eliminates the traditional A(B) meaning A B ambiguity, since we never have to tack an A onto
+ * the front of something that might start with (. The name length got maximised ab initio. The downside
+ * is that semantic interpretation must split the names up again.
+ *
+ * Unification of the declaration and expression syntax means that unary and binary pointer declarator operators:
+ * int * * name
+ * are parsed as binary and unary arithmetic operators (int) * (*name). Since type information is not used
+ * ambiguities resulting from a cast
+ * (cast)*(value)
+ * are resolved to favour the binary rather than the cast unary to ease AST clean-up.
+ * The cast-call ambiguity must be resolved to the cast to ensure that (a)(b)c can be parsed.
+ *
+ * The problem of the functional cast ambiguity
+ * name(arg)
+ * as call or declaration is avoided by maximising the name within the parsing kernel. So
+ * primary_id_expression picks up
+ * extern long int const var = 5;
+ * as an assignment to the syntax parsed as "extern long int const var". The presence of two names is
+ * parsed so that "extern long into const" is distinguished from "var" considerably simplifying subsequent
+ * semantic resolution.
+ *
+ * The generalised name is a concatenation of potential type-names (scoped identifiers or built-in sequences)
+ * plus optionally one of the special names such as an operator-function-id, conversion-function-id or
+ * destructor as the final name.
+ */
+primary_expression: literal
+ | THIS { $$ = YACC_THIS_EXPRESSION(); }
+ | suffix_decl_specified_ids { $$ = $1; }
+/* | SCOPE identifier -- covered by suffix_decl_specified_ids */
+/* | SCOPE operator_function_id -- covered by suffix_decl_specified_ids */
+/* | SCOPE qualified_id -- covered by suffix_decl_specified_ids */
+ | abstract_expression %prec REDUCE_HERE_MOSTLY /* Prefer binary to unary ops, cast to call */
+/* | id_expression -- covered by suffix_decl_specified_ids */
+
+/*
+ * Abstract-expression covers the () and [] of abstract-declarators.
+ */
+abstract_expression: parenthesis_clause { $$ = YACC_ABSTRACT_FUNCTION_EXPRESSION($1); }
+ | '[' expression.opt ']' { $$ = YACC_ABSTRACT_ARRAY_EXPRESSION($2); }
+ | TEMPLATE parenthesis_clause { $$ = YACC_SET_TEMPLATE_EXPRESSION(YACC_ABSTRACT_FUNCTION_EXPRESSION($2)); }
+
+/* Type I function parameters are ambiguous with respect to the generalised name, so we have to do a lookahead following
+ * any function-like parentheses. This unfortunately hits normal code, so kill the -- lines and add the ++ lines for efficiency.
+ * Supporting Type I code under the superset causes perhaps 25% of lookahead parsing. Sometimes complete class definitions
+ * get traversed since they are valid generalised type I parameters!
+ */
+type1_parameters: /*----*/ parameter_declaration_list ';' { $$ = YACC_TYPE1_PARAMETERS(0, $1); }
+ | /*----*/ type1_parameters parameter_declaration_list ';' { $$ = YACC_TYPE1_PARAMETERS($1, $2); }
+mark_type1: /* empty */ { $$ = mark_type1(); }
+postfix_expression: primary_expression
+/* | /++++++/ postfix_expression parenthesis_clause { $$ = YACC_CALL_EXPRESSION($1, $2); } */
+ | /*----*/ postfix_expression parenthesis_clause mark_type1 '-' { $$ = YACC_CALL_EXPRESSION($1, $2); }
+ | /*----*/ postfix_expression parenthesis_clause mark_type1 '+' type1_parameters mark '{' error
+ /*----*/ { yyerrok; remark_type1($6); unmark(); unmark($5); $$ = YACC_TYPE1_EXPRESSION($1, $2, $5); }
+ | /*----*/ postfix_expression parenthesis_clause mark_type1 '+' type1_parameters mark error
+ /*----*/ { yyerrok; remark_type1($3); unmark(); unmark(); $$ = YACC_CALL_EXPRESSION($1, $2); }
+ | /*----*/ postfix_expression parenthesis_clause mark_type1 '+' error
+ /*----*/ { yyerrok; remark_type1($3); unmark(); $$ = YACC_CALL_EXPRESSION($1, $2); }
+ | postfix_expression '[' expression.opt ']' { $$ = YACC_ARRAY_EXPRESSION($1, $3); }
+/* | destructor_id '[' expression.opt ']' -- not semantically valid */
+/* | destructor_id parenthesis_clause -- omitted to resolve known ambiguity */
+/* | simple_type_specifier '(' expression_list.opt ')' -- simple_type_specifier is a primary_expression */
+ | postfix_expression '.' declarator_id { $$ = YACC_DOT_EXPRESSION($1, $3); }
+/* | postfix_expression '.' TEMPLATE declarator_id -- TEMPLATE absorbed into declarator_id. */
+ | postfix_expression '.' scoped_pseudo_destructor_id { $$ = YACC_DOT_EXPRESSION($1, $3); }
+ | postfix_expression ARROW declarator_id { $$ = YACC_ARROW_EXPRESSION($1, $3); }
+/* | postfix_expression ARROW TEMPLATE declarator_id -- TEMPLATE absorbed into declarator_id. */
+ | postfix_expression ARROW scoped_pseudo_destructor_id { $$ = YACC_ARROW_EXPRESSION($1, $3); }
+ | postfix_expression INC { $$ = YACC_POST_INCREMENT_EXPRESSION($1); }
+ | postfix_expression DEC { $$ = YACC_POST_DECREMENT_EXPRESSION($1); }
+ | DYNAMIC_CAST '<' type_id '>' '(' expression ')' { $$ = YACC_DYNAMIC_CAST_EXPRESSION($3, $6); }
+ | STATIC_CAST '<' type_id '>' '(' expression ')' { $$ = YACC_STATIC_CAST_EXPRESSION($3, $6); }
+ | REINTERPRET_CAST '<' type_id '>' '(' expression ')' { $$ = YACC_REINTERPRET_CAST_EXPRESSION($3, $6); }
+ | CONST_CAST '<' type_id '>' '(' expression ')' { $$ = YACC_CONST_CAST_EXPRESSION($3, $6); }
+ | TYPEID parameters_clause { $$ = YACC_TYPEID_EXPRESSION($2); }
+/* | TYPEID '(' expression ')' -- covered by parameters_clause */
+/* | TYPEID '(' type_id ')' -- covered by parameters_clause */
+expression_list.opt: /* empty */ { $$ = YACC_EXPRESSIONS(0, 0); }
+ | expression_list
+expression_list: assignment_expression { $$ = YACC_EXPRESSIONS(0, $1); }
+ | expression_list ',' assignment_expression { $$ = YACC_EXPRESSIONS($1, $3); }
+
+unary_expression: postfix_expression
+ | INC cast_expression { $$ = YACC_PRE_INCREMENT_EXPRESSION($2); }
+ | DEC cast_expression { $$ = YACC_PRE_DECREMENT_EXPRESSION($2); }
+ | ptr_operator cast_expression { $$ = YACC_POINTER_EXPRESSION($1, $2); }
+/* | '*' cast_expression -- covered by ptr_operator */
+/* | '&' cast_expression -- covered by ptr_operator */
+/* | decl_specifier_seq '*' cast_expression -- covered by binary operator */
+/* | decl_specifier_seq '&' cast_expression -- covered by binary operator */
+ | suffix_decl_specified_scope star_ptr_operator cast_expression /* covers e.g int ::type::* const t = 4 */
+ { $$ = YACC_SCOPED_POINTER_EXPRESSION($1, $2, $3); }
+ | '+' cast_expression { $$ = YACC_PLUS_EXPRESSION($2); }
+ | '-' cast_expression { $$ = YACC_MINUS_EXPRESSION($2); }
+ | '!' cast_expression { $$ = YACC_NOT_EXPRESSION($2); }
+ | '~' cast_expression { $$ = YACC_COMPLEMENT_EXPRESSION($2); }
+ | SIZEOF unary_expression { $$ = YACC_SIZEOF_EXPRESSION($2); }
+/* | SIZEOF '(' type_id ')' -- covered by unary_expression */
+ | new_expression { $$ = $1; }
+ | global_scope new_expression { $$ = YACC_GLOBAL_EXPRESSION($1, $2); }
+ | delete_expression { $$ = $1; }
+ | global_scope delete_expression { $$ = YACC_GLOBAL_EXPRESSION($1, $2); }
+/* | DELETE '[' ']' cast_expression -- covered by DELETE cast_expression since cast_expression covers ... */
+/* | SCOPE DELETE '[' ']' cast_expression // ... abstract_expression cast_expression and so [] cast_expression */
+
+delete_expression: DELETE cast_expression /* also covers DELETE[] cast_expression */
+ { $$ = YACC_DELETE_EXPRESSION($2); }
+new_expression: NEW new_type_id new_initializer.opt { $$ = YACC_NEW_TYPE_ID_EXPRESSION(0, $2, $3); }
+ | NEW parameters_clause new_type_id new_initializer.opt { $$ = YACC_NEW_TYPE_ID_EXPRESSION($2, $3, $4); }
+ | NEW parameters_clause { $$ = YACC_NEW_EXPRESSION($2, 0, 0); }
+/* | NEW '(' type-id ')' -- covered by parameters_clause */
+ | NEW parameters_clause parameters_clause new_initializer.opt { $$ = YACC_NEW_EXPRESSION($2, $3, $4); }
+/* | NEW '(' type-id ')' new_initializer -- covered by parameters_clause parameters_clause */
+/* | NEW parameters_clause '(' type-id ')' -- covered by parameters_clause parameters_clause */
+ /* ptr_operator_seq.opt production reused to save a %prec */
+new_type_id: type_specifier ptr_operator_seq.opt { $$ = YACC_TYPED_EXPRESSION($1, $2); }
+ | type_specifier new_declarator { $$ = YACC_TYPED_EXPRESSION($1, $2); }
+ | type_specifier new_type_id { $$ = YACC_TYPED_EXPRESSION($1, $2); }
+new_declarator: ptr_operator new_declarator { $$ = YACC_POINTER_EXPRESSION($1, $2); }
+ | direct_new_declarator
+direct_new_declarator: '[' expression ']' { $$ = YACC_ABSTRACT_ARRAY_EXPRESSION($2); }
+ | direct_new_declarator '[' constant_expression ']' { $$ = YACC_ARRAY_EXPRESSION($1, $3); }
+new_initializer.opt: /* empty */ { $$ = YACC_EXPRESSIONS(0, 0); }
+ | '(' expression_list.opt ')' { $$ = $2; }
+
+/* cast-expression is generalised to support a [] as well as a () prefix. This covers the omission of DELETE[] which when
+ * followed by a parenthesised expression was ambiguous. It also covers the gcc indexed array initialisation for free.
+ */
+cast_expression: unary_expression
+ | abstract_expression cast_expression { $$ = YACC_CAST_EXPRESSION($1, $2); }
+/* | '(' type_id ')' cast_expression -- covered by abstract_expression */
+
+pm_expression: cast_expression
+ | pm_expression DOT_STAR cast_expression { $$ = YACC_DOT_STAR_EXPRESSION($1, $3); }
+ | pm_expression ARROW_STAR cast_expression { $$ = YACC_ARROW_STAR_EXPRESSION($1, $3); }
+multiplicative_expression: pm_expression
+ | multiplicative_expression star_ptr_operator pm_expression { $$ = YACC_MULTIPLY_EXPRESSION($1, $2, $3); }
+ | multiplicative_expression '/' pm_expression { $$ = YACC_DIVIDE_EXPRESSION($1, $3); }
+ | multiplicative_expression '%' pm_expression { $$ = YACC_MODULUS_EXPRESSION($1, $3); }
+additive_expression: multiplicative_expression
+ | additive_expression '+' multiplicative_expression { $$ = YACC_ADD_EXPRESSION($1, $3); }
+ | additive_expression '-' multiplicative_expression { $$ = YACC_SUBTRACT_EXPRESSION($1, $3); }
+shift_expression: additive_expression
+ | shift_expression SHL additive_expression { $$ = YACC_SHIFT_LEFT_EXPRESSION($1, $3); }
+ | shift_expression SHR additive_expression { $$ = YACC_SHIFT_RIGHT_EXPRESSION($1, $3); }
+relational_expression: shift_expression
+ | relational_expression '<' shift_expression { $$ = YACC_LESS_THAN_EXPRESSION($1, $3); }
+ | relational_expression '>' shift_expression { $$ = YACC_GREATER_THAN_EXPRESSION($1, $3); }
+ | relational_expression LE shift_expression { $$ = YACC_LESS_EQUAL_EXPRESSION($1, $3); }
+ | relational_expression GE shift_expression { $$ = YACC_GREATER_EQUAL_EXPRESSION($1, $3); }
+equality_expression: relational_expression
+ | equality_expression EQ relational_expression { $$ = YACC_EQUAL_EXPRESSION($1, $3); }
+ | equality_expression NE relational_expression { $$ = YACC_NOT_EQUAL_EXPRESSION($1, $3); }
+and_expression: equality_expression
+ | and_expression '&' equality_expression { $$ = YACC_AND_EXPRESSION($1, $3); }
+exclusive_or_expression: and_expression
+ | exclusive_or_expression '^' and_expression { $$ = YACC_EXCLUSIVE_OR_EXPRESSION($1, $3); }
+inclusive_or_expression: exclusive_or_expression
+ | inclusive_or_expression '|' exclusive_or_expression { $$ = YACC_INCLUSIVE_OR_EXPRESSION($1, $3); }
+logical_and_expression: inclusive_or_expression
+ | logical_and_expression LOG_AND inclusive_or_expression { $$ = YACC_LOGICAL_AND_EXPRESSION($1, $3); }
+logical_or_expression: logical_and_expression
+ | logical_or_expression LOG_OR logical_and_expression { $$ = YACC_LOGICAL_OR_EXPRESSION($1, $3); }
+conditional_expression: logical_or_expression
+ | logical_or_expression '?' expression ':' assignment_expression
+ { $$ = YACC_CONDITIONAL_EXPRESSION($1, $3, $5); }
+
+/* assignment-expression is generalised to cover the simple assignment of a braced initializer in order to contribute to the
+ * coverage of parameter-declaration and init-declaration.
+ */
+assignment_expression: conditional_expression
+ | logical_or_expression assignment_operator assignment_expression { $$ = YACC_ASSIGNMENT_EXPRESSION($1, $2, $3); }
+ | logical_or_expression '=' braced_initializer { $$ = YACC_ASSIGNMENT_EXPRESSION($1, $2, $3); }
+ | throw_expression
+assignment_operator: '=' | ASS_ADD | ASS_AND | ASS_DIV | ASS_MOD | ASS_MUL | ASS_OR | ASS_SHL | ASS_SHR | ASS_SUB | ASS_XOR
+
+/* expression is widely used and usually single-element, so the reductions are arranged so that a
+ * single-element expression is returned as is. Multi-element expressions are parsed as a list that
+ * may then behave polymorphically as an element or be compacted to an element. */
+expression.opt: /* empty */ { $$ = YACC_EXPRESSION(0); }
+ | expression
+expression: assignment_expression
+ | expression_list ',' assignment_expression { $$ = YACC_EXPRESSION(YACC_EXPRESSIONS($1, $3)); }
+constant_expression: conditional_expression
+
+/* The grammar is repeated for when the parser stack knows that the next > must end a template.
+ */
+templated_relational_expression: shift_expression
+ | templated_relational_expression '<' shift_expression { $$ = YACC_LESS_THAN_EXPRESSION($1, $3); }
+ | templated_relational_expression LE shift_expression { $$ = YACC_LESS_EQUAL_EXPRESSION($1, $3); }
+ | templated_relational_expression GE shift_expression { $$ = YACC_GREATER_EQUAL_EXPRESSION($1, $3); }
+templated_equality_expression: templated_relational_expression
+ | templated_equality_expression EQ templated_relational_expression { $$ = YACC_EQUAL_EXPRESSION($1, $3); }
+ | templated_equality_expression NE templated_relational_expression { $$ = YACC_NOT_EQUAL_EXPRESSION($1, $3); }
+templated_and_expression: templated_equality_expression
+ | templated_and_expression '&' templated_equality_expression { $$ = YACC_AND_EXPRESSION($1, $3); }
+templated_exclusive_or_expression: templated_and_expression
+ | templated_exclusive_or_expression '^' templated_and_expression
+ { $$ = YACC_EXCLUSIVE_OR_EXPRESSION($1, $3); }
+templated_inclusive_or_expression: templated_exclusive_or_expression
+ | templated_inclusive_or_expression '|' templated_exclusive_or_expression
+ { $$ = YACC_INCLUSIVE_OR_EXPRESSION($1, $3); }
+templated_logical_and_expression: templated_inclusive_or_expression
+ | templated_logical_and_expression LOG_AND templated_inclusive_or_expression
+ { $$ = YACC_LOGICAL_AND_EXPRESSION($1, $3); }
+templated_logical_or_expression: templated_logical_and_expression
+ | templated_logical_or_expression LOG_OR templated_logical_and_expression
+ { $$ = YACC_LOGICAL_OR_EXPRESSION($1, $3); }
+templated_conditional_expression: templated_logical_or_expression
+ | templated_logical_or_expression '?' templated_expression ':' templated_assignment_expression
+ { $$ = YACC_CONDITIONAL_EXPRESSION($1, $3, $5); }
+templated_assignment_expression: templated_conditional_expression
+ | templated_logical_or_expression assignment_operator templated_assignment_expression
+ { $$ = YACC_ASSIGNMENT_EXPRESSION($1, $2, $3); }
+ | templated_throw_expression
+templated_expression: templated_assignment_expression
+ | templated_expression_list ',' templated_assignment_expression
+ { $$ = YACC_EXPRESSION(YACC_EXPRESSIONS($1, $3)); }
+templated_expression_list: templated_assignment_expression { $$ = YACC_EXPRESSIONS(0, $1); }
+ | templated_expression_list ',' templated_assignment_expression { $$ = YACC_EXPRESSIONS($1, $3); }
+
+/*---------------------------------------------------------------------------------------------------
+ * A.5 Statements
+ *---------------------------------------------------------------------------------------------------
+ * Parsing statements is easy once simple_declaration has been generalised to cover expression_statement.
+ */
+looping_statement: start_search looped_statement { $$ = YACC_LINED_STATEMENT($2, $1); end_search($$); }
+looped_statement: statement
+ | advance_search '+' looped_statement { $$ = $3; }
+ | advance_search '-' { $$ = 0; }
+statement: control_statement
+/* | expression_statement -- covered by declaration_statement */
+ | compound_statement
+ | declaration_statement
+ | try_block { $$ = YACC_TRY_BLOCK_STATEMENT($1); }
+control_statement: labeled_statement
+ | selection_statement
+ | iteration_statement
+ | jump_statement
+labeled_statement: identifier_word ':' looping_statement { $$ = YACC_LABEL_STATEMENT($1, $3); }
+ | CASE constant_expression ':' looping_statement { $$ = YACC_CASE_STATEMENT($2, $4); }
+ | DEFAULT ':' looping_statement { $$ = YACC_DEFAULT_STATEMENT($3); }
+/*expression_statement: expression.opt ';' -- covered by declaration_statement */
+compound_statement: '{' statement_seq.opt '}' { $$ = YACC_COMPOUND_STATEMENT($2); }
+ | '{' statement_seq.opt looping_statement '#' bang error '}' { $$ = $2; YACC_UNBANG($5, "Bad statement-seq."); }
+statement_seq.opt: /* empty */ { $$ = YACC_STATEMENTS(0, 0); }
+ | statement_seq.opt looping_statement { $$ = YACC_STATEMENTS($1, YACC_COMPILE_STATEMENT($2)); }
+ | statement_seq.opt looping_statement '#' bang error ';' { $$ = $1; YACC_UNBANG($4, "Bad statement."); }
+/*
+ * The dangling else conflict is resolved to the innermost if.
+ */
+selection_statement: IF '(' condition ')' looping_statement %prec SHIFT_THERE { $$ = YACC_IF_STATEMENT($3, $5, 0); }
+ | IF '(' condition ')' looping_statement ELSE looping_statement { $$ = YACC_IF_STATEMENT($3, $5, $7); }
+ | SWITCH '(' condition ')' looping_statement { $$ = YACC_SWITCH_STATEMENT($3, $5); }
+condition.opt: /* empty */ { $$ = YACC_CONDITION(0); }
+ | condition
+condition: parameter_declaration_list { $$ = YACC_CONDITION($1); }
+/* | expression -- covered by parameter_declaration_list */
+/* | type_specifier_seq declarator '=' assignment_expression -- covered by parameter_declaration_list */
+iteration_statement: WHILE '(' condition ')' looping_statement { $$ = YACC_WHILE_STATEMENT($3, $5); }
+ | DO looping_statement WHILE '(' expression ')' ';' { $$ = YACC_DO_WHILE_STATEMENT($2, $5); }
+ | FOR '(' for_init_statement condition.opt ';' expression.opt ')' looping_statement
+ { $$ = YACC_FOR_STATEMENT($3, $4, $6, $8); }
+for_init_statement: simple_declaration
+/* | expression_statement -- covered by simple_declaration */
+jump_statement: BREAK ';' { $$ = YACC_BREAK_STATEMENT(); }
+ | CONTINUE ';' { $$ = YACC_CONTINUE_STATEMENT(); }
+ | RETURN expression.opt ';' { $$ = YACC_RETURN_STATEMENT($2); }
+ | GOTO identifier ';' { $$ = YACC_GOTO_STATEMENT($2); }
+declaration_statement: block_declaration { $$ = YACC_DECLARATION_STATEMENT($1); }
+
+/*---------------------------------------------------------------------------------------------------
+ * A.6 Declarations
+ *---------------------------------------------------------------------------------------------------*/
+compound_declaration: '{' nest declaration_seq.opt '}' { $$ = $3; unnest($2); }
+ | '{' nest declaration_seq.opt util looping_declaration '#' bang error '}'
+ { $$ = $3; unnest($2); YACC_UNBANG($7, "Bad declaration-seq."); }
+declaration_seq.opt: /* empty */ { $$ = YACC_DECLARATIONS(0, 0); }
+ | declaration_seq.opt util looping_declaration { $$ = YACC_DECLARATIONS($1, YACC_COMPILE_DECLARATION($2, $3)); }
+ | declaration_seq.opt util looping_declaration '#' bang error ';' { $$ = $1; YACC_UNBANG($5, "Bad declaration."); }
+looping_declaration: start_search1 looped_declaration { $$ = YACC_LINED_DECLARATION($2, $1); end_search($$); }
+looped_declaration: declaration
+ | advance_search '+' looped_declaration { $$ = $3; }
+ | advance_search '-' { $$ = 0; }
+declaration: block_declaration
+ | function_definition { $$ = YACC_SIMPLE_DECLARATION($1); }
+ | template_declaration
+/* | explicit_instantiation -- covered by relevant declarations */
+ | explicit_specialization
+ | specialised_declaration
+specialised_declaration: linkage_specification { $$ = YACC_LINKAGE_SPECIFICATION($1); }
+ | namespace_definition { $$ = YACC_NAMESPACE_DECLARATION($1); }
+ | TEMPLATE specialised_declaration { $$ = YACC_SET_TEMPLATE_DECLARATION($2); }
+block_declaration: simple_declaration { $$ = YACC_SIMPLE_DECLARATION($1); }
+ | specialised_block_declaration
+specialised_block_declaration: asm_definition
+ | namespace_alias_definition
+ | using_declaration
+ | using_directive
+ | TEMPLATE specialised_block_declaration { $$ = YACC_SET_TEMPLATE_DECLARATION($2); }
+simple_declaration: ';' { $$ = YACC_EXPRESSION(0); }
+ | init_declaration ';'
+ | init_declarations ';' { $$ = $1; }
+ | decl_specifier_prefix simple_declaration { $$ = YACC_DECL_SPECIFIER_EXPRESSION($2, $1); }
+
+/* A decl-specifier following a ptr_operator provokes a shift-reduce conflict for
+ * * const name
+ * which is resolved in favour of the pointer, and implemented by providing versions
+ * of decl-specifier guaranteed not to start with a cv_qualifier.
+ *
+ * decl-specifiers are implemented type-centrically. That is the semantic constraint
+ * that there must be a type is exploited to impose structure, but actually eliminate
+ * very little syntax. built-in types are multi-name and so need a different policy.
+ *
+ * non-type decl-specifiers are bound to the left-most type in a decl-specifier-seq,
+ * by parsing from the right and attaching suffixes to the right-hand type. Finally
+ * residual prefixes attach to the left.
+ */
+suffix_built_in_decl_specifier.raw: built_in_type_specifier { $$ = $1; }
+ | suffix_built_in_decl_specifier.raw built_in_type_specifier { $$ = YACC_BUILT_IN_NAME($1, $2); }
+ | suffix_built_in_decl_specifier.raw decl_specifier_suffix { $$ = YACC_DECL_SPECIFIER_NAME($1, $2); }
+suffix_built_in_decl_specifier: suffix_built_in_decl_specifier.raw { $$ = $1; }
+ | TEMPLATE suffix_built_in_decl_specifier { $$ = YACC_SET_TEMPLATE_NAME($2); }
+suffix_named_decl_specifier: scoped_id { $$ = $1; }
+ | elaborate_type_specifier { $$ = $1; }
+ | suffix_named_decl_specifier decl_specifier_suffix { $$ = YACC_DECL_SPECIFIER_NAME($1, $2); }
+suffix_named_decl_specifier.bi: suffix_named_decl_specifier { $$ = YACC_NAME_EXPRESSION($1); }
+ | suffix_named_decl_specifier suffix_built_in_decl_specifier.raw { $$ = YACC_TYPED_NAME($1, $2); }
+suffix_named_decl_specifiers: suffix_named_decl_specifier.bi
+ | suffix_named_decl_specifiers suffix_named_decl_specifier.bi { $$ = YACC_TYPED_NAME($1, $2); }
+suffix_named_decl_specifiers.sf: scoped_special_function_id /* operators etc */ { $$ = YACC_NAME_EXPRESSION($1); }
+ | suffix_named_decl_specifiers
+ | suffix_named_decl_specifiers scoped_special_function_id { $$ = YACC_TYPED_NAME($1, $2); }
+suffix_decl_specified_ids: suffix_built_in_decl_specifier
+ | suffix_built_in_decl_specifier suffix_named_decl_specifiers.sf { $$ = YACC_TYPED_NAME($1, $2); }
+ | suffix_named_decl_specifiers.sf
+suffix_decl_specified_scope: suffix_named_decl_specifiers SCOPE
+ | suffix_built_in_decl_specifier suffix_named_decl_specifiers SCOPE { $$ = YACC_TYPED_NAME($1, $2); }
+ | suffix_built_in_decl_specifier SCOPE { $$ = YACC_NAME_EXPRESSION($1); }
+
+decl_specifier_affix: storage_class_specifier
+ | function_specifier
+ | FRIEND
+ | TYPEDEF
+ | cv_qualifier { $$ = $1; }
+
+decl_specifier_suffix: decl_specifier_affix
+
+decl_specifier_prefix: decl_specifier_affix
+ | TEMPLATE decl_specifier_prefix { $$ = YACC_SET_TEMPLATE_DECL_SPECIFIER($2); }
+
+storage_class_specifier: REGISTER | STATIC | MUTABLE
+ | EXTERN %prec SHIFT_THERE /* Prefer linkage specification */
+ | AUTO
+
+function_specifier: EXPLICIT
+ | INLINE
+ | VIRTUAL
+
+type_specifier: simple_type_specifier
+ | elaborate_type_specifier
+ | cv_qualifier { $$ = YACC_CV_DECL_SPECIFIER($1); }
+
+elaborate_type_specifier: class_specifier
+ | enum_specifier
+ | elaborated_type_specifier
+ | TEMPLATE elaborate_type_specifier { $$ = YACC_SET_TEMPLATE_ID($2); }
+simple_type_specifier: scoped_id
+ | built_in_type_specifier { $$ = YACC_BUILT_IN_ID_ID($1); }
+built_in_type_specifier: CHAR | WCHAR_T | BOOL | SHORT | INT | LONG | SIGNED | UNSIGNED | FLOAT | DOUBLE | VOID
+
+/*
+ * The over-general use of declaration_expression to cover decl-specifier-seq.opt declarator in a function-definition means that
+ * class X {};
+ * could be a function-definition or a class-specifier.
+ * enum X {};
+ * could be a function-definition or an enum-specifier.
+ * The function-definition is not syntactically valid so resolving the false conflict in favour of the
+ * elaborated_type_specifier is correct.
+ */
+elaborated_type_specifier: elaborated_class_specifier
+ | elaborated_enum_specifier
+ | TYPENAME scoped_id { $$ = YACC_ELABORATED_TYPE_SPECIFIER($1, $2); }
+
+elaborated_enum_specifier: ENUM scoped_id %prec SHIFT_THERE { $$ = YACC_ELABORATED_TYPE_SPECIFIER($1, $2); }
+enum_specifier: ENUM scoped_id enumerator_clause { $$ = YACC_ENUM_SPECIFIER_ID($2, $3); }
+ | ENUM enumerator_clause { $$ = YACC_ENUM_SPECIFIER_ID(0, $2); }
+enumerator_clause: '{' enumerator_list_ecarb { $$ = YACC_ENUMERATORS(0, 0); }
+ | '{' enumerator_list enumerator_list_ecarb { $$ = $2; }
+ | '{' enumerator_list ',' enumerator_definition_ecarb { $$ = $2; }
+enumerator_list_ecarb: '}' { }
+ | bang error '}' { YACC_UNBANG($1, "Bad enumerator-list."); }
+enumerator_definition_ecarb: '}' { }
+ | bang error '}' { YACC_UNBANG($1, "Bad enumerator-definition."); }
+enumerator_definition_filler: /* empty */
+ | bang error ',' { YACC_UNBANG($1, "Bad enumerator-definition."); }
+enumerator_list_head: enumerator_definition_filler { $$ = YACC_ENUMERATORS(0, 0); }
+ | enumerator_list ',' enumerator_definition_filler
+enumerator_list: enumerator_list_head enumerator_definition { $$ = YACC_ENUMERATORS($1, $2); }
+enumerator_definition: enumerator { $$ = YACC_ENUMERATOR($1, 0); }
+ | enumerator '=' constant_expression { $$ = YACC_ENUMERATOR($1, $3); }
+enumerator: identifier
+
+namespace_definition: NAMESPACE scoped_id compound_declaration { $$ = YACC_NAMESPACE_DEFINITION($2, $3); }
+ | NAMESPACE compound_declaration { $$ = YACC_NAMESPACE_DEFINITION(0, $2); }
+namespace_alias_definition: NAMESPACE scoped_id '=' scoped_id ';' { $$ = YACC_NAMESPACE_ALIAS_DEFINITION($2, $4); }
+
+using_declaration: USING declarator_id ';' { $$ = YACC_USING_DECLARATION(false, $2); }
+ | USING TYPENAME declarator_id ';' { $$ = YACC_USING_DECLARATION(true, $3); }
+
+using_directive: USING NAMESPACE scoped_id ';' { $$ = YACC_USING_DIRECTIVE($3); }
+asm_definition: ASM '(' string ')' ';' { $$ = YACC_ASM_DEFINITION($3); }
+linkage_specification: EXTERN string looping_declaration { $$ = YACC_LINKAGE_SPECIFIER($2, $3); }
+ | EXTERN string compound_declaration { $$ = YACC_LINKAGE_SPECIFIER($2, $3); }
+
+/*---------------------------------------------------------------------------------------------------
+ * A.7 Declarators
+ *---------------------------------------------------------------------------------------------------*/
+/*init-declarator is named init_declaration to reflect the embedded decl-specifier-seq.opt*/
+init_declarations: assignment_expression ',' init_declaration { $$ = YACC_EXPRESSIONS(YACC_EXPRESSIONS(0, $1), $3); }
+ | init_declarations ',' init_declaration { $$ = YACC_EXPRESSIONS($1, $3); }
+init_declaration: assignment_expression
+/* | assignment_expression '=' initializer_clause -- covered by assignment_expression */
+/* | assignment_expression '(' expression_list ')' -- covered by another set of call arguments */
+
+/*declarator: -- covered by assignment_expression */
+/*direct_declarator: -- covered by postfix_expression */
+
+star_ptr_operator: '*' { $$ = YACC_POINTER_DECLARATOR(); }
+ | star_ptr_operator cv_qualifier { $$ = YACC_CV_DECLARATOR($1, $2); }
+nested_ptr_operator: star_ptr_operator { $$ = $1; }
+ | id_scope nested_ptr_operator { $$ = YACC_NESTED_DECLARATOR($1, $2); }
+ptr_operator: '&' { $$ = YACC_REFERENCE_DECLARATOR(); }
+ | nested_ptr_operator { $$ = $1; }
+ | global_scope nested_ptr_operator { $$ = YACC_GLOBAL_DECLARATOR($1, $2); }
+ptr_operator_seq: ptr_operator { $$ = YACC_POINTER_EXPRESSION($1, YACC_EPSILON()); }
+ | ptr_operator ptr_operator_seq { $$ = YACC_POINTER_EXPRESSION($1, $2); }
+/* Independently coded to localise the shift-reduce conflict: sharing just needs another %prec */
+ptr_operator_seq.opt: /* empty */ %prec SHIFT_THERE /* Maximise type length */ { $$ = YACC_EXPRESSION(0); }
+ | ptr_operator ptr_operator_seq.opt { $$ = YACC_POINTER_EXPRESSION($1, $2); }
+
+cv_qualifier_seq.opt: /* empty */ { $$ = YACC_CV_QUALIFIERS(0, 0); }
+ | cv_qualifier_seq.opt cv_qualifier { $$ = YACC_CV_QUALIFIERS($1, $2); }
+cv_qualifier: CONST | VOLATILE /* | CvQualifier */
+
+/*type_id -- also covered by parameter declaration */
+type_id: type_specifier abstract_declarator.opt { $$ = YACC_TYPED_EXPRESSION($1, $2); }
+ | type_specifier type_id { $$ = YACC_TYPED_EXPRESSION($1, $2); }
+
+/*abstract_declarator: -- also covered by parameter declaration */
+abstract_declarator.opt: /* empty */ { $$ = YACC_EPSILON(); }
+ | ptr_operator abstract_declarator.opt { $$ = YACC_POINTER_EXPRESSION($1, $2); }
+ | direct_abstract_declarator
+direct_abstract_declarator.opt: /* empty */ { $$ = YACC_EPSILON(); }
+ | direct_abstract_declarator
+direct_abstract_declarator: direct_abstract_declarator.opt parenthesis_clause { $$ = YACC_CALL_EXPRESSION($1, $2); }
+ | direct_abstract_declarator.opt '[' ']' { $$ = YACC_ARRAY_EXPRESSION($1, 0); }
+ | direct_abstract_declarator.opt '[' constant_expression ']' { $$ = YACC_ARRAY_EXPRESSION($1, $3); }
+/* | '(' abstract_declarator ')' -- covered by parenthesis_clause */
+
+parenthesis_clause: parameters_clause cv_qualifier_seq.opt { $$ = YACC_PARENTHESISED($1, $2, 0); }
+ | parameters_clause cv_qualifier_seq.opt exception_specification { $$ = YACC_PARENTHESISED($1, $2, $3); }
+parameters_clause: '(' parameter_declaration_clause ')' { $$ = $2; }
+/* parameter_declaration_clause also covers init_declaration, type_id, declarator and abstract_declarator. */
+parameter_declaration_clause: /* empty */ { $$ = YACC_PARAMETERS(0, 0); }
+ | parameter_declaration_list
+ | parameter_declaration_list ELLIPSIS { $$ = YACC_PARAMETERS($1, YACC_ELLIPSIS_EXPRESSION()); }
+parameter_declaration_list: parameter_declaration { $$ = YACC_PARAMETERS(0, $1); }
+ | parameter_declaration_list ',' parameter_declaration { $$ = YACC_PARAMETERS($1, $3); }
+
+/* A typed abstract qualifier such as
+ * Class * ...
+ * looks like a multiply, so pointers are parsed as their binary operation equivalents that
+ * ultimately terminate with a degenerate right hand term.
+ */
+abstract_pointer_declaration: ptr_operator_seq
+ | multiplicative_expression star_ptr_operator ptr_operator_seq.opt { $$ = YACC_MULTIPLY_EXPRESSION($1, $2, $3); }
+abstract_parameter_declaration: abstract_pointer_declaration
+ | and_expression '&' { $$ = YACC_AND_EXPRESSION($1, YACC_EPSILON()); }
+ | and_expression '&' abstract_pointer_declaration { $$ = YACC_AND_EXPRESSION($1, $3); }
+special_parameter_declaration: abstract_parameter_declaration
+ | abstract_parameter_declaration '=' assignment_expression { $$ = YACC_ASSIGNMENT_EXPRESSION($1, $2, $3); }
+ | ELLIPSIS { $$ = YACC_ELLIPSIS_EXPRESSION(); }
+parameter_declaration: assignment_expression { $$ = YACC_EXPRESSION_PARAMETER($1); }
+ | special_parameter_declaration { $$ = YACC_EXPRESSION_PARAMETER($1); }
+ | decl_specifier_prefix parameter_declaration { $$ = YACC_DECL_SPECIFIER_PARAMETER($2, $1); }
+
+/* The grammar is repeated for use within template <>
+ */
+templated_parameter_declaration: templated_assignment_expression { $$ = YACC_EXPRESSION_PARAMETER($1); }
+ | templated_abstract_declaration { $$ = YACC_EXPRESSION_PARAMETER($1); }
+ | templated_abstract_declaration '=' templated_assignment_expression
+ { $$ = YACC_EXPRESSION_PARAMETER(YACC_ASSIGNMENT_EXPRESSION($1, $2, $3)); }
+ | decl_specifier_prefix templated_parameter_declaration { $$ = YACC_DECL_SPECIFIER_PARAMETER($2, $1); }
+templated_abstract_declaration: abstract_pointer_declaration
+ | templated_and_expression '&' { $$ = YACC_AND_EXPRESSION($1, 0); }
+ | templated_and_expression '&' abstract_pointer_declaration { $$ = YACC_AND_EXPRESSION($1, $3); }
+
+/* function_definition includes constructor, destructor, implicit int definitions too.
+ * A local destructor is successfully parsed as a function-declaration but the ~ was treated as a unary operator.
+ * constructor_head is the prefix ambiguity between a constructor and a member-init-list starting with a bit-field.
+ */
+function_definition: ctor_definition
+ | func_definition
+func_definition: assignment_expression function_try_block { $$ = YACC_FUNCTION_DEFINITION($1, $2); }
+ | assignment_expression function_body { $$ = YACC_FUNCTION_DEFINITION($1, $2); }
+ | decl_specifier_prefix func_definition { $$ = YACC_DECL_SPECIFIER_EXPRESSION($2, $1); }
+ctor_definition: constructor_head function_try_block { $$ = YACC_CTOR_DEFINITION($1, $2); }
+ | constructor_head function_body { $$ = YACC_CTOR_DEFINITION($1, $2); }
+ | decl_specifier_prefix ctor_definition { $$ = YACC_DECL_SPECIFIER_EXPRESSION($2, $1); }
+constructor_head: bit_field_init_declaration { $$ = YACC_EXPRESSIONS(0, $1); }
+ | constructor_head ',' assignment_expression { $$ = YACC_EXPRESSIONS($1, $3); }
+function_try_block: TRY function_block handler_seq { $$ = YACC_TRY_FUNCTION_BLOCK($2, $3); }
+function_block: ctor_initializer.opt function_body { $$ = YACC_CTOR_FUNCTION_BLOCK($2, $1); }
+function_body: compound_statement { $$ = YACC_FUNCTION_BLOCK($1); }
+
+/* An = initializer looks like an extended assignment_expression.
+ * An () initializer looks like a function call.
+ * initializer is therefore flattened into its generalised customers.
+ *initializer: '=' initializer_clause -- flattened into caller
+ * | '(' expression_list ')' -- flattened into caller */
+initializer_clause: assignment_expression { $$ = YACC_INITIALIZER_EXPRESSION_CLAUSE($1); }
+ | braced_initializer
+braced_initializer: '{' initializer_list '}' { $$ = YACC_INITIALIZER_LIST_CLAUSE($2); }
+ | '{' initializer_list ',' '}' { $$ = YACC_INITIALIZER_LIST_CLAUSE($2); }
+ | '{' '}' { $$ = YACC_INITIALIZER_LIST_CLAUSE(0); }
+ | '{' looping_initializer_clause '#' bang error '}' { $$ = 0; YACC_UNBANG($4, "Bad initializer_clause."); }
+ | '{' initializer_list ',' looping_initializer_clause '#' bang error '}'
+ { $$ = $2; YACC_UNBANG($6, "Bad initializer_clause."); }
+initializer_list: looping_initializer_clause { $$ = YACC_INITIALIZER_CLAUSES(0, $1); }
+ | initializer_list ',' looping_initializer_clause { $$ = YACC_INITIALIZER_CLAUSES($1, $3); }
+looping_initializer_clause: start_search looped_initializer_clause { $$ = $2; end_search($$); }
+looped_initializer_clause: initializer_clause
+ | advance_search '+' looped_initializer_clause { $$ = $3; }
+ | advance_search '-' { $$ = 0; }
+
+/*---------------------------------------------------------------------------------------------------
+ * A.8 Classes
+ *---------------------------------------------------------------------------------------------------
+ *
+ * An anonymous bit-field declaration may look very like inheritance:
+ * class A : B = 3;
+ * class A : B ;
+ * The two usages are too distant to try to create and enforce a common prefix so we have to resort to
+ * a parser hack by backtracking. Inheritance is much the most likely so we mark the input stream context
+ * and try to parse a base-clause. If we successfully reach a { the base-clause is ok and inheritance was
+ * the correct choice so we unmark and continue. If we fail to find the { an error token causes back-tracking
+ * to the alternative parse in elaborated_class_specifier which regenerates the : and declares unconditional success.
+ */
+colon_mark: ':' { $$ = mark(); }
+elaborated_class_specifier: class_key scoped_id %prec SHIFT_THERE { $$ = YACC_ELABORATED_TYPE_SPECIFIER($1, $2); }
+ | class_key scoped_id colon_mark error { $$ = YACC_ELABORATED_TYPE_SPECIFIER($1, $2); rewind_colon($3, $$); }
+class_specifier_head: class_key scoped_id colon_mark base_specifier_list '{' { unmark($4); $$ = YACC_CLASS_SPECIFIER_ID($1, $2, $4); }
+ | class_key ':' base_specifier_list '{' { $$ = YACC_CLASS_SPECIFIER_ID($1, 0, $3); }
+ | class_key scoped_id '{' { $$ = YACC_CLASS_SPECIFIER_ID($1, $2, 0); }
+ | class_key '{' { $$ = YACC_CLASS_SPECIFIER_ID($1, 0, 0); }
+class_key: CLASS | STRUCT | UNION
+class_specifier: class_specifier_head member_specification.opt '}' { $$ = YACC_CLASS_MEMBERS($1, $2); }
+ | class_specifier_head member_specification.opt util looping_member_declaration '#' bang error '}'
+ { $$ = YACC_CLASS_MEMBERS($1, $2); YACC_UNBANG($6, "Bad member_specification.opt."); }
+member_specification.opt: /* empty */ { $$ = YACC_MEMBER_DECLARATIONS(0, 0); }
+ | member_specification.opt util looping_member_declaration { $$ = YACC_MEMBER_DECLARATIONS($1, YACC_COMPILE_DECLARATION($2, $3)); }
+ | member_specification.opt util looping_member_declaration '#' bang error ';'
+ { $$ = $1; YACC_UNBANG($5, "Bad member-declaration."); }
+looping_member_declaration: start_search looped_member_declaration { $$ = YACC_LINED_DECLARATION($2, $1); end_search($$); }
+looped_member_declaration: member_declaration
+ | advance_search '+' looped_member_declaration { $$ = $3; }
+ | advance_search '-' { $$ = 0; }
+member_declaration: accessibility_specifier
+ | simple_member_declaration { $$ = YACC_SIMPLE_DECLARATION($1); }
+ | function_definition { $$ = YACC_SIMPLE_DECLARATION($1); }
+/* | function_definition ';' -- trailing ; covered by null declaration */
+/* | qualified_id ';' -- covered by simple_member_declaration */
+ | using_declaration
+ | template_declaration
+
+/* The generality of constructor names (there need be no parenthesised argument list) means that that
+ * name : f(g), h(i)
+ * could be the start of a constructor or the start of an anonymous bit-field. An ambiguity is avoided by
+ * parsing the ctor-initializer of a function_definition as a bit-field.
+ */
+simple_member_declaration: ';' { $$ = YACC_EXPRESSION(0); }
+ | assignment_expression ';'
+ | constructor_head ';' { $$ = $1; }
+ | member_init_declarations ';' { $$ = $1; }
+ | decl_specifier_prefix simple_member_declaration { $$ = YACC_DECL_SPECIFIER_EXPRESSION($2, $1); }
+member_init_declarations: assignment_expression ',' member_init_declaration { $$ = YACC_EXPRESSIONS(YACC_EXPRESSIONS(0, $1), $3); }
+ | constructor_head ',' bit_field_init_declaration { $$ = YACC_EXPRESSIONS($1, $3); }
+ | member_init_declarations ',' member_init_declaration { $$ = YACC_EXPRESSIONS($1, $3); }
+member_init_declaration: assignment_expression
+/* | assignment_expression '=' initializer_clause -- covered by assignment_expression */
+/* | assignment_expression '(' expression_list ')' -- covered by another set of call arguments */
+ | bit_field_init_declaration
+accessibility_specifier: access_specifier ':' { $$ = YACC_ACCESSIBILITY_SPECIFIER($1); }
+bit_field_declaration: assignment_expression ':' bit_field_width { $$ = YACC_BIT_FIELD_EXPRESSION($1, $3); }
+ | ':' bit_field_width { $$ = YACC_BIT_FIELD_EXPRESSION(0, $2); }
+bit_field_width: logical_or_expression
+/* | logical_or_expression '?' expression ':' assignment_expression -- has SR conflict w.r.t later = */
+ | logical_or_expression '?' bit_field_width ':' bit_field_width { $$ = YACC_CONDITIONAL_EXPRESSION($1, $3, $5); }
+bit_field_init_declaration: bit_field_declaration
+ | bit_field_declaration '=' initializer_clause { $$ = YACC_ASSIGNMENT_EXPRESSION($1, $2, $3); }
+
+/*---------------------------------------------------------------------------------------------------
+ * A.9 Derived classes
+ *---------------------------------------------------------------------------------------------------*/
+/*base_clause: ':' base_specifier_list -- flattened */
+base_specifier_list: base_specifier { $$ = YACC_BASE_SPECIFIERS(0, $1); }
+ | base_specifier_list ',' base_specifier { $$ = YACC_BASE_SPECIFIERS($1, $3); }
+base_specifier: scoped_id { $$ = YACC_BASE_SPECIFIER($1); }
+ | access_specifier base_specifier { $$ = YACC_ACCESS_BASE_SPECIFIER($2, $1); }
+ | VIRTUAL base_specifier { $$ = YACC_VIRTUAL_BASE_SPECIFIER($2); }
+access_specifier: PRIVATE | PROTECTED | PUBLIC
+
+/*---------------------------------------------------------------------------------------------------
+ * A.10 Special member functions
+ *---------------------------------------------------------------------------------------------------*/
+conversion_function_id: OPERATOR conversion_type_id { $$ = YACC_CONVERSION_FUNCTION_ID($2); }
+conversion_type_id: type_specifier ptr_operator_seq.opt { $$ = YACC_TYPED_EXPRESSION($1, $2); }
+ | type_specifier conversion_type_id { $$ = YACC_TYPED_EXPRESSION($1, $2); }
+/*
+ * Ctor-initialisers can look like a bit field declaration, given the generalisation of names:
+ * Class(Type) : m1(1), m2(2) {}
+ * NonClass(bit_field) : int(2), second_variable, ...
+ * The grammar below is used within a function_try_block or function_definition.
+ * See simple_member_declaration for use in normal member function_definition.
+ */
+ctor_initializer.opt: /* empty */ { $$ = YACC_MEM_INITIALIZERS(0, 0); }
+ | ctor_initializer
+ctor_initializer: ':' mem_initializer_list { $$ = $2; }
+ | ':' mem_initializer_list bang error { $$ = $2; YACC_UNBANG($3, "Bad ctor-initializer."); }
+mem_initializer_list: mem_initializer { $$ = YACC_MEM_INITIALIZERS(0, $1); }
+ | mem_initializer_list_head mem_initializer { $$ = YACC_MEM_INITIALIZERS($1, $2); }
+mem_initializer_list_head: mem_initializer_list ','
+ | mem_initializer_list bang error ',' { YACC_UNBANG($2, "Bad mem-initializer."); }
+mem_initializer: mem_initializer_id '(' expression_list.opt ')' { $$ = YACC_MEM_INITIALIZER($1, $3); }
+mem_initializer_id: scoped_id
+
+/*---------------------------------------------------------------------------------------------------
+ * A.11 Overloading
+ *---------------------------------------------------------------------------------------------------*/
+operator_function_id: OPERATOR operator { $$ = YACC_OPERATOR_FUNCTION_ID($2); }
+/*
+ * It is not clear from the ANSI standard whether spaces are permitted in delete[]. If not then it can
+ * be recognised and returned as DELETE_ARRAY by the lexer. Assuming spaces are permitted there is an
+ * ambiguity created by the over generalised nature of expressions. operator new is a valid delarator-id
+ * which we may have an undimensioned array of. Semantic rubbish, but syntactically valid. Since the
+ * array form is covered by the declarator consideration we can exclude the operator here. The need
+ * for a semantic rescue can be eliminated at the expense of a couple of shift-reduce conflicts by
+ * removing the comments on the next four lines.
+ */
+operator: /*++++*/ NEW { $$ = YACC_OPERATOR_NEW_ID(); }
+ | /*++++*/ DELETE { $$ = YACC_OPERATOR_DELETE_ID(); }
+/* | / ---- / NEW %prec SHIFT_THERE { $$ = YACC_OPERATOR_NEW_ID(); }
+/* | / ---- / DELETE %prec SHIFT_THERE { $$ = YACC_OPERATOR_DELETE_ID(); }
+/* | / ---- / NEW '[' ']' -- Covered by array of OPERATOR NEW */
+/* | / ---- / DELETE '[' ']' -- Covered by array of OPERATOR DELETE */
+ | '+' { $$ = YACC_OPERATOR_ADD_ID(); }
+ | '-' { $$ = YACC_OPERATOR_SUB_ID(); }
+ | '*' { $$ = YACC_OPERATOR_MUL_ID(); }
+ | '/' { $$ = YACC_OPERATOR_DIV_ID(); }
+ | '%' { $$ = YACC_OPERATOR_MOD_ID(); }
+ | '^' { $$ = YACC_OPERATOR_XOR_ID(); }
+ | '&' { $$ = YACC_OPERATOR_BIT_AND_ID(); }
+ | '|' { $$ = YACC_OPERATOR_BIT_OR_ID(); }
+ | '~' { $$ = YACC_OPERATOR_BIT_NOT_ID(); }
+ | '!' { $$ = YACC_OPERATOR_LOG_NOT_ID(); }
+ | '=' { $$ = YACC_OPERATOR_ASS_ID(); }
+ | '<' { $$ = YACC_OPERATOR_LT_ID(); }
+ | '>' { $$ = YACC_OPERATOR_GT_ID(); }
+ | ASS_ADD { $$ = YACC_OPERATOR_ASS_ADD_ID(); }
+ | ASS_SUB { $$ = YACC_OPERATOR_ASS_SUB_ID(); }
+ | ASS_MUL { $$ = YACC_OPERATOR_ASS_MUL_ID(); }
+ | ASS_DIV { $$ = YACC_OPERATOR_ASS_DIV_ID(); }
+ | ASS_MOD { $$ = YACC_OPERATOR_ASS_MOD_ID(); }
+ | ASS_XOR { $$ = YACC_OPERATOR_ASS_XOR_ID(); }
+ | ASS_AND { $$ = YACC_OPERATOR_ASS_BIT_AND_ID(); }
+ | ASS_OR { $$ = YACC_OPERATOR_ASS_BIT_OR_ID(); }
+ | SHL { $$ = YACC_OPERATOR_SHL_ID(); }
+ | SHR { $$ = YACC_OPERATOR_SHR_ID(); }
+ | ASS_SHR { $$ = YACC_OPERATOR_ASS_SHR_ID(); }
+ | ASS_SHL { $$ = YACC_OPERATOR_ASS_SHL_ID(); }
+ | EQ { $$ = YACC_OPERATOR_EQ_ID(); }
+ | NE { $$ = YACC_OPERATOR_NE_ID(); }
+ | LE { $$ = YACC_OPERATOR_LE_ID(); }
+ | GE { $$ = YACC_OPERATOR_GE_ID(); }
+ | LOG_AND { $$ = YACC_OPERATOR_LOG_AND_ID(); }
+ | LOG_OR { $$ = YACC_OPERATOR_LOG_OR_ID(); }
+ | INC { $$ = YACC_OPERATOR_INC_ID(); }
+ | DEC { $$ = YACC_OPERATOR_DEC_ID(); }
+ | ',' { $$ = YACC_OPERATOR_COMMA_ID(); }
+ | ARROW_STAR { $$ = YACC_OPERATOR_ARROW_STAR_ID(); }
+ | ARROW { $$ = YACC_OPERATOR_ARROW_ID(); }
+ | '(' ')' { $$ = YACC_OPERATOR_CALL_ID(); }
+ | '[' ']' { $$ = YACC_OPERATOR_INDEX_ID(); }
+
+/*---------------------------------------------------------------------------------------------------
+ * A.12 Templates
+ *---------------------------------------------------------------------------------------------------*/
+template_declaration: template_parameter_clause declaration { $$ = YACC_TEMPLATE_DECLARATION($1, $2); }
+ | EXPORT template_declaration { $$ = YACC_DECL_SPECIFIER_DECLARATION($2, $1); }
+template_parameter_clause: TEMPLATE '<' template_parameter_list '>' { $$ = $3; }
+template_parameter_list: template_parameter { $$ = YACC_TEMPLATE_PARAMETERS(0, $1); }
+ | template_parameter_list ',' template_parameter { $$ = YACC_TEMPLATE_PARAMETERS($1, $3); }
+template_parameter: simple_type_parameter { $$ = YACC_INIT_SIMPLE_TYPE_PARAMETER($1, 0); }
+ | simple_type_parameter '=' type_id { $$ = YACC_INIT_SIMPLE_TYPE_PARAMETER($1, $3); }
+ | templated_type_parameter { $$ = YACC_INIT_TEMPLATED_PARAMETER($1, 0); }
+ | templated_type_parameter '=' identifier { $$ = YACC_INIT_TEMPLATED_PARAMETER($1, $3); }
+ | templated_parameter_declaration { $$ = YACC_TEMPLATE_PARAMETER($1); }
+ | bang error { $$ = 0; YACC_UNBANG($1, "Bad template-parameter."); }
+simple_type_parameter: CLASS { $$ = YACC_CLASS_TYPE_PARAMETER(0); }
+/* | CLASS identifier -- covered by parameter_declaration */
+ | TYPENAME { $$ = YACC_TYPENAME_TYPE_PARAMETER(0); }
+/* | TYPENAME identifier -- covered by parameter_declaration */
+templated_type_parameter: template_parameter_clause CLASS { $$ = YACC_TEMPLATED_TYPE_PARAMETER($1, 0); }
+ | template_parameter_clause CLASS identifier { $$ = YACC_TEMPLATED_TYPE_PARAMETER($1, $3); }
+template_id: TEMPLATE identifier '<' template_argument_list '>' { $$ = YACC_TEMPLATE_NAME($2, $4); }
+ | TEMPLATE template_id { $$ = $2; }
+/*
+ * template-argument is evaluated using a templated...expression so that > resolves to end of template.
+ */
+template_argument_list: template_argument { $$ = YACC_TEMPLATE_ARGUMENTS(0, $1); }
+ | template_argument_list ',' template_argument { $$ = YACC_TEMPLATE_ARGUMENTS($1, $3); }
+template_argument: templated_parameter_declaration { $$ = YACC_TEMPLATE_ARGUMENT($1); }
+/* | type_id -- covered by templated_parameter_declaration */
+/* | template_name -- covered by templated_parameter_declaration */
+/* | error -- must allow template failure to re-search */
+
+/*
+ * Generalised naming makes identifier a valid declaration, so TEMPLATE identifier is too.
+ * The TEMPLATE prefix is therefore folded into all names, parenthesis_clause and decl_specifier_prefix.
+ */
+/*explicit_instantiation: TEMPLATE declaration */
+explicit_specialization: TEMPLATE '<' '>' declaration { $$ = YACC_EXPLICIT_SPECIALIZATION($4); }
+
+/*---------------------------------------------------------------------------------------------------
+ * A.13 Exception Handling
+ *---------------------------------------------------------------------------------------------------*/
+try_block: TRY compound_statement handler_seq { $$ = YACC_TRY_BLOCK($2, $3); }
+/*function_try_block: -- moved near function_block */
+handler_seq: handler { $$ = YACC_HANDLERS(0, $1); }
+ | handler handler_seq { $$ = YACC_HANDLERS($2, $1); }
+handler: CATCH '(' exception_declaration ')' compound_statement { $$ = YACC_HANDLER($3, $5); }
+exception_declaration: parameter_declaration { $$ = YACC_EXCEPTION_DECLARATION($1); }
+/* ELLIPSIS -- covered by parameter_declaration */
+throw_expression: THROW { $$ = YACC_THROW_EXPRESSION(0); }
+ | THROW assignment_expression { $$ = YACC_THROW_EXPRESSION($2); }
+templated_throw_expression: THROW { $$ = YACC_THROW_EXPRESSION(0); }
+ | THROW templated_assignment_expression { $$ = YACC_THROW_EXPRESSION($2); }
+exception_specification: THROW '(' ')' { $$ = YACC_EXCEPTION_SPECIFICATION(0); }
+ | THROW '(' type_id_list ')' { $$ = YACC_EXCEPTION_SPECIFICATION($3); }
+type_id_list: type_id { $$ = YACC_EXPRESSIONS(0, $1); }
+ | type_id_list ',' type_id { $$ = YACC_EXPRESSIONS($1, $3); }
+
+/*---------------------------------------------------------------------------------------------------
+ * Back-tracking and context support
+ *---------------------------------------------------------------------------------------------------*/
+advance_search: error { yyerrok; advance_search(); } /* Rewind and queue '+' or '-' '#' */
+bang: /* empty */ { $$ = YACC_BANG(); } /* set flag to suppress "parse error" */
+mark: /* empty */ { $$ = mark(); } /* Push lookahead and input token stream context onto a stack */
+nest: /* empty */ { $$ = nest(); } /* Push a declaration nesting depth onto the parse stack */
+start_search: /* empty */ { $$ = YACC_LINE(); start_search(false); } /* Create/reset binary search context */
+start_search1: /* empty */ { $$ = YACC_LINE(); start_search(true); } /* Create/reset binary search context */
+util: /* empty */ { $$ = YACC_UTILITY_MODE(); } /* Get current utility mode */
+/*StartTester*/
+%%
+#include <CxxParsing.cxx>
+/*EndTester*/
--- /dev/null
+#include <iostream.h>
+#include <memory.h>
+#include <CxxToken.hxx>
+
+extern CxxToken *yylex_token();
+
+#ifdef BISON_PP_CLASS
+BISON_PP_CLASS theParser;
+#define PARSE_DOT theParser .
+#define PARSE_SCOPE BISON_PP_CLASS ::
+#else
+#define PARSE_DOT
+#define PARSE_SCOPE
+extern int yydebug;
+#ifndef YYEMPTY
+#define YYEMPTY -1
+#endif
+#endif
+
+class CxxSearchContext
+{
+ friend class ios; // Suppress GNU error message for no public constructors.
+ CxxSearchContext *_next;
+ size_t _index;
+ size_t _depth;
+ size_t _size;
+ size_t _mark;
+ bool _enable_type1;
+ size_t _line;
+ size_t _advances;
+ bool _status[32];
+private:
+ CxxSearchContext(CxxSearchContext *nextSearch)
+ : _next(nextSearch), _index(0), _depth(0), _size(sizeof(_status)/sizeof(_status[0])),
+ _mark(0), _enable_type1(false), _line(0), _advances(0) {}
+ CxxSearchContext(const CxxSearchContext&);
+ CxxSearchContext& operator=(const CxxSearchContext&);
+ bool did_search() const { return _depth > 0 ? true : false; }
+ void initialise(size_t markIndex, bool enableType1);
+ CxxSearchContext *queue(CxxSearchContext *& listHead);
+ void reset();
+public:
+ bool advance();
+ bool enable_type1() const { return _enable_type1; }
+ bool is_template();
+ size_t mark() const { return _mark; }
+private:
+ static CxxSearchContext *_current;
+ static CxxSearchContext *_free;
+public:
+ static size_t actual_searches;
+ static size_t advances[16];
+ static size_t max_search_depth;
+ static size_t nested_searches;
+ static size_t releases;
+ static size_t search_advances;
+ static size_t unnested_searches;
+public:
+ static CxxSearchContext *current() { return _current; }
+ static void release();
+ static void start(YACC_MARK_TYPE anIndex, bool enableType1);
+};
+
+size_t bang_depth = 0;
+size_t error_count = 0;
+size_t marked_error_count = 0;
+bool in_type1 = false;
+bool show_marked = false;
+
+int main(int argc, char *argv[])
+{
+ for (--argc, ++argv; argc-- > 0; ++argv)
+ {
+ char *p = *argv;
+ if (*p == '-')
+ {
+ switch (*(p+1))
+ {
+ case 'c':
+ c_keywords = true;
+ break;
+ case 't':
+ echo_line_text = true;
+ break;
+ case 'm':
+ show_marked = true;
+ break;
+ case 'n':
+ echo_line_numbers = true;
+ break;
+ case 'y':
+ PARSE_DOT yydebug = true;
+ break;
+ }
+ }
+ }
+ if (PARSE_DOT yyparse() != 0)
+ ERRMSG("Failed to parse to end of file,");
+ cout << "error_count = " << error_count
+ << ", marked_error_count = " << marked_error_count
+ << ", lines = " << line_number
+ << ", unnested_searches = " << CxxSearchContext::unnested_searches
+ << ", nested_searches = " << CxxSearchContext::nested_searches
+ << ", releases = " << CxxSearchContext::releases
+ << ", actual_searches = " << CxxSearchContext::actual_searches
+ << ", max_search_depth = " << CxxSearchContext::max_search_depth
+ << ", search_advances = " << CxxSearchContext::search_advances << endl;
+ cout << "number of occurences of each advance";
+ for (size_t i = 0; i < sizeof(CxxSearchContext::advances)/sizeof(CxxSearchContext::advances[0]); i++)
+ cout << ' ' << CxxSearchContext::advances[i];
+ cout << endl;
+ return 0;
+}
+
+static CxxToken **tokenBuffer = 0; // Allocated buffer
+static YACC_MARK_TYPE tokenReadIndex = 0; // Read index
+static size_t tokenSize = 0; // Allocate buffer size
+static YACC_MARK_TYPE tokenWriteIndex = 0; // Write index
+int tokenMarkDepth = 0; // Write index
+static CxxToken *primed_tokens[3] = {0, 0}; // Restarting sequence
+static void token_put(CxxToken *aToken);
+
+CxxSearchContext *CxxSearchContext::_current = 0;
+CxxSearchContext *CxxSearchContext::_free = 0;
+size_t CxxSearchContext::actual_searches = 0;
+size_t CxxSearchContext::advances[16] = { 0 };
+size_t CxxSearchContext::max_search_depth = 0;
+size_t CxxSearchContext::nested_searches = 0;
+size_t CxxSearchContext::releases = 0;
+size_t CxxSearchContext::search_advances;
+size_t CxxSearchContext::unnested_searches;
+
+//
+// Implements a binary search counter, performing the increment at the
+// _index of othe failed search.
+//
+bool CxxSearchContext::advance()
+{
+ _advances++;
+ size_t i = _depth;
+ if (i <= 0)
+ return false;
+ while (--i > _index)
+ _status[i] = false;
+ while (true)
+ {
+ if (!_status[i])
+ {
+ _status[i] = true;
+ _index = 0;
+ return true;
+ }
+ if (i <= 0)
+ return false;
+ _status[i--] = false;
+ }
+}
+
+void CxxSearchContext::initialise(size_t markIndex, bool enableType1)
+{
+ _index = 0;
+ _depth = 0;
+ _mark = markIndex;
+ _enable_type1 = enableType1;
+ _line = line_number;
+ _advances = 0;
+}
+
+bool CxxSearchContext::is_template()
+{
+ if (_index >= _depth)
+ {
+ if (_depth >= _size)
+ {
+ ERRMSG("Binary search depth exceeded.");
+ return false;
+ }
+ _status[_depth++] = false;
+ if (_depth > max_search_depth)
+ max_search_depth = _depth;
+ }
+ return _status[_index++] ? false : true;
+}
+
+//
+// Put this element onto listHead, returning element under this one.
+//
+CxxSearchContext *CxxSearchContext::queue(CxxSearchContext *& listHead)
+{
+ CxxSearchContext *oldNext = _next;
+ _next = listHead;
+ listHead = this;
+ return oldNext;
+}
+
+//
+// Release the current search buffer.
+//
+void CxxSearchContext::release()
+{
+ if (_current)
+ {
+ releases++;
+ _current->reset();
+ _current = _current->queue(_free);
+ }
+}
+
+void CxxSearchContext::reset()
+{
+ if (did_search())
+ {
+ _advances++;
+ actual_searches++;
+ }
+ if (_advances >= sizeof(advances)/sizeof(advances[0]))
+ advances[sizeof(advances)/sizeof(advances[0])-1]++;
+ else
+ advances[_advances]++;
+}
+
+void CxxSearchContext::start(YACC_MARK_TYPE anIndex, bool enableType1)
+{
+ if (!_current)
+ unnested_searches++;
+ else
+ nested_searches++;
+ if (!_free)
+ _current = new CxxSearchContext(_current);
+ else
+ _free = _free->queue(_current);
+ _current->initialise(anIndex, enableType1);
+}
+
+static CxxToken angleToken('<');
+static CxxToken colonToken(':');
+static CxxToken hashToken('#');
+static CxxToken plusToken('+');
+static CxxToken minusToken('-');
+
+void PARSE_SCOPE yyerror(const char *s)
+{
+ if (!bang_depth && (tokenMarkDepth == 0))
+ {
+ cout << s << endl;
+ increment_error_count();
+ }
+ else
+ {
+ if (show_marked)
+ cout << "Marked " << s << endl;
+ marked_error_count++;
+ }
+}
+
+//
+// Get the next token for the parser, invoking yylex_token to get the next token from the lexer.
+// This routine gets renamed to buffered_yylex by a #define when using yacc so that the two purposes
+// above are split allowing lookahead buffering and primimimg to occur.
+//
+int PARSE_SCOPE yylex()
+{
+ CxxToken *aToken = primed_tokens[0];
+ if (aToken)
+ {
+ primed_tokens[0] = primed_tokens[1];
+ primed_tokens[1] = primed_tokens[2];
+ primed_tokens[2] = 0;
+ }
+ else if (tokenReadIndex < tokenWriteIndex)
+ aToken = tokenBuffer[tokenReadIndex++];
+ else
+ {
+ aToken = yylex_token();
+ if (!aToken)
+ return 0;
+ if (tokenMarkDepth > 0)
+ token_put(aToken);
+ else
+ {
+ tokenWriteIndex = 0;
+ tokenReadIndex = 0;
+ }
+ }
+ yylval.token = aToken;
+ return aToken->value();
+}
+
+//
+// Advance the binary search of template attempts. Rewinds and forces true into the input sequence
+// to proceed with the search. Rewinds and forces false to terminate it. Also forces a # that may then
+// be used to initiate error propagation.
+//
+void advance_search()
+{
+ CxxSearchContext::search_advances++;
+ remark(CxxSearchContext::current()->mark());
+ if (CxxSearchContext::current() && CxxSearchContext::current()->advance())
+ {
+ primed_tokens[0] = &plusToken;
+ primed_tokens[1] = 0;
+ }
+ else
+ {
+ primed_tokens[0] = &minusToken;
+ primed_tokens[1] = &hashToken;
+ }
+}
+
+//
+// Complete a search, releasing the search context object and popping a mark off the stack.
+//
+void end_search(CxxToken *aToken)
+{
+ CxxSearchContext::release();
+ unmark(aToken);
+}
+
+//
+// Notch up an error and establish a good break point.
+//
+void increment_error_count()
+{
+ error_count++;
+}
+
+//
+// Push a new marked context onto the stack, returning its identity for use by remark().
+// Any parser readahead is incorporated within the marked region.
+//
+YACC_MARK_TYPE mark()
+{
+ if (primed_tokens[0])
+ ERRMSG("Unexpected primed_tokens[0] in mark.");
+ YACC_MARK_TYPE markIndex = tokenReadIndex;
+ if (PARSE_DOT yychar != YYEMPTY)
+ {
+// if (primed_tokens[2])
+// token_put(primed_tokens[2]);
+// if (primed_tokens[1])
+// token_put(primed_tokens[1]);
+// if (primed_tokens[0])
+// token_put(primed_tokens[0]);
+// if (!tokenMarkDepth)
+ if (!tokenReadIndex && !tokenWriteIndex)
+ {
+ token_put(PARSE_DOT yylval.token);
+ tokenReadIndex = 0;
+ }
+ else if (!tokenReadIndex)
+ ERRMSG("Unexpected 0 read index in mark.");
+ else if (tokenBuffer[--tokenReadIndex] != PARSE_DOT yylval.token)
+ ERRMSG("Unexpected unget in mark.");
+ markIndex = tokenReadIndex;
+ yyclearin;
+ primed_tokens[0] = 0;
+ primed_tokens[1] = 0;
+ }
+ tokenMarkDepth++;
+ bang_depth++;
+ return markIndex;
+}
+
+//
+// If it is appropriate to do type I function parameter parsing perform a mark and force a rrue token
+// into the input stream. Otherwise just force a false token in.
+//
+YACC_MARK_TYPE mark_type1()
+{
+ if (!in_type1 && CxxSearchContext::current() && CxxSearchContext::current()->enable_type1())
+ {
+ YACC_MARK_TYPE markIndex = mark();
+ primed_tokens[0] = &plusToken;
+ primed_tokens[1] = 0;
+ in_type1 = true;
+ yyclearin;
+ return markIndex;
+ }
+ else
+ {
+ primed_tokens[0] = &minusToken;
+ primed_tokens[1] = PARSE_DOT yychar != YYEMPTY ? PARSE_DOT yylval.token : 0;
+ yyclearin;
+ return 0; // Never used.
+ }
+}
+
+//
+// Push a bang context onto the error suppression stack, returning the context for restoration by pop_bang.
+//
+void pop_bang(YACC_BANG_TYPE bangValue)
+{
+ bang_depth = bangValue;
+}
+
+//
+// Push a bang context onto the error suppression stack, returning the context for restoration by pop_bang.
+//
+YACC_BANG_TYPE push_bang()
+{
+ return bang_depth++;
+}
+
+//
+// Reposition the input to restart at the position returned by a mark().
+//
+void remark(YACC_MARK_TYPE anIndex)
+{
+ tokenReadIndex = anIndex;
+ yyclearin;
+}
+
+//
+// Reposition the input to restart at the position returned by a mark().
+//
+void remark_type1(YACC_MARK_TYPE anIndex)
+{
+ remark(anIndex);
+ in_type1 = false;
+}
+
+//
+// Rewind the input stream back to anIndex and force a : prior to resuming input.
+//
+void rewind_colon(YACC_MARK_TYPE anIndex, const CxxToken *aToken)
+{
+ remark(anIndex);
+ unmark();
+ primed_tokens[0] = &colonToken;
+ primed_tokens[1] = PARSE_DOT yylval.token;
+}
+
+//
+// Start a new binary search over the template/arithmetic alternative parses of a statement.
+// Marks the current position and saves it in a binary search context maintained on a private stack.
+//
+void start_search(bool enableType1)
+{
+ bool type1Enabled = !CxxSearchContext::current() || CxxSearchContext::current()->enable_type1() ? true : false;
+ CxxSearchContext::start(mark(), enableType1 && type1Enabled ? true : false);
+}
+
+//
+// Determine whether the just parsed < should be interpreted as a template or arithmetic operator.
+// The implementation here intersacts with a binary search to traverse all possibilities in
+// multiple passes. The search proceeds by branch and bound presuming the template interpretation.
+// A true token is forced into the input stream to take the template interpretaion. A false token
+// otherwise.
+//
+// An alternate implementation that keeps track of scopes may interact with semantic knowledge to make
+// the correct decision directly.
+//
+void template_test()
+{
+ if (!CxxSearchContext::current() || CxxSearchContext::current()->is_template())
+ {
+ primed_tokens[0] = &plusToken;
+ primed_tokens[1] = 0;
+ }
+ else
+ {
+ primed_tokens[0] = &minusToken;
+ primed_tokens[1] = &angleToken;
+ }
+}
+
+void token_put(CxxToken *aToken)
+{
+ if (!tokenBuffer || !tokenSize)
+ tokenBuffer = new CxxToken *[tokenSize = 256];
+ else if (tokenWriteIndex >= tokenSize)
+ {
+ CxxToken **oldTokenBuffer = tokenBuffer;
+ size_t oldTokenSize = tokenSize;
+ tokenBuffer = new CxxToken *[tokenSize *= 2];
+ memcpy(tokenBuffer, oldTokenBuffer, oldTokenSize * sizeof(*oldTokenBuffer));
+ delete[] oldTokenBuffer;
+ }
+ tokenBuffer[tokenWriteIndex++] = aToken;
+ tokenReadIndex = tokenWriteIndex;
+}
+
+//
+// Pop a marked context off the stack.
+//
+void unmark(const CxxToken *aToken)
+{
+ if (bang_depth)
+ bang_depth--;
+ else
+ ERRMSG("BUG - should not unmark with 0 bang.");
+ if (tokenMarkDepth <= 0)
+ ERRMSG("Unexpected unmark.");
+ else
+ tokenMarkDepth--;
+}
--- /dev/null
+#include <CxxToken.hxx>
+#include <stdio.h>
+#ifndef _MSC_VER
+#include <alloca.h>
+#else
+#include <malloc.h>
+//#define alloca _alloca
+#endif
+void advance_search();
+void end_search(CxxToken *aToken);
+YACC_MARK_TYPE mark();
+YACC_MARK_TYPE mark_type1();
+size_t nest() { return 0; }
+void pop_bang(YACC_BANG_TYPE bangValue);
+YACC_BANG_TYPE push_bang();
+void remark(YACC_MARK_TYPE anIndex);
+void remark_type1(YACC_MARK_TYPE anIndex);
+void rewind_colon(YACC_MARK_TYPE anIndex, const CxxToken *aToken);
+void start_search(bool enableType1);
+void template_test();
+void unmark(const CxxToken *aToken = 0);
+void unnest(size_t aNest) {}
+
+void classify_argument();
+void classify_function();
+void dollar_kill();
+CxxTokens *get_code(CxxToken *);
+CxxTokens *get_expr();
+CxxTokens *get_for_init();
+CxxTokens *get_for_next();
+CxxTokens *get_for_test();
+CxxTokens *get_func();
+CxxTokens *get_raw(CxxToken *);
+CxxTokens *get_statement();
+void make(CxxToken *);
+void queue(CxxToken *);
+int set_replace_formals(int);
+
+extern CxxToken *_list_token;
+
+#ifndef BISON_PP_CLASS
+void yyerror(const char *s);
+#define yylex buffered_yylex
+int yylex();
+#endif
+
+#define YACC_ABSTRACT_ARRAY_EXPRESSION(a) make_abstract_array_expression(a)
+#define YACC_ABSTRACT_FUNCTION_EXPRESSION(a) make_abstract_function_expression(a)
+#define YACC_ACCESSIBILITY_SPECIFIER(a) make_accessibility_specifier(a)
+#define YACC_ACCESS_BASE_SPECIFIER(a,b) make_access_base_specifier(a,b)
+#define YACC_ACCESS_SPECIFIER_ID(a) make_access_specifier_id(a)
+#define YACC_ADD_EXPRESSION(a,b) make_add_expression(a, b)
+#define YACC_AND_EXPRESSION(a,b) make_and_expression(a,b)
+#define YACC_ARRAY_EXPRESSION(a,b) make_array_expression(a,b)
+#define YACC_ARROW_EXPRESSION(a,b) make_arrow_expression(a,b)
+#define YACC_ARROW_STAR_EXPRESSION(a,b) make_arrow_star_expression(a,b)
+#define YACC_ASM_DEFINITION(a) make_asm_definition(a)
+#define YACC_ASSIGNMENT_EXPRESSION(a,b,c) make_assignment_expression(a,b,c)
+#define YACC_BASE_SPECIFIER(a) make_base_specifier(a)
+#define YACC_BASE_SPECIFIERS(a,b) make_base_specifiers(a,b)
+#define YACC_BIT_FIELD_EXPRESSION(a,b) make_bit_field_expression(a,b)
+#define YACC_BREAK_STATEMENT() make_break_statement()
+#define YACC_BUILT_IN_ID(a) make_built_in_id(a)
+#define YACC_BUILT_IN_ID_ID(a) make_built_in_id_id(a)
+#define YACC_BUILT_IN_IDS(a,b) make_built_in_ids(a,b)
+#define YACC_BUILT_IN_NAME(a,b) make_built_in_name(a,b)
+#define YACC_CALL_EXPRESSION(a,b) make_call_expression(a,b)
+#define YACC_CASE_STATEMENT(a,b) make_case_statement(a,b)
+#define YACC_CAST_EXPRESSION(a,b) make_cast_expression(a,b)
+#define YACC_CHARACTER_LITERAL_EXPRESSION(a) make_character_literal_expression(a)
+#define YACC_CLASS_MEMBERS(a,b) make_class_members(a,b)
+#define YACC_CLASS_SPECIFIER_ID(a,b,c) make_class_specifier_id(a,b,c)
+#define YACC_CLASS_TEMPLATE_PARAMETER(a) make_class_template_parameter(a)
+#define YACC_CLASS_TYPE_PARAMETER(a) make_class_type_parameter(a)
+#define YACC_COMPILE_DECLARATION(a,b) compile_declaration(a,b)
+#define YACC_COMPILE_STATEMENT(a) compile_statement(a)
+#define YACC_COMPLEMENT_EXPRESSION(a) make_complement_expression(a)
+#define YACC_COMPOUND_STATEMENT(a) make_compound_statement(a)
+#define YACC_CONDITION(a) make_condition(a)
+#define YACC_CONDITIONAL_EXPRESSION(a,b,c) make_conditional_expression(a,b,c)
+#define YACC_CONST_CAST_EXPRESSION(a,b) make_const_cast_expression(a,b)
+#define YACC_CONTINUE_STATEMENT() make_continue_statement()
+#define YACC_CONVERSION_FUNCTION_ID(a) make_conversion_function_id(a)
+#define YACC_CTOR_DEFINITION(a,b) make_ctor_definition(a,b)
+#define YACC_CTOR_FUNCTION_BLOCK(a,b) make_ctor_function_block(a,b)
+#define YACC_CV_DECLARATOR(a,b) make_cv_declarator(a,b)
+#define YACC_CV_DECL_SPECIFIER(a) make_cv_decl_specifier(a)
+#define YACC_CV_QUALIFIERS(a,b) make_cv_qualifiers(a,b)
+#define YACC_DECLARATIONS(a,b) make_declarations(a,b)
+#define YACC_DECLARATION_STATEMENT(a) make_declaration_statement(a)
+#define YACC_DECL_SPECIFIER_DECLARATION(a,b) make_decl_specifier_declaration(a,b)
+#define YACC_DECL_SPECIFIER_EXPRESSION(a,b) make_decl_specifier_expression(a,b)
+#define YACC_DECL_SPECIFIER_NAME(a,b) make_decl_specifier_name(a,b)
+#define YACC_DECL_SPECIFIER_PARAMETER(a,b) make_decl_specifier_parameter(a,b)
+#define YACC_DECL_SPECIFIERS(a,b) make_decl_specifiers(a,b)
+#define YACC_DECL_SPECIFIER_TREE_ARGUMENT(a,b) make_decl_specifier_tree_argument(a,b)
+#define YACC_DECL_SPECIFIER_TREE_ARGUMENTS(a,b) make_decl_specifier_tree_arguments(a,b)
+#define YACC_DEFAULT_STATEMENT(a) make_default_statement(a)
+#define YACC_DELETE_EXPRESSION(a) make_delete_expression(a)
+#define YACC_DERIVED_CLAUSE(a,b) make_derived_clause(a,b)
+#define YACC_DESTRUCTOR_ID(a) make_destructor_id(a)
+#define YACC_DIVIDE_EXPRESSION(a,b) make_divide_expression(a,b)
+#define YACC_DOT_EXPRESSION(a,b) make_dot_expression(a,b)
+#define YACC_DOT_STAR_EXPRESSION(a,b) make_dot_star_expression(a,b)
+#define YACC_DO_WHILE_STATEMENT(a,b) make_do_while_statement(a,b)
+#define YACC_DYNAMIC_CAST_EXPRESSION(a,b) make_dynamic_cast_expression(a,b)
+#define YACC_ELABORATED_TYPE_SPECIFIER(a,b) make_elaborated_type_specifier(a,b)
+#define YACC_ELLIPSIS_EXPRESSION() make_ellipsis_expression()
+#define YACC_ENUMERATOR(a,b) make_enumerator(a,b)
+#define YACC_ENUMERATORS(a,b) make_enumerators(a,b)
+#define YACC_ENUM_SPECIFIER_ID(a,b) make_enum_specifier_id(a,b)
+#define YACC_ENUM_TREE_ID(a) make_enum_tree_id(a)
+#define YACC_EPSILON() make_epsilon()
+#define YACC_EQUAL_EXPRESSION(a,b) make_equal_expression(a,b)
+#define YACC_EXCEPTION_DECLARATION(a) make_exception_declaration(a)
+#define YACC_EXCEPTION_SPECIFICATION(a) make_exception_specification(a)
+#define YACC_EXCLUSIVE_OR_EXPRESSION(a,b) make_exclusive_or_expression(a,b)
+#define YACC_EXPLICIT_IMPLEMENTATION_DECLARATION(a) make_explicit_implementation_declaration(a)
+#define YACC_EXPLICIT_INTERFACE_DECLARATION(a) make_explicit_interface_declaration(a)
+#define YACC_EXPLICIT_SPECIALIZATION(a) make_explicit_specialization(a)
+#define YACC_EXPORT_IMPLEMENTATION_DECLARATION(a) make_export_implementation_declaration(a)
+#define YACC_EXPORT_INTERFACE_DECLARATION(a) make_export_interface_declaration(a)
+#define YACC_EXPORT_NOIMPLEMENTATION_DECLARATION() make_export_noimplementation_declaration()
+#define YACC_EXPRESSION(a) make_expression(a)
+#define YACC_EXPRESSIONS(a,b) make_expressions(a,b)
+#define YACC_EXPRESSION_PARAMETER(a) make_expression_parameter(a)
+#define YACC_FALSE_EXPRESSION() make_false_expression()
+#define YACC_FILESPACE_DECLARATION(a) make_filespace_declaration(a)
+#define YACC_FILESPACE_SPECIFIER(a,b) make_filespace_specifier(a,b)
+#define YACC_FILE_ID(a) make_file_id(a)
+#define YACC_FILE_ID_IMPLEMENTATION(a) make_file_id_implementation(a)
+#define YACC_FILE_ID_INTERFACE(a) make_file_id_interface(a)
+#define YACC_FILE_IDS(a,b) make_file_ids(a,b)
+#define YACC_FILE_NAME(a) make_file_name(a)
+#define YACC_FILE_NAME_GUARD(a,b) make_file_name_guard(a,b)
+#define YACC_FILE_NAME_IMPLEMENTATION(a) make_file_name_implementation(a)
+#define YACC_FILE_NAME_INTERFACE(a) make_file_name_interface(a)
+#define YACC_FILE_NAME_NOGUARD(a) make_file_name_noguard(a)
+#define YACC_FILE_NAME_PATH(a,b) make_file_name_path(a,b)
+#define YACC_FILE_NAME_PREFIX(a,b) make_file_name_prefix(a,b)
+#define YACC_FILE_NAME_SUFFIX(a,b) make_file_name_suffix(a,b)
+#define YACC_FILE_NAME_TEMPLATE(a) make_file_name_template(a)
+#define YACC_FILE_NAME_UTILITY(a,b) make_file_name_utility(a,b)
+#define YACC_FLOATING_LITERAL_EXPRESSION(a) make_floating_literal_expression(a)
+#define YACC_FOR_STATEMENT(a,b,c,d) make_for_statement(a,b,c,d)
+#define YACC_FUNCTION_BLOCK(a) make_function_block(a)
+#define YACC_FUNCTION_DECLARATIONS(a,b) make_function_declarations(a,b)
+#define YACC_FUNCTION_DEFINITION(a,b) make_function_definition(a,b)
+#define YACC_GLOBAL_DECLARATOR(a,b) make_global_declarator(a,b)
+#define YACC_GLOBAL_EXPRESSION(a, b) make_global_expression(a,b)
+#define YACC_GLOBAL_ID(a,b) make_global_id(a,b)
+#define YACC_GOTO_STATEMENT(a) make_goto_statement(a)
+#define YACC_GREATER_EQUAL_EXPRESSION(a,b) make_greater_equal_expression(a,b)
+#define YACC_GREATER_THAN_EXPRESSION(a,b) make_greater_than_expression(a,b)
+#define YACC_HANDLER(a,b) make_handler(a,b)
+#define YACC_HANDLERS(a,b) make_handlers(a,b)
+#define YACC_IF_STATEMENT(a,b,c) make_if_statement(a,b,c)
+#define YACC_INCLUDE_DECLARATION(a,b) make_include_declaration(a,b)
+#define YACC_INCLUSIVE_OR_EXPRESSION(a,b) make_inclusive_or_expression(a,b)
+#define YACC_INITIALIZED_PARAMETER(a,b) make_initialized_parameter(a, b)
+#define YACC_INITIALIZER_CLAUSES(a,b) make_initializer_clauses(a,b)
+#define YACC_INITIALIZER_EXPRESSION_CLAUSE(a) make_initializer_expression_clause(a)
+#define YACC_INITIALIZER_LIST_CLAUSE(a) make_initializer_list_clause(a)
+#define YACC_INIT_SIMPLE_TYPE_PARAMETER(a,b) make_init_simple_type_parameter(a,b)
+#define YACC_INIT_TEMPLATED_PARAMETER(a,b) make_init_templated_parameter(a,b)
+#define YACC_INLINE_AS_FRIEND() make_inline_as_friend()
+#define YACC_INLINE_IF_SHORT() make_inline_if_short()
+#define YACC_INLINE_IN_IMPLEMENTATION() make_inline_in_implementation()
+#define YACC_INLINE_IN_INTERFACE() make_inline_in_interface()
+#define YACC_INDEX_CAST_EXPRESSION(a,b) make_index_cast_expression(a,b)
+#define YACC_INPUT_FILE(a) make_input_file(a)
+#define YACC_INTEGER_LITERAL_EXPRESSION(a) make_integer_literal_expression(a)
+#define YACC_LABEL_STATEMENT(a,b) make_label_statement(a,b)
+#define YACC_LESS_EQUAL_EXPRESSION(a,b) make_less_equal_expression(a,b)
+#define YACC_LESS_THAN_EXPRESSION(a,b) make_less_than_expression(a,b)
+#define YACC_LINE() make_line()
+#define YACC_LINED_DECLARATION(a,b) make_lined_declaration(a,b)
+#define YACC_LINED_STATEMENT(a,b) make_lined_statement(a,b)
+#define YACC_LINED_TOKEN(a,b) make_lined_token(a,b)
+#define YACC_LINKAGE_SPECIFICATION(a) make_linkage_specification(a)
+#define YACC_LINKAGE_SPECIFIER(a,b) make_linkage_specifier(a,b)
+#define YACC_LOGICAL_AND_EXPRESSION(a,b) make_logical_and_expression(a,b)
+#define YACC_LOGICAL_OR_EXPRESSION(a,b) make_logical_or_expression(a,b)
+#define YACC_MEMBER_DECLARATIONS(a,b) make_member_declarations(a,b)
+#define YACC_MEM_INITIALIZER(a,b) make_mem_initializer(a,b)
+#define YACC_MEM_INITIALIZERS(a,b) make_mem_initializers(a,b)
+#define YACC_META_ASSIGNMENT_EXPRESSION(a,b,c) make_meta_assignment_expression(a,b,c)
+#define YACC_META_BASE_SPECIFIER(a) make_meta_base_specifier(a)
+#define YACC_META_BREAK_STATEMENT() make_meta_break_statement()
+#define YACC_META_BUILT_IN_TYPE(a) make_meta_built_in_type(a)
+#define YACC_META_CASE_STATEMENT(a,b) make_meta_case_statement(a,b)
+#define YACC_META_CLASS(a,b,c) make_meta_class(a,b,c)
+#define YACC_META_CONTINUE_STATEMENT() make_meta_continue_statement()
+#define YACC_META_DEFAULT_STATEMENT(a) make_meta_default_statement(a)
+#define YACC_META_DO_WHILE_STATEMENT(a,b,c) make_meta_do_while_statement(a,b,c)
+#define YACC_META_FOR_STATEMENT(a,b,c,d,e) make_meta_for_statement(a,b,c,d,e)
+#define YACC_META_FUNCTION(a,b,c) make_meta_function(a,b,c)
+#define YACC_META_IF_STATEMENT(a,b,c,d) make_meta_if_statement(a,b,c,d)
+#define YACC_META_INITIALIZER(a,b) make_meta_initializer(a,b)
+#define YACC_META_INITIALIZERS(a,b) make_meta_initializers(a,b)
+#define YACC_META_RETURN_STATEMENT(a) make_meta_return_statement(a)
+#define YACC_META_STATEMENT(a) make_meta_statement(a)
+#define YACC_META_STATEMENT_DECLARATION(a) make_meta_statement_declaration(a)
+#define YACC_META_SWITCH_STATEMENT(a,b,c) make_meta_switch_statement(a,b,c)
+#define YACC_META_TYPE(a) make_meta_type(a)
+#define YACC_META_TYPE_ID(a) make_meta_type_id(a)
+#define YACC_META_WHILE_STATEMENT(a,b,c) make_meta_while_statement(a,b,c)
+#define YACC_MINUS_EXPRESSION(a) make_minus_expression(a)
+#define YACC_MODULUS_EXPRESSION(a,b) make_modulus_expression(a,b)
+#define YACC_MULTIPLY_EXPRESSION(a,b,c) make_multiply_expression(a,b,c)
+#define YACC_NAME(a) make_name(a)
+#define YACC_NAMESPACE_ALIAS_DEFINITION(a,b) make_namespace_alias_definition(a,b)
+#define YACC_NAMESPACE_DECLARATION(a) make_namespace_declaration(a)
+#define YACC_NAMESPACE_DEFINITION(a,b) make_namespace_definition(a,b)
+#define YACC_NAME_EXPRESSION(a) make_name_expression(a)
+#define YACC_NESTED_DECLARATOR(a,b) make_nested_declarator(a,b)
+#define YACC_NESTED_ID(a,b) make_nested_id(a,b)
+#define YACC_NESTED_SCOPE(a) make_nested_scope(a)
+#define YACC_NEW_EXPRESSION(a,b,c) make_new_expression(a,b,c)
+#define YACC_NEW_TYPE_ID_EXPRESSION(a,b,c) make_new_type_id_expression(a,b,c)
+#define YACC_NOT_CONST() make_not_const()
+#define YACC_NOT_EQUAL_EXPRESSION(a,b) make_not_equal_expression(a,b)
+#define YACC_NOT_EXPRESSION(a) make_not_expression(a)
+#define YACC_NOT_INLINE() make_not_inline()
+#define YACC_NOT_STATIC() make_not_static()
+#define YACC_NOT_VIRTUAL() make_not_virtual()
+#define YACC_NOT_VIRTUAL_BASE_SPECIFIER(a) make_not_virtual_base_specifier(a)
+#define YACC_NOT_VOLATILE() make_not_volatile()
+#define YACC_NUMBER_LITERAL_EXPRESSION(a) make_number_literal_expression(a)
+#define YACC_OBJECT_SCOPE_EXPRESSION(a,b) make_object_scope_expression(a,b)
+#define YACC_OPERATOR_ADD_ID() make_operator_add_id()
+#define YACC_OPERATOR_ARROW_ID() make_operator_arrow_id()
+#define YACC_OPERATOR_ARROW_STAR_ID() make_operator_arrow_star_id()
+#define YACC_OPERATOR_ASS_ADD_ID() make_operator_ass_add_id()
+#define YACC_OPERATOR_ASS_BIT_AND_ID() make_operator_ass_bit_and_id()
+#define YACC_OPERATOR_ASS_BIT_OR_ID() make_operator_ass_bit_or_id()
+#define YACC_OPERATOR_ASS_DIV_ID() make_operator_ass_div_id()
+#define YACC_OPERATOR_ASS_ID() make_operator_ass_id()
+#define YACC_OPERATOR_ASS_MOD_ID() make_operator_ass_mod_id()
+#define YACC_OPERATOR_ASS_MUL_ID() make_operator_ass_mul_id()
+#define YACC_OPERATOR_ASS_SHL_ID() make_operator_ass_shl_id()
+#define YACC_OPERATOR_ASS_SHR_ID() make_operator_ass_shr_id()
+#define YACC_OPERATOR_ASS_SUB_ID() make_operator_ass_sub_id()
+#define YACC_OPERATOR_ASS_XOR_ID() make_operator_ass_xor_id()
+#define YACC_OPERATOR_BIT_AND_ID() make_operator_bit_and_id()
+#define YACC_OPERATOR_BIT_NOT_ID() make_operator_bit_not_id()
+#define YACC_OPERATOR_BIT_OR_ID() make_operator_bit_or_id()
+#define YACC_OPERATOR_CALL_ID() make_operator_call_id()
+#define YACC_OPERATOR_COMMA_ID() make_operator_comma_id()
+#define YACC_OPERATOR_DEC_ID() make_operator_dec_id()
+#define YACC_OPERATOR_DELETE_ID() make_operator_delete_id()
+#define YACC_OPERATOR_DIV_ID() make_operator_div_id()
+#define YACC_OPERATOR_EQ_ID() make_operator_eq_id()
+#define YACC_OPERATOR_FUNCTION_ID(a) make_operator_function_id(a)
+#define YACC_OPERATOR_GE_ID() make_operator_ge_id()
+#define YACC_OPERATOR_GT_ID() make_operator_gt_id()
+#define YACC_OPERATOR_INC_ID() make_operator_inc_id()
+#define YACC_OPERATOR_INDEX_ID() make_operator_index_id()
+#define YACC_OPERATOR_LE_ID() make_operator_le_id()
+#define YACC_OPERATOR_LOG_AND_ID() make_operator_log_and_id()
+#define YACC_OPERATOR_LOG_NOT_ID() make_operator_log_not_id()
+#define YACC_OPERATOR_LOG_OR_ID() make_operator_log_or_id()
+#define YACC_OPERATOR_LT_ID() make_operator_lt_id()
+#define YACC_OPERATOR_MOD_ID() make_operator_mod_id()
+#define YACC_OPERATOR_MUL_ID() make_operator_mul_id()
+#define YACC_OPERATOR_NE_ID() make_operator_ne_id()
+#define YACC_OPERATOR_NEW_ID() make_operator_new_id()
+#define YACC_OPERATOR_SHL_ID() make_operator_shl_id()
+#define YACC_OPERATOR_SHR_ID() make_operator_shr_id()
+#define YACC_OPERATOR_SUB_ID() make_operator_sub_id()
+#define YACC_OPERATOR_XOR_ID() make_operator_xor_id()
+#define YACC_PARAMETERS(a,b) make_parameters(a,b)
+#define YACC_PARENTHESISED(a,b,c) make_parenthesised(a,b,c)
+#define YACC_POINTER_DECLARATOR() make_pointer_declarator()
+#define YACC_POINTER_EXPRESSION(a,b) make_pointer_expression(a,b)
+#define YACC_PLUS_EXPRESSION(a) make_plus_expression(a)
+#define YACC_POSITION(a,b) make_position(a)
+#define YACC_POSITION_FUNCTION_BLOCK(a,b) make_position_function_block(a,b)
+#define YACC_POST_DECREMENT_EXPRESSION(a) make_post_decrement_expression(a)
+#define YACC_POST_INCREMENT_EXPRESSION(a) make_post_increment_expression(a)
+#define YACC_PRE_DECREMENT_EXPRESSION(a) make_pre_decrement_expression(a)
+#define YACC_PRE_INCREMENT_EXPRESSION(a) make_pre_increment_expression(a)
+#define YACC_PSEUDO_DESTRUCTOR_ID(a,b) make_pseudo_destructor_id(a,b)
+#define YACC_PURE_VIRTUAL() make_pure_virtual()
+#define YACC_READ_ONLY_RESULT(a) make_read_only_result(a)
+#define YACC_READ_WRITE_RESULT(a) make_read_write_result(a)
+#define YACC_REFERENCE_DECLARATOR() make_reference_declarator()
+#define YACC_REINTERPRET_CAST_EXPRESSION(a,b) make_reinterpret_cast_expression(a,b)
+#define YACC_RESULT(a) make_result(a)
+#define YACC_RETURN_STATEMENT(a) make_return_statement(a)
+#define YACC_SCOPED_POINTER_EXPRESSION(a,b,c) make_scoped_pointer_expression(a,b,c)
+#define YACC_SCOPED_ID(a,b) make_scoped_id(a,b)
+#define YACC_SEGMENT(a,b) make_segment(a)
+#define YACC_SEGMENT_FUNCTION_BLOCK(a,b) make_segment_function_block(a,b)
+#define YACC_SET_TEMPLATE_DECLARATION(a) make_set_template_declaration(a)
+#define YACC_SET_TEMPLATE_DECL_SPECIFIER(a) make_set_template_decl_specifier(a)
+#define YACC_SET_TEMPLATE_EXPRESSION(a) make_set_template_expression(a)
+#define YACC_SET_TEMPLATE_ID(a) make_set_template_id(a)
+#define YACC_SET_TEMPLATE_NAME(a) make_set_template_name(a)
+#define YACC_SET_TEMPLATE_SCOPE(a) make_set_template_scope(a)
+#define YACC_SHIFT_LEFT_EXPRESSION(a,b) make_shift_left_expression(a,b)
+#define YACC_SHIFT_RIGHT_EXPRESSION(a,b) make_shift_right_expression(a,b)
+#define YACC_SIMPLE_DECLARATION(a) make_simple_declaration(a)
+#define YACC_SIZEOF_EXPRESSION(a) make_sizeof_expression(a)
+#define YACC_STATEMENTS(a,b) make_statements(a,b)
+#define YACC_STATIC_CAST_EXPRESSION(a,b) make_static_cast_expression(a,b)
+#define YACC_STRINGS(a,b) make_strings(a,b)
+#define YACC_STRING_LITERAL_EXPRESSION(a) make_string_literal_expression(a)
+#define YACC_SUBTRACT_EXPRESSION(a,b) make_subtract_expression(a,b)
+#define YACC_SWITCH_STATEMENT(a,b) make_switch_statement(a,b)
+#define YACC_SYNTAX_MACRO_DEFINITION(a,b,c,d,e) make_syntax_macro_definition(a,b,c,d,e)
+#define YACC_SYNTAX_MACRO_PARAMETER(a,b,c) make_syntax_macro_parameter(a,b,c)
+#define YACC_SYNTAX_MACRO_PARAMETERS(a,b) make_syntax_macro_parameters(a,b)
+#define YACC_TEMPLATE_ARGUMENT(a) make_template_argument(a)
+#define YACC_TEMPLATE_ARGUMENTS(a,b) make_template_arguments(a,b)
+#define YACC_TEMPLATED_TEMPLATE_PARAMETER(a,b) make_templated_template_parameter(a,b)
+#define YACC_TEMPLATED_TYPE_PARAMETER(a,b) make_templated_type_parameter(a,b)
+#define YACC_TEMPLATE_DECLARATION(a,b) make_template_declaration(a,b)
+#define YACC_TEMPLATE_NAME(a,b) make_template_name(a,b)
+#define YACC_TEMPLATE_PARAMETER(a) make_template_parameter(a)
+#define YACC_TEMPLATE_PARAMETERS(a,b) make_template_parameters(a,b)
+#define YACC_THIS_EXPRESSION() make_this_expression()
+#define YACC_THROW_EXPRESSION(a) make_throw_expression(a)
+#define YACC_TOKENS_EXPRESSION(a) make_tokens_expression(a)
+#define YACC_TREE_ARGUMENT(a) make_tree_argument(a)
+#define YACC_TREE_ARGUMENTS(a,b) make_tree_arguments(a,b)
+#define YACC_TREE_ARRAY_EXPRESSION(a,b) make_tree_array_expression(a,b)
+#define YACC_TREE_ARROW_EXPRESSION(a,b) make_tree_arrow_expression(a,b)
+#define YACC_TREE_ARROW_CALL_EXPRESSION(a,b,c) make_tree_arrow_call_expression(a,b,c)
+#define YACC_TREE_CALL_EXPRESSION(a,b) make_tree_call_expression(a,b)
+#define YACC_TREE_DOT_EXPRESSION(a,b) make_tree_dot_expression(a,b)
+#define YACC_TREE_DOT_CALL_EXPRESSION(a,b,c) make_tree_dot_call_expression(a,b,c)
+#define YACC_TREE_EXPRESSION(a) make_tree_expression(a)
+#define YACC_TREE_ID(a) make_tree_id(a)
+#define YACC_TREE_POINTER_EXPRESSION(a) make_tree_pointer_expression(a)
+#define YACC_TRUE_EXPRESSION() make_true_expression()
+#define YACC_TRY_BLOCK(a,b) make_try_block(a,b)
+#define YACC_TRY_BLOCK_STATEMENT(a) make_try_block_statement(a)
+#define YACC_TRY_FUNCTION_BLOCK(a,b) make_try_function_block(a,b)
+#define YACC_TYPE1_EXPRESSION(a,b,c) make_type1_expression(a,b,c)
+#define YACC_TYPE1_PARAMETERS(a,b) make_type1_parameters(a,b)
+#define YACC_TYPED_EXPRESSION(a,b) make_typed_expression(a,b)
+#define YACC_TYPED_NAME(a,b) make_typed_name(a,b)
+#define YACC_TYPEID_EXPRESSION(a) make_typeid_expression(a)
+#define YACC_TYPENAME_TEMPLATE_PARAMETER(a) make_typename_template_parameter(a)
+#define YACC_TYPENAME_TYPE_PARAMETER(a) make_typename_type_parameter(a)
+#define YACC_TYPE_TEMPLATE_PARAMETER(a,b) make_type_template_parameter(a,b)
+#define YACC_USING_DECLARATION(a,b) make_using_declaration(a,b)
+#define YACC_USING_DIRECTIVE(a) make_using_directive(a)
+#define YACC_USING_FUNCTION_BLOCK(a,b) make_using_function_block(a,b)
+#define YACC_USING_IMPLEMENTATION_DECLARATION(a) make_using_implementation_declaration(a)
+#define YACC_USING_INTERFACE_DECLARATION(a) make_using_interface_declaration(a)
+#define YACC_UTILITY(a) make_utility(0)
+#define YACC_UTILITY_MODE() make_utility_mode()
+#define YACC_VIRTUAL_BASE_SPECIFIER(a) make_virtual_base_specifier(a)
+#define YACC_WHILE_STATEMENT(a,b) make_while_statement(a,b)
+
+CxxDeclaration *compile_declaration(CxxUtility *utilityMode, CxxDeclaration *aDeclaration) { return 0; }
+CxxStatement *compile_statement(CxxStatement *aDeclaration) { return 0; }
+void make_result(CxxToken *aResult) {}
+
+CxxExpression *make_abstract_array_expression(CxxExpression *sizeExpr) { return 0; }
+CxxExpression *make_abstract_function_expression(CxxParenthesised *aparenthesis) { return 0; }
+CxxBaseSpecifier *make_access_base_specifier(CxxBaseSpecifier *baseSpecifier, CxxAccessSpecifier *accessSpecifier) { return 0; }
+CxxDeclSpecifierId *make_access_specifier_id(CxxAccessSpecifier *aName) { return 0; }
+CxxDeclaration *make_accessibility_specifier(CxxAccessSpecifier *accessSpecifier) { return 0; }
+CxxExpression *make_add_expression(CxxExpression *leftExpr, CxxExpression *rightExpr) { return 0; }
+CxxExpression *make_and_expression(CxxExpression *leftExpr, CxxExpression *rightExpr) { return 0; }
+CxxExpression *make_array_expression(CxxExpression *anExpr, CxxExpression *indexExpr) { return 0; }
+CxxExpression *make_arrow_expression(CxxExpression *anExpr, CxxName *aName) { return 0; }
+CxxExpression *make_arrow_star_expression(CxxExpression *anExpr, CxxExpression *memberExpr) { return 0; }
+CxxDeclaration *make_asm_definition(CxxStrings *aString) { return 0; }
+CxxExpression *make_assignment_expression(CxxExpression *leftExpr, CxxToken *assOp, CxxExpression *rightExpr) { return 0; }
+CxxBaseSpecifier *make_base_specifier(CxxName *aName) { return 0; }
+CxxBaseSpecifiers *make_base_specifiers(CxxBaseSpecifiers *aList, CxxBaseSpecifier *anElement) { return 0; }
+CxxExpression *make_bit_field_expression(CxxExpression *nameExpr, CxxExpression *sizeExpr) { return 0; }
+CxxStatement *make_break_statement() { return 0; }
+CxxName *make_built_in_id(CxxBuiltInId *aName) { return 0; }
+CxxName *make_built_in_id_id(CxxBuiltInId *aName) { return 0; }
+CxxBuiltInId *make_built_in_ids(CxxBuiltInId *anExpr, CxxBuiltInId *anElement) { return 0; }
+CxxName *make_built_in_name(CxxName *aName, CxxBuiltInId *anElement) { return 0; }
+CxxExpression *make_call_expression(CxxExpression *anExpr, CxxParenthesised *aParenthesis) { return 0; }
+CxxStatement *make_case_statement(CxxExpression *anExpr, CxxStatement *aStmt) { return 0; }
+CxxExpression *make_cast_expression(CxxExpression *aCast, CxxExpression *anExpr) { return 0; }
+CxxExpression *make_character_literal_expression(CxxCharacterLiteral *aLiteral) { return 0; }
+CxxName *make_class_members(CxxClass *aClass, CxxMemberDeclarations *memberDeclarations) { return 0; }
+CxxClass *make_class_specifier_id(CxxClassKey *classKey, CxxName *aName, CxxBaseSpecifiers *baseSpecifiers) { return 0; }
+CxxSimpleTypeParameter *make_class_template_parameter(CxxName *aName) { return 0; }
+CxxSimpleTypeParameter *make_class_type_parameter(CxxName *aName) { return 0; }
+CxxStatement *make_compound_statement(CxxStatements *statementList) { return 0; }
+CxxExpression *make_complement_expression(CxxExpression *anExpr) { return 0; }
+CxxCondition *make_condition(CxxParameters *aList) { return 0; }
+CxxExpression *make_conditional_expression(CxxExpression *testExpr, CxxExpression *trueExpr, CxxExpression *falseExpr) { return 0; }
+CxxExpression *make_const_cast_expression(CxxExpression *aType, CxxExpression *anExpr) { return 0; }
+CxxStatement *make_continue_statement() { return 0; }
+CxxName *make_conversion_function_id(CxxExpression *typeId) { return 0; }
+CxxExpression *make_ctor_definition(CxxExpressions *anExpr, CxxFunctionBody *functionBody) { return 0; }
+CxxFunctionBody *make_ctor_function_block(CxxFunctionBody *functionBody, CxxMemInitializers *ctorList) { return 0; }
+CxxDeclSpecifierId *make_cv_decl_specifier(CxxCvQualifiers *cvQualifiers) { return 0; }
+CxxPointerDeclarator *make_cv_declarator(CxxPointerDeclarator *aDeclarator, CxxCvQualifiers *cvQualifiers) { return 0; }
+CxxCvQualifiers *make_cv_qualifiers(CxxCvQualifiers *aList, CxxCvQualifiers *anElement) { return 0; }
+CxxDeclaration *make_decl_specifier_declaration(CxxDeclaration *aDeclaration, CxxDeclSpecifierId *declSpecifier) { return 0; }
+CxxExpression *make_decl_specifier_expression(CxxExpression *anExpr, CxxDeclSpecifierId *declSpecifier) { return 0; }
+CxxName *make_decl_specifier_name(CxxName *aName, CxxDeclSpecifierId *declSpecifier) { return 0; }
+CxxParameter *make_decl_specifier_parameter(CxxParameter *aName, CxxDeclSpecifierId *declSpecifier) { return 0; }
+CxxToken *make_decl_specifier_tree_argument(CxxToken *treeArgument, CxxDeclSpecifierId *aName) { return 0; }
+CxxTokens *make_decl_specifier_tree_arguments(CxxTokens *treeArguments, CxxDeclSpecifierId *aName) { return 0; }
+CxxDeclSpecifierId *make_decl_specifiers(CxxDeclSpecifierId *aList, CxxDeclSpecifierId *anElement) { return 0; }
+CxxDeclarations *make_declarations(CxxDeclarations *aList, CxxDeclaration *anElement) { return 0; }
+CxxStatement *make_declaration_statement(CxxDeclaration *aDecl) { return 0; }
+CxxStatement *make_default_statement(CxxStatement *aStmt) { return 0; }
+CxxExpression *make_delete_expression(CxxExpression *anExpr) { return 0; }
+CxxDeclaration *make_derived_clause(CxxExpression *derivedPredicate, CxxDeclaration *aDeclaration) { return 0; }
+CxxName *make_destructor_id(CxxName *aName) { return 0; }
+CxxExpression *make_divide_expression(CxxExpression *leftExpr, CxxExpression *rightExpr) { return 0; }
+CxxStatement *make_do_while_statement(CxxStatement *aStmt, CxxExpression *testExpr) { return 0; }
+CxxExpression *make_dot_expression(CxxExpression *anExpr, CxxName *aName) { return 0; }
+CxxExpression *make_dot_star_expression(CxxExpression *anExpr, CxxExpression *memberExpr) { return 0; }
+CxxExpression *make_dynamic_cast_expression(CxxExpression *aType, CxxExpression *anExpr) { return 0; }
+CxxName *make_elaborated_type_specifier(CxxClassKey *classKey, CxxName *aName) { return 0; }
+CxxParameter *make_ellipsis_expression() { return 0; }
+CxxName *make_enum_specifier_id(CxxName *aName, CxxEnumerators *aList) { return 0; }
+CxxEnumerator *make_enumerator(CxxName *aName, CxxExpression *anExpr) { return 0; }
+CxxEnumerators *make_enumerators(CxxEnumerators *aList, CxxEnumerator *anElement) { return 0; }
+CxxName *make_epsilon() { return 0; }
+CxxExpression *make_equal_expression(CxxExpression *leftExpr, CxxExpression *rightExpr) { return 0; }
+CxxExceptionDeclaration *make_exception_declaration(CxxParameter *aParameter) { return 0; }
+CxxExceptionSpecification *make_exception_specification(CxxExpressions *typeIds) { return 0; }
+CxxExpression *make_exclusive_or_expression(CxxExpression *leftExpr, CxxExpression *rightExpr) { return 0; }
+CxxDeclaration *make_explicit_implementation_declaration(CxxTokens *someTokens) { return 0; }
+CxxDeclaration *make_explicit_interface_declaration(CxxTokens *someTokens) { return 0; }
+CxxDeclaration *make_explicit_specialization(CxxDeclaration *aDeclaration) { return 0; }
+CxxDeclaration *make_export_implementation_declaration(CxxFileId *fileId) { return 0; }
+CxxDeclaration *make_export_interface_declaration(CxxFileId *fileId) { return 0; }
+CxxDeclaration *make_export_noimplementation_declaration() { return 0; }
+CxxExpression *make_expression(CxxExpressions *aList) { return 0; }
+CxxParameter *make_expression_parameter(CxxExpression *anExpr) { return 0; }
+CxxExpressions *make_expressions(CxxExpressions *aList, CxxExpression *anElement) { return 0; }
+CxxExpression *make_false_expression() { return 0; }
+CxxFileId *make_file_id(CxxFileName *fileName) { return 0; }
+CxxFileId *make_file_id_implementation(CxxName *aName) { return 0; }
+CxxFileId *make_file_id_interface(CxxName *aName) { return 0; }
+CxxFileIds *make_file_ids(CxxFileIds *aList, CxxFileId *anElement) { return 0; }
+CxxFileName *make_file_name(CxxStrings *aString) { return 0; }
+CxxFileName *make_file_name_guard(CxxFileName *fileName, CxxStrings *aString) { return 0; }
+CxxFileName *make_file_name_implementation(CxxFileName *fileName) { return 0; }
+CxxFileName *make_file_name_interface(CxxFileName *fileName) { return 0; }
+CxxFileName *make_file_name_noguard(CxxFileName *fileName) { return 0; }
+CxxFileName *make_file_name_path(CxxFileName *fileName, CxxStrings *aString) { return 0; }
+CxxFileName *make_file_name_prefix(CxxFileName *fileName, CxxStrings *aString) { return 0; }
+CxxFileName *make_file_name_suffix(CxxFileName *fileName, CxxStrings *aString) { return 0; }
+CxxFileName *make_file_name_template(CxxFileName *fileName) { return 0; }
+CxxFileName *make_file_name_utility(CxxFileName *fileName, CxxUtility *aUtility) { return 0; }
+CxxDeclaration *make_filespace_declaration(CxxName *aName) { return 0; }
+CxxName *make_filespace_specifier(CxxFileName *fileName, CxxDeclarations *aDeclaration) { return 0; }
+CxxExpression *make_floating_literal_expression(CxxFloatingLiteral *aLiteral) { return 0; }
+CxxStatement *make_for_statement(CxxExpression *initExpr, CxxCondition *testExpr, CxxExpression *stepExpr, CxxStatement *aStmt) { return 0; }
+CxxFunctionBody *make_function_block(CxxStatement *aStatement) { return 0; }
+CxxFunctionDeclarations *make_function_declarations(CxxFunctionDeclarations *aList, CxxDeclaration *anElement) { return 0; }
+CxxExpression *make_function_definition(CxxExpression *anExpr, CxxFunctionBody *functionBody) { return 0; }
+CxxDeclarator *make_global_declarator(CxxIsTemplate isTemplate, CxxDeclarator *aDeclarator) { return 0; }
+CxxExpression *make_global_expression(CxxIsTemplate isTemplate, CxxNewExpression *anExpr) { return 0; }
+CxxName *make_global_id(CxxIsTemplate isTemplate, CxxName *nestedId) { return 0; }
+CxxStatement *make_goto_statement(CxxToken *aLabel) { return 0; }
+CxxExpression *make_greater_equal_expression(CxxExpression *leftExpr, CxxExpression *rightExpr) { return 0; }
+CxxExpression *make_greater_than_expression(CxxExpression *leftExpr, CxxExpression *rightExpr) { return 0; }
+CxxHandler *make_handler(CxxExceptionDeclaration *exceptionDeclaration, CxxStatement *aStatement) { return 0; }
+CxxHandlers *make_handlers(CxxHandlers *aList, CxxHandler *anElement) { return 0; }
+CxxStatement *make_if_statement(CxxCondition *testExpr, CxxStatement *trueStmt, CxxStatement *falseStmt) { return 0; }
+CxxDeclaration *make_include_declaration(CxxStrings *aString, CxxUtility *aUtility) { return 0; }
+CxxExpression *make_inclusive_or_expression(CxxExpression *leftExpr, CxxExpression *rightExpr) { return 0; }
+CxxExpression *make_index_cast_expression(CxxExpression *aCast, CxxExpression *anExpr) { return 0; }
+CxxParameter *make_initialized_parameter(CxxParameter *aParameter, CxxExpression *anExpr) { return 0; }
+CxxInitializerClauses *make_initializer_clauses(CxxInitializerClauses *aList, CxxInitializerClause *anElement) { return 0; }
+CxxInitializerClause *make_initializer_expression_clause(CxxExpression *anExpr) { return 0; }
+CxxInitializerClause *make_initializer_list_clause(CxxInitializerClauses *aList) { return 0; }
+CxxSimpleTypeParameter *make_init_simple_type_parameter(CxxSimpleTypeParameter *templateParameters, CxxExpression *anExpr) { return 0; }
+CxxTemplatedTypeParameter *make_init_templated_parameter(CxxTemplatedTypeParameter *typeParameter, CxxName *aName) { return 0; }
+CxxDeclSpecifierId *make_inline_as_friend() { return 0; }
+CxxDeclSpecifierId *make_inline_if_short() { return 0; }
+CxxDeclSpecifierId *make_inline_in_implementation() { return 0; }
+CxxDeclSpecifierId *make_inline_in_interface() { return 0; }
+CxxFileId *make_input_file(CxxFileId *fileId) { return 0; }
+CxxExpression *make_integer_literal_expression(CxxIntegerLiteral *aLiteral) { return 0; }
+CxxStatement *make_label_statement(CxxToken *aLabel, CxxStatement *aStmt) { return 0; }
+CxxExpression *make_less_equal_expression(CxxExpression *leftExpr, CxxExpression *rightExpr) { return 0; }
+CxxExpression *make_less_than_expression(CxxExpression *leftExpr, CxxExpression *rightExpr) { return 0; }
+CxxLine *make_line() { return 0; }
+CxxDeclaration *make_lined_declaration(CxxDeclaration *aDeclaration, CxxLine *aLine) { return 0; }
+CxxStatement *make_lined_statement(CxxStatement *aStatement, CxxLine *aLine) { return 0; }
+CxxToken *make_lined_token(CxxToken *aToken, CxxLine *aLine) { return 0; }
+CxxName *make_linkage_specifier(CxxStrings *aString, CxxDeclaration *aDeclaration) { return 0; }
+CxxExpression *make_logical_and_expression(CxxExpression *leftExpr, CxxExpression *rightExpr) { return 0; }
+CxxExpression *make_logical_or_expression(CxxExpression *leftExpr, CxxExpression *rightExpr) { return 0; }
+CxxMemInitializer *make_mem_initializer(CxxName *aName, CxxExpression *anExpr) { return 0; }
+CxxMemInitializers *make_mem_initializers(CxxMemInitializers *aList, CxxMemInitializer *anElement) { return 0; }
+CxxMemberDeclarations *make_member_declarations(CxxMemberDeclarations *aList, CxxDeclaration *aDeclaration) { return 0; }
+CxxExpression *make_meta_assignment_expression(CxxExpression *leftExpr, CxxToken *assOp, CxxToken *rightExpr) { return 0; }
+CxxBaseSpecifier *make_meta_base_specifier(CxxBaseSpecifier *baseSpecifier) { return 0; }
+CxxMetaType *make_meta_built_in_type(CxxBuiltInId *aName) { return 0; }
+CxxStatement *make_meta_break_statement() { return 0; }
+CxxStatement *make_meta_case_statement(CxxExpression *anExpr, CxxToken *someTokens) { return 0; }
+CxxMetaClass *make_meta_class(CxxName *metaClass, CxxBaseSpecifiers *baseSpecifiers, CxxToken *classBody) { return 0; }
+CxxStatement *make_meta_continue_statement() { return 0; }
+CxxDeclaration *make_meta_declaration_declaration(CxxDeclaration *metaDeclaration) { return 0; }
+CxxStatement *make_meta_default_statement(CxxToken *someTokens) { return 0; }
+CxxStatement *make_meta_do_while_statement(CxxLine *aLine, CxxToken *bodyTokens, CxxToken *testTokens) { return 0; }
+CxxStatement *make_meta_expression_statement(CxxName *aName, CxxToken *bodyTokens) { return 0; }
+CxxStatement *make_meta_for_statement(CxxLine *aLine, CxxExpression *initTokens, CxxToken *testTokens,
+ CxxToken *stepTokens, CxxToken *bodyTokens) { return 0; }
+CxxExpression *make_meta_function(CxxExpression *anExpr, CxxTokens *aList, CxxToken *aBody) { return 0; }
+CxxStatement *make_meta_if_statement(CxxLine *aLine, CxxExpression *testTokens, CxxToken *trueTokens, CxxToken *falseTokens) { return 0; }
+CxxDeclaration *make_linkage_specification(CxxName *aName) { return 0; }
+//CxxMetaInitializers *make_meta_initializers(CxxMetaInitializers *aList, CxxToken *anElement) { return 0; }
+CxxMetaParameter *make_meta_parameter(CxxMetaType *metaType, CxxIsTree isTree, CxxName *aName, CxxToken *anInit) { return 0; }
+CxxMetaParameters *make_meta_parameters(CxxMetaParameters *aList, CxxMetaParameter *anElement) { return 0; }
+CxxStatement *make_meta_return_statement(CxxExpression *anExpr) { return 0; }
+CxxStatement *make_meta_statement(CxxStatement *aStatement) { return 0; }
+CxxDeclaration *make_meta_statement_declaration(CxxStatement *metaStatement) { return 0; }
+CxxStatement *make_meta_statement_statement(CxxStatement *metaStatement) { return 0; }
+CxxStatement *make_meta_switch_statement(CxxLine *aLine, CxxExpression *testTokens, CxxToken *bodyTokens) { return 0; }
+CxxMetaType *make_meta_type(CxxName *aName) { return 0; }
+CxxName *make_meta_type_id(CxxMetaType *metaType) { return 0; }
+CxxStatement *make_meta_while_statement(CxxLine *aLine, CxxToken *testTokens, CxxToken *bodyTokens) { return 0; }
+CxxExpression *make_minus_expression(CxxExpression *anExpr) { return 0; }
+CxxExpression *make_modulus_expression(CxxExpression *leftExpr, CxxExpression *rightExpr) { return 0; }
+CxxExpression *make_multiply_expression(CxxExpression *leftExpr, CxxDeclarator *aDeclarator, CxxExpression *rightExpr) { return 0; }
+CxxName *make_name(CxxName *aName) { return 0; }
+CxxName *make_name_expression(CxxName *aName) { return 0; }
+CxxDeclaration *make_namespace_alias_definition(CxxName *aName, CxxName *forId) { return 0; }
+CxxDeclaration *make_namespace_declaration(CxxName *aName) { return 0; }
+CxxName *make_namespace_definition(CxxName *aName, CxxDeclarations *aDeclaration) { return 0; }
+CxxDeclarator *make_nested_declarator(CxxName *aName, CxxDeclarator *aDeclarator) { return 0; }
+CxxName *make_nested_id(CxxName *nestingId, CxxName *nestedId) { return 0; }
+CxxName *make_nested_scope(CxxName *nestingId) { return 0; }
+CxxExpression *make_new_expression(CxxParameters *aPlace, CxxParameters *aType, CxxExpression *anInit) { return 0; }
+CxxExpression *make_new_type_id_expression(CxxParameters *aPlace, CxxExpression *aType, CxxExpression *anInit) { return 0; }
+CxxDeclSpecifierId *make_not_const() { return 0; }
+CxxExpression *make_not_equal_expression(CxxExpression *leftExpr, CxxExpression *rightExpr) { return 0; }
+CxxExpression *make_not_expression(CxxExpression *anExpr) { return 0; }
+CxxDeclSpecifierId *make_not_inline() { return 0; }
+CxxDeclSpecifierId *make_not_static() { return 0; }
+CxxDeclSpecifierId *make_not_virtual() { return 0; }
+CxxBaseSpecifier *make_not_virtual_base_specifier(CxxBaseSpecifier *baseSpecifier) { return 0; }
+CxxDeclSpecifierId *make_not_volatile() { return 0; }
+CxxExpression *make_number_literal_expression(CxxExpression *anExpr) { return 0; }
+CxxExpression *make_object_scope_expression(CxxExpression *anExpr, CxxDeclaration *functionDeclarations) { return 0; }
+CxxName *make_operator_add_id() { return 0; }
+CxxName *make_operator_arrow_id() { return 0; }
+CxxName *make_operator_arrow_star_id() { return 0; }
+CxxName *make_operator_ass_add_id() { return 0; }
+CxxName *make_operator_ass_bit_and_id() { return 0; }
+CxxName *make_operator_ass_bit_or_id() { return 0; }
+CxxName *make_operator_ass_div_id() { return 0; }
+CxxName *make_operator_ass_id() { return 0; }
+CxxName *make_operator_ass_mod_id() { return 0; }
+CxxName *make_operator_ass_mul_id() { return 0; }
+CxxName *make_operator_ass_shl_id() { return 0; }
+CxxName *make_operator_ass_shr_id() { return 0; }
+CxxName *make_operator_ass_sub_id() { return 0; }
+CxxName *make_operator_ass_xor_id() { return 0; }
+CxxName *make_operator_bit_and_id() { return 0; }
+CxxName *make_operator_bit_not_id() { return 0; }
+CxxName *make_operator_bit_or_id() { return 0; }
+CxxName *make_operator_call_id() { return 0; }
+CxxName *make_operator_comma_id() { return 0; }
+CxxName *make_operator_dec_id() { return 0; }
+CxxName *make_operator_delete_id() { return 0; }
+CxxName *make_operator_div_id() { return 0; }
+CxxName *make_operator_eq_id() { return 0; }
+CxxName *make_operator_function_id(CxxName *operatorId) { return 0; }
+CxxName *make_operator_ge_id() { return 0; }
+CxxName *make_operator_gt_id() { return 0; }
+CxxName *make_operator_inc_id() { return 0; }
+CxxName *make_operator_index_id() { return 0; }
+CxxName *make_operator_le_id() { return 0; }
+CxxName *make_operator_log_and_id() { return 0; }
+CxxName *make_operator_log_not_id() { return 0; }
+CxxName *make_operator_log_or_id() { return 0; }
+CxxName *make_operator_lt_id() { return 0; }
+CxxName *make_operator_mod_id() { return 0; }
+CxxName *make_operator_mul_id() { return 0; }
+CxxName *make_operator_ne_id() { return 0; }
+CxxName *make_operator_new_id() { return 0; }
+CxxName *make_operator_shl_id() { return 0; }
+CxxName *make_operator_shr_id() { return 0; }
+CxxName *make_operator_sub_id() { return 0; }
+CxxName *make_operator_xor_id() { return 0; }
+CxxParameters *make_parameters(CxxParameters *aList, CxxParameter *anElement) { return 0; }
+CxxParenthesised *make_parenthesised(CxxParameters *aList, CxxCvQualifiers *cvQualifiers, CxxExceptionSpecification *exceptionSpecification) { return 0; }
+CxxExpression *make_plus_expression(CxxExpression *anExpr) { return 0; }
+CxxPointerDeclarator *make_pointer_declarator() { return 0; }
+CxxExpression *make_pointer_expression(CxxDeclarator *aDeclarator, CxxExpression *anExpr) { return 0; }
+CxxExpression *make_post_decrement_expression(CxxExpression *anExpr) { return 0; }
+CxxExpression *make_post_increment_expression(CxxExpression *anExpr) { return 0; }
+CxxExpression *make_pre_decrement_expression(CxxExpression *anExpr) { return 0; }
+CxxExpression *make_pre_increment_expression(CxxExpression *anExpr) { return 0; }
+CxxName *make_pseudo_destructor_id(CxxBuiltInId *aScope, CxxBuiltInId *aName) { return 0; }
+CxxDeclSpecifierId *make_pure_virtual() { return 0; }
+CxxDeclarator *make_reference_declarator() { return 0; }
+CxxExpression *make_reinterpret_cast_expression(CxxExpression *aType, CxxExpression *anExpr) { return 0; }
+CxxStatement *make_return_statement(CxxExpression *anExpr) { return 0; }
+CxxName *make_scoped_id(CxxName *globalId, CxxName *nestedId) { return 0; }
+CxxExpression *make_scoped_pointer_expression(CxxExpression *aScope, CxxDeclarator *aDeclarator, CxxExpression *anExpr) { return 0; }
+CxxSegment *make_segment(CxxSegment *aSegment) { return 0; }
+CxxFunctionBody *make_segment_function_block(CxxFunctionBody *functionBody, CxxSegment *aSegment) { return 0; }
+CxxDeclSpecifierId *make_set_template_decl_specifier(CxxDeclSpecifierId *aName) { return 0; }
+CxxDeclaration *make_set_template_declaration(CxxDeclaration *aDeclaration) { return 0; }
+CxxExpression *make_set_template_expression(CxxExpression *anExpr) { return 0; }
+CxxName *make_set_template_id(CxxName *aName) { return 0; }
+CxxName *make_set_template_name(CxxName *aName) { return 0; }
+CxxName *make_set_template_scope(CxxName *aName) { return 0; }
+CxxExpression *make_shift_left_expression(CxxExpression *leftExpr, CxxExpression *rightExpr) { return 0; }
+CxxExpression *make_shift_right_expression(CxxExpression *leftExpr, CxxExpression *rightExpr) { return 0; }
+CxxDeclaration *make_simple_declaration(CxxExpression *anExpr) { return 0; }
+CxxExpression *make_sizeof_expression(CxxExpression *anExpr) { return 0; }
+CxxStatements *make_statements(CxxStatements *, CxxStatement *aStmt) { return 0; }
+CxxExpression *make_static_cast_expression(CxxExpression *aType, CxxExpression *anExpr) { return 0; }
+CxxExpression *make_string_literal_expression(CxxStrings *aString) { return 0; }
+CxxStrings *make_strings(CxxStringLiteral *anElement, CxxStrings *aList) { return 0; }
+CxxExpression *make_subtract_expression(CxxExpression *leftExpr, CxxExpression *rightExpr) { return 0; }
+CxxStatement *make_switch_statement(CxxCondition *testExpr, CxxStatement *aStmt) { return 0; }
+CxxExpression *make_syntax_macro_definition(CxxMetaType *metaType, CxxIsTree isTree, CxxName *aName, CxxSyntaxMacroParameters *aList, CxxToken *aBody) { return 0; }
+CxxSyntaxMacroParameter *make_syntax_macro_parameter(CxxToken *metaType, CxxIsTree isTree, CxxName *aName) { return 0; }
+CxxSyntaxMacroParameters *make_syntax_macro_parameters(CxxSyntaxMacroParameters *aList, CxxSyntaxMacroParameter *anElement) { return 0; }
+CxxTemplateArgument *make_template_argument(CxxParameter *aParameter) { return 0; }
+CxxTemplateArguments *make_template_arguments(CxxTemplateArguments *aList, CxxTemplateArgument *anElement) { return 0; }
+CxxDeclaration *make_template_declaration(CxxTemplateParameters *aList, CxxDeclaration *aDeclaration) { return 0; }
+CxxName *make_template_name(CxxName *aName, CxxTemplateArguments *templateArguments) { return 0; }
+CxxTemplateParameter *make_templated_template_parameter(CxxTemplateParameter *typeParameter, CxxName *aName) { return 0; }
+CxxTemplateParameter *make_template_parameter(CxxParameter *aParameter) { return 0; }
+CxxTemplateParameters *make_template_parameters(CxxTemplateParameters *aList, CxxTemplateParameter *anElement) { return 0; }
+CxxTemplatedTypeParameter *make_templated_type_parameter(CxxTemplateParameters *templateParameters, CxxName *aName) { return 0; }
+CxxExpression *make_this_expression() { return 0; }
+CxxExpression *make_throw_expression(CxxExpression *anExpr) { return 0; }
+CxxExpression *make_tokens_expression(CxxTokens *someTokens) { return 0; }
+CxxToken *make_tree_argument(CxxToken *aToken) { return 0; }
+CxxTokens *make_tree_arguments(CxxTokens *aList, CxxToken *anElement) { return 0; }
+CxxTreeExpression *make_tree_array_expression(CxxTreeExpression *anExpr, CxxExpression *indexExpr) { return 0; }
+CxxTreeExpression *make_tree_arrow_expression(CxxTreeExpression *anExpr, CxxName *aName) { return 0; }
+CxxTreeExpression *make_tree_call_expression(CxxTreeExpression *anExpr, CxxTokens *aList) { return 0; }
+CxxTreeExpression *make_tree_dot_expression(CxxTreeExpression *anExpr, CxxName *aName) { return 0; }
+CxxTreeExpression *make_tree_expression(CxxName *aName) { return 0; }
+CxxName *make_tree_id(CxxName *aName) { return 0; }
+CxxTreeExpression *make_tree_pointer_expression(CxxTreeExpression *anExpr) { return 0; }
+CxxExpression *make_true_expression() { return 0; }
+CxxFunctionBody *make_try_block(CxxStatement *aStatement, CxxHandlers *exceptionHandlers) { return 0; }
+CxxStatement *make_try_block_statement(CxxFunctionBody *tryBlock) { return 0; }
+CxxFunctionBody *make_try_function_block(CxxFunctionBody *functionBody, CxxHandlers *exceptionHandlers) { return 0; }
+CxxExpression *make_type1_expression(CxxExpression *functionName, CxxParenthesised *aParenthesis, CxxType1Parameters *type1Parameters) { return 0; }
+CxxTemplateParameter *make_type_template_parameter(CxxSimpleTypeParameter *typeParameter, CxxExpression *typeId) { return 0; }
+CxxExpression *make_typed_expression(CxxName *frontName, CxxExpression *backName) { return 0; }
+CxxName *make_typed_name(CxxName *frontName, CxxName *backName) { return 0; }
+CxxExpression *make_typeid_expression(CxxExpression *aList) { return 0; }
+CxxSimpleTypeParameter *make_typename_template_parameter(CxxName *aName) { return 0; }
+CxxSimpleTypeParameter *make_typename_type_parameter(CxxName *aName) { return 0; }
+CxxType1Parameters *make_type1_parameters(CxxType1Parameters *aList, CxxParameters *someParameters) { return 0; }
+CxxDeclaration *make_using_declaration(bool isTypename, CxxName *aName) { return 0; }
+CxxDeclaration *make_using_directive(CxxName *aName) { return 0; }
+CxxFunctionBody *make_using_function_block(CxxFunctionBody *functionBody, CxxFileIds *fileIds) { return 0; }
+CxxDeclaration *make_using_implementation_declaration(CxxFileId *fileId) { return 0; }
+CxxDeclaration *make_using_interface_declaration(CxxFileId *fileId) { return 0; }
+CxxUtility *make_utility(CxxUtility *aUtility) { return 0; }
+CxxUtility *make_utility_mode() { return 0; }
+CxxBaseSpecifier *make_virtual_base_specifier(CxxBaseSpecifier *baseSpecifier) { return 0; }
+CxxStatement *make_while_statement(CxxCondition *testExpr, CxxStatement *aStmt) { return 0; }
+
--- /dev/null
+//
+// Title: C++ Grammar Token support compilation unit.
+//
+// File Name: CxxToken.cpp
+//
+// Author: E.D.Willink
+//END
+//
+#include <CxxToken.cxx>
--- /dev/null
+#include <CxxToken.hxx>
+#include <memory.h>
+
+//CxxToken::CxxToken()
+//:
+// _value(0)
+//{}
+
+CxxNaffToken::CxxNaffToken(int tokenValue, const char *yyText, int yyLeng)
+:
+ Super(tokenValue), _text(new char[yyLeng+1]), _leng(yyLeng)
+{
+ memcpy(_text, yyText, yyLeng);
+ _text[_leng] = 0;
+}
+
+CxxNaffToken::~CxxNaffToken() { delete[] _text; }
--- /dev/null
+#ifndef CXXTOKEN_HXX
+#define CXXTOKEN_HXX
+
+#include <iostream.h>
+#include <stdlib.h>
+
+#define YYSTYPE CxxTokenType
+#define YY_parse_STYPE CxxTokenType
+#define YACC_BANG_TYPE size_t
+#define YACC_MARK_TYPE size_t
+
+#define YACC_BANG() push_bang()
+#define YACC_UNBANG(bangValue, msg) pop_bang(bangValue); yyerrok; yyclearin; yyerror(msg);
+
+#define ERRMSG(a) do { cout << "ERROR -- " << a << endl; increment_error_count(); } while (0)
+
+#ifdef NEEDS_BOOL
+enum bool { false, true };
+#endif
+
+#ifdef BISON_PP_CLASS
+#define PARSE_TOKEN(a) BISON_PP_CLASS::a
+#else
+#define PARSE_TOKEN(a) a
+#endif
+
+extern size_t line_number;
+extern bool c_keywords;
+extern bool echo_line_numbers;
+extern bool echo_line_text;
+extern void increment_error_count();
+extern int tokenMarkDepth;
+
+class CxxToken
+{
+ int _value;
+private:
+ CxxToken(const CxxToken&);
+ CxxToken& operator=(const CxxToken&);
+public:
+ CxxToken(int tokenValue = 0) : _value(tokenValue) {}
+ virtual ~CxxToken() {}
+ int value() const { return _value; }
+};
+
+enum CxxIsTemplate { IS_DEFAULT, IS_TEMPLATE };
+enum CxxIsTree { IS_SCALAR, IS_TREE };
+typedef CxxToken CxxTreeArgument;
+
+class CxxStatement : public CxxToken {};
+typedef CxxStatement CxxDeclaration;
+class CxxExpression : public CxxStatement {};
+class CxxName : public CxxExpression {};
+class CxxTokens : public CxxToken {};
+class CxxMetaObject : public CxxExpression {};
+class CxxMetaStatement : public CxxStatement {};
+
+class CxxStatements : public CxxStatement {};
+typedef CxxStatements CxxDeclarations;
+typedef CxxDeclarations CxxMemberDeclarations;
+typedef CxxExpression CxxTreeExpression;
+
+class CxxKeyword : public CxxName {};
+class CxxDeclSpecifierId : public CxxKeyword {};
+
+class CxxAccessSpecifier : public CxxKeyword {};
+class CxxBaseSpecifier : public CxxToken {};
+class CxxBaseSpecifiers : public CxxTokens {};
+class CxxBrace : public CxxToken {};
+class CxxBuiltInId : public CxxName {};
+class CxxCharacterLiteral : public CxxToken {};
+class CxxClass : public CxxToken {};
+class CxxClassKey : public CxxKeyword {};
+class CxxCondition : public CxxExpression {};
+class CxxCvQualifiers : public CxxDeclSpecifierId {};
+class CxxDeclarator : public CxxToken {};
+typedef CxxExpression CxxDeleteExpression;
+//class CxxDerived : public CxxToken {};
+//class CxxEnum : public CxxToken {};
+class CxxEnumerator : public CxxToken {};
+class CxxEnumerators : public CxxTokens {};
+class CxxExceptionDeclaration : public CxxToken {};
+class CxxExceptionSpecification : public CxxToken {};
+class CxxExpressions : public CxxExpression {};
+class CxxFileId : public CxxToken {};
+class CxxFileIds : public CxxTokens {};
+class CxxFileName : public CxxToken {};
+class CxxFloatingLiteral : public CxxToken {};
+class CxxFunctionBody : public CxxStatement {};
+class CxxFunctionDeclarations : public CxxDeclarations {};
+class CxxHandler : public CxxToken {};
+class CxxHandlers : public CxxTokens {};
+class CxxIdentifier : public CxxName {};
+//class CxxIds : public CxxTokens {};
+class CxxInitializerClause : public CxxExpression {};
+class CxxInitializerClauses : public CxxInitializerClause {};
+class CxxIntegerLiteral : public CxxToken {};
+class CxxLine : public CxxToken {};
+//class CxxList : public CxxTokens {};
+class CxxMemInitializer : public CxxToken {};
+class CxxMemInitializers : public CxxTokens {};
+class CxxMetaClass : public CxxStatement {};
+class CxxMetaFunction : public CxxMetaObject {};
+class CxxMetaInitializer : public CxxToken {};
+class CxxMetaInitializers : public CxxTokens {};
+class CxxMetaParameter : public CxxToken {};
+class CxxMetaParameters : public CxxTokens {};
+//class CxxMetaPrototype : public CxxToken {};
+//class CxxMetaPrototypes : public CxxTokens {};
+class CxxMetaType : public CxxName {};
+class CxxMetaVariable : public CxxMetaObject {};
+class CxxNamespace : public CxxToken {};
+typedef CxxExpression CxxNewExpression;
+class CxxNumberLiteral : public CxxExpression {};
+class CxxParameter : public CxxExpression {};
+class CxxParameters : public CxxExpression {};
+class CxxParenthesised : public CxxToken {};
+class CxxPointerDeclarator : public CxxDeclarator {};
+class CxxPosition : public CxxName {};
+class CxxSegment : public CxxName {};
+class CxxSpacing : public CxxToken {};
+class CxxStrings : public CxxToken {};
+typedef CxxStrings CxxStringLiteral;
+class CxxSubspace : public CxxToken {};
+class CxxSyntaxMacroParameter : public CxxToken {};
+class CxxSyntaxMacroParameters : public CxxTokens {};
+class CxxTemplateArgument : public CxxToken {};
+class CxxTemplateArguments : public CxxTokens {};
+class CxxTemplateParameter : public CxxToken {};
+class CxxTemplateParameters : public CxxTokens {};
+class CxxSimpleTypeParameter : public CxxTemplateParameter {};
+class CxxTemplatedTypeParameter : public CxxTemplateParameter {};
+class CxxTokenStatements : public CxxTokens {};
+class CxxTreeArguments : public CxxTokens {};
+class CxxType1Parameters : public CxxTokens {};
+class CxxTypeId : public CxxToken {};
+class CxxTypeIds : public CxxTokens {};
+class CxxUtility : public CxxToken {};
+
+#define FOGPARSERVALUE_ENUM(T,N) \
+ const T *name2(u_,N); \
+ const T& N() const { return *name2(u_,N); } \
+ const T* & N() { return name2(u_,N); }
+#define FOGPARSERVALUE_POINTER(T,N) T *N;
+#define FOGPARSERVALUE_VALUE(T,N) T N;
+
+union CxxTokenType
+{
+ CxxToken *_token;
+
+ FOGPARSERVALUE_VALUE(bool, _bool)
+ FOGPARSERVALUE_VALUE(long, _long)
+ FOGPARSERVALUE_POINTER(CxxBrace, brace)
+ FOGPARSERVALUE_POINTER(CxxSpacing, spacing)
+
+ FOGPARSERVALUE_POINTER(CxxAccessSpecifier, access_specifier)
+ FOGPARSERVALUE_POINTER(CxxBaseSpecifier, base_specifier)
+ FOGPARSERVALUE_POINTER(CxxBaseSpecifiers, base_specifiers)
+ FOGPARSERVALUE_POINTER(CxxBuiltInId, built_in_id)
+ FOGPARSERVALUE_POINTER(CxxCharacterLiteral, character_literal)
+ FOGPARSERVALUE_POINTER(CxxClass, _class)
+ FOGPARSERVALUE_POINTER(CxxClassKey, class_key)
+ FOGPARSERVALUE_POINTER(CxxCondition, condition)
+ FOGPARSERVALUE_POINTER(CxxCvQualifiers, cv_qualifiers)
+ FOGPARSERVALUE_POINTER(CxxDeclSpecifierId, decl_specifier_id)
+ FOGPARSERVALUE_POINTER(CxxDeclaration, declaration)
+ FOGPARSERVALUE_POINTER(CxxDeclarations, declarations)
+ FOGPARSERVALUE_POINTER(CxxDeclarator, declarator)
+ FOGPARSERVALUE_POINTER(CxxDeleteExpression, delete_expression)
+ FOGPARSERVALUE_POINTER(CxxEnumerator, enumerator)
+ FOGPARSERVALUE_POINTER(CxxEnumerators, enumerators)
+ FOGPARSERVALUE_POINTER(CxxExceptionDeclaration, exception_declaration)
+ FOGPARSERVALUE_POINTER(CxxExceptionSpecification, exception_specification)
+ FOGPARSERVALUE_POINTER(CxxExpression, expression)
+ FOGPARSERVALUE_POINTER(CxxExpressions, expressions)
+ FOGPARSERVALUE_POINTER(CxxFileId, file_id)
+ FOGPARSERVALUE_POINTER(CxxFileIds, file_ids)
+ FOGPARSERVALUE_POINTER(CxxFileName, file_name)
+ FOGPARSERVALUE_POINTER(CxxFloatingLiteral, floating_literal)
+ FOGPARSERVALUE_POINTER(CxxFunctionBody, function_body)
+ FOGPARSERVALUE_POINTER(CxxHandler, handler)
+ FOGPARSERVALUE_POINTER(CxxHandlers, handlers)
+ FOGPARSERVALUE_POINTER(CxxIdentifier, identifier)
+ FOGPARSERVALUE_POINTER(CxxInitializerClause, initializer_clause)
+ FOGPARSERVALUE_POINTER(CxxInitializerClauses, initializer_clauses)
+ FOGPARSERVALUE_POINTER(CxxIntegerLiteral, integer_literal)
+ FOGPARSERVALUE_POINTER(CxxKeyword, keyword)
+ FOGPARSERVALUE_POINTER(CxxLine, line)
+ FOGPARSERVALUE_POINTER(CxxMemInitializer, mem_initializer)
+ FOGPARSERVALUE_POINTER(CxxMemInitializers, mem_initializers)
+ FOGPARSERVALUE_POINTER(CxxMemberDeclarations, member_declarations)
+ FOGPARSERVALUE_POINTER(CxxMetaClass, meta_class)
+ FOGPARSERVALUE_POINTER(CxxMetaFunction, meta_function)
+ FOGPARSERVALUE_POINTER(CxxMetaInitializer, meta_initializer)
+ FOGPARSERVALUE_POINTER(CxxMetaInitializers, meta_initializers)
+ FOGPARSERVALUE_POINTER(CxxMetaObject, meta_object)
+ FOGPARSERVALUE_POINTER(CxxMetaStatement, meta_statement)
+ FOGPARSERVALUE_POINTER(CxxMetaType, meta_type)
+ FOGPARSERVALUE_POINTER(CxxMetaVariable, meta_variable)
+ FOGPARSERVALUE_POINTER(CxxName, name)
+ FOGPARSERVALUE_POINTER(CxxNewExpression, new_expression)
+ FOGPARSERVALUE_POINTER(CxxNumberLiteral, number_literal)
+ FOGPARSERVALUE_POINTER(CxxParameter, parameter)
+ FOGPARSERVALUE_POINTER(CxxParameters, parameters)
+ FOGPARSERVALUE_POINTER(CxxParenthesised, parenthesised)
+ FOGPARSERVALUE_POINTER(CxxPointerDeclarator, pointer_declarator)
+ FOGPARSERVALUE_POINTER(CxxPosition, position)
+ FOGPARSERVALUE_POINTER(CxxSegment, segment)
+ FOGPARSERVALUE_POINTER(CxxSimpleTypeParameter, simple_type_parameter)
+ FOGPARSERVALUE_POINTER(CxxStatement, statement)
+ FOGPARSERVALUE_POINTER(CxxStatements, statements)
+ FOGPARSERVALUE_POINTER(CxxStringLiteral, string_literal)
+ FOGPARSERVALUE_POINTER(CxxStrings, strings)
+ FOGPARSERVALUE_POINTER(CxxSubspace, subspace)
+ FOGPARSERVALUE_POINTER(CxxSyntaxMacroParameter, syntax_macro_parameter)
+ FOGPARSERVALUE_POINTER(CxxSyntaxMacroParameters, syntax_macro_parameters)
+ FOGPARSERVALUE_POINTER(CxxTemplateArgument, template_argument)
+ FOGPARSERVALUE_POINTER(CxxTemplateArguments, template_arguments)
+ FOGPARSERVALUE_POINTER(CxxTemplateParameter, template_parameter)
+ FOGPARSERVALUE_POINTER(CxxTemplateParameters, template_parameters)
+ FOGPARSERVALUE_POINTER(CxxTemplatedTypeParameter, templated_type_parameter)
+ FOGPARSERVALUE_POINTER(CxxToken, token)
+ FOGPARSERVALUE_POINTER(CxxTokenStatements, token_statements)
+ FOGPARSERVALUE_POINTER(CxxTokens, tokens)
+ FOGPARSERVALUE_POINTER(CxxTreeArgument, tree_argument)
+ FOGPARSERVALUE_POINTER(CxxTreeArguments, tree_arguments)
+ FOGPARSERVALUE_POINTER(CxxTreeExpression, tree_expression)
+ FOGPARSERVALUE_POINTER(CxxType1Parameters, type1_parameters)
+ FOGPARSERVALUE_POINTER(CxxUtility, utility)
+
+ FOGPARSERVALUE_VALUE(int, bang)
+ FOGPARSERVALUE_VALUE(CxxIsTemplate, is_template)
+ FOGPARSERVALUE_VALUE(YACC_MARK_TYPE, mark)
+ FOGPARSERVALUE_VALUE(size_t, nest)
+#if 0
+ CxxAccessSpecifier *access_specifier;
+ CxxBaseSpecifier *base_specifier;
+ CxxBaseSpecifiers *base_specifiers;
+ CxxBuiltInId *built_in_id;
+ CxxCharacterLiteral *character_literal;
+ CxxClass *_class;
+ CxxClassKey *class_key;
+ CxxCondition *condition;
+ CxxCvQualifiers *cv_qualifiers;
+ CxxDeclaration *declaration;
+ CxxDeclarations *declarations;
+ CxxDeclarator *declarator;
+ CxxDeclSpecifierId *decl_specifier_id;
+// CxxDerived *derived;
+// CxxEnum *_enum;
+ CxxEnumerator *enumerator;
+ CxxEnumerators *enumerators;
+ CxxExceptionDeclaration *exception_declaration;
+ CxxExceptionSpecification *exception_specification;
+ CxxExpression *expression;
+ CxxExpressions *expressions;
+ CxxFileId *file_id;
+ CxxFileIds *file_ids;
+ CxxFileName *file_name;
+ CxxFloatingLiteral *floating_literal;
+ CxxFunctionBody *function_body;
+ CxxFunctionDeclarations *function_declarations;
+ CxxHandler *handler;
+ CxxHandlers *handlers;
+ CxxIdentifier *identifier;
+// CxxIds *ids;
+ CxxInitializerClause *initializer_clause;
+ CxxInitializerClauses *initializer_clauses;
+ CxxIntegerLiteral *integer_literal;
+ CxxKeyword *keyword;
+ CxxLine *line;
+// CxxList *list;
+ CxxMemInitializer *mem_initializer;
+ CxxMemInitializers *mem_initializers;
+ CxxMemberDeclarations *member_declarations;
+ CxxMetaClass *meta_class;
+// CxxMetaFunction *meta_function;
+// CxxMetaInitializer *meta_initializer;
+// CxxMetaInitializers *meta_initializers;
+// CxxMetaObject *meta_object;
+ CxxMetaParameter *meta_parameter;
+ CxxMetaParameters *meta_parameters;
+// CxxMetaPrototype *meta_prototype;
+// CxxMetaPrototypes *meta_prototypes;
+// CxxMetaStatement *meta_statement;
+ CxxMetaType *meta_type;
+// CxxMetaVariable *meta_variable;
+ CxxName *name;
+// CxxNamespace *_namespace;
+ CxxNumberLiteral *number_literal;
+ CxxParameter *parameter;
+ CxxParameters *parameters;
+ CxxParenthesised *parenthesised;
+ CxxPointerDeclarator *pointer_declarator;
+ CxxSegment *segment;
+ CxxSimpleTypeParameter *simple_type_parameter;
+ CxxStatement *statement;
+ CxxStatements *statements;
+ CxxStringLiteral *string_literal;
+ CxxStrings *strings;
+ CxxSyntaxMacroParameter *syntax_macro_parameter;
+ CxxSyntaxMacroParameters *syntax_macro_parameters;
+ CxxTemplateArgument *template_argument;
+ CxxTemplateArguments *template_arguments;
+ CxxTemplateParameter *template_parameter;
+ CxxTemplateParameters *template_parameters;
+ CxxTemplatedTypeParameter *templated_type_parameter;
+ CxxToken *token;
+ CxxTokens *tokens;
+// CxxTreeArgument *tree_argument;
+// CxxTreeArguments *tree_arguments;
+// CxxTreeExpression *tree_expression;
+ CxxType1Parameters *type1_parameters;
+// CxxTypeId *type_id;
+// CxxTypeIds *type_ids;
+ CxxUtility *utility;
+ YACC_BANG_TYPE bang;
+ YACC_MARK_TYPE mark;
+ size_t nest;
+#endif
+};
+
+class CxxNaffToken : public CxxToken
+{
+ typedef CxxToken Super;
+ char *_text;
+ int _leng;
+private:
+ CxxNaffToken(const CxxNaffToken&);
+ CxxNaffToken& operator=(const CxxNaffToken&);
+public:
+ CxxNaffToken(int tokenValue, const char *yyText, int yyLeng);
+ virtual ~CxxNaffToken();
+};
+
+#endif
--- /dev/null
+This directory tree comprises a pre-built demonstration of the superset C++ grammar
+from FOG..
+
+Contents
+--------
+
+ Release/grammar.exe -- the statically bound executable (on NT)
+ sun4o/grammar -- the statically bound executable (on Unix)
+
+It is a command line based utility. See index.html for details.
+
+Bug reporting
+-------------
+
+Please report any bugs to Ed.Willink@rrl.co.uk. I will endeavour to fix them,
+but since this code is a one man effort and my time is primarily devoted to
+my other activities for Thales Research, only simple and easy fixes are likely.
+I am more likely to be able to fix the problem if you can trim your problem to
+just a few lines.
+
--- /dev/null
+<html>
+
+<head>
+<meta http-equiv="Content-Type"
+content="text/html; charset=iso-8859-1">
+<meta name="GENERATOR" content="Microsoft FrontPage Express 2.0">
+<title>Ed's Toolkit</title>
+</head>
+
+<body bgcolor="#FFFFFF">
+
+<h1 align="center">Superset C++ Grammar</h1>
+
+<hr>
+
+<p>This work area supports a demonstration of the superset C++
+grammar described in Chapter 5 of <a
+href="mailto:Ed.Willink@rrl.co.uk">Ed Willink</a>'s thesis on <a
+href="http://www.computing.surrey.ac.uk/research/dsrg/fog/FogThesis.html">Meta-Compilation
+for C++</a>. It contains working lex and yacc grammars that
+enable C++ source to be lexically analysed, then syntactically
+analysed without semantic knowlege. The lex and yacc grammar have
+their action routines defined by macros in the hope that
+reconfiguration may be possible without editing the grammars
+directly. The dummy implementations of the yacc macros do nothing
+other than count statements and diagnose the back-tracking
+behaviour. Users may add their own syntactic level code. A proper
+C++ parser needs semantic analysis as well, including correction
+of minor misprses at the syntactic level. Semantic interpretaion
+is provided by <a
+href="http://www.computing.surrey.ac.uk/research/dsrg/fog/">FOG</a>
+from which this demonstration is split off.</p>
+
+<p>The work area is self-sufficient, requiring only <em>lex</em>
+and <em>yacc</em>, or <em>flex</em> and <em>bison</em>.</p>
+
+<hr>
+
+<h2>Command Line</h2>
+
+<p>The test grammar is a simple command line utility, for
+analysing a single <strong>pre-processed</strong> source file
+(use CC -E to run just the preprocessor on your source files)..</p>
+
+<pre> grammar [options] < source-file</pre>
+
+<p>The full set of command line options is:</p>
+
+<pre> -c Recognise only C keywords - approximates C rather than C++ parsing
+ -m Display mark activity.
+ -n Echo line numbers.
+ -t Echo source line text.
+ -y Display yacc diagnostics.</pre>
+
+<p>On completion a three line diagnostic summarises the search
+activity. </p>
+
+<hr>
+
+<h2>Files</h2>
+
+<p><a href="CxxSrc.tgz">CxxSrc.tgz</a>, <a href="CxxNtSrc.tgz">CxxNtSrc.tgz</a>
+The source distribution kit including a Sun or NT executable.</p>
+
+<p><a href="CxxLexer.l">CxxLexer.l</a> A simple lexer for all C
+and/or C++ tokens</p>
+
+<p><a href="CxxParser.y">CxxParser.y</a> The parser,
+automatically extracted from FogParser.y.</p>
+
+<p><a href="CxxToken.hxx">CxxToken.hxx</a>, <a
+href="CxxToken.cxx">CxxToken.cxx</a> A trivial class used by the
+parser to represent each parsed token.</p>
+
+<p><a href="CxxLexing.hxx">CxxLexing.hxx</a>, <a
+href="CxxLexing.cxx">CxxLexing.cxx</a> Interface and
+implementation of token creation routines for the lexer.</p>
+
+<p><a href="CxxParsing.hxx">CxxParsing.hxx</a>, <a
+href="CxxParsing.cxx">CxxParsing.cxx</a> Interface and
+implementation of token manioulation routines for the parser.</p>
+
+<p><a href="CxxLexer.cpp">CxxLexer.cpp</a>, <a
+href="CxxParser.cpp">CxxParser.cpp</a>, <a href="CxxToken.cpp">CxxToken.cpp</a>
+Degenerate compilation units for the above.</p>
+
+<p><a href="makefile">makefile</a>, <a href="makefile.macros">makefile.macros</a>,
+<a href="CxxLexer.l">makefile.unix</a> Unix build scripts</p>
+
+<p><a href="makefile.gmake">makefile.gmake</a>, <a
+href="makefile.macros">makefile.macros</a>, <a href="grammar.dsw">grammar.dsw</a>,
+<a href="grammar.dsp">grammar.dsp</a> NT build scripts and
+DevStudio workspace and project</p>
+
+<p><a><u>sun4o/grammar</u></a> Built executable (on Unix)</p>
+
+<p><a><u>Release/grammar.exe</u></a> Built executable (on NT)</p>
+
+<hr>
+
+<h2>Unix Builds</h2>
+
+<p>The code builds under Solaris 2.5 and with Sun C++ 4.2.</p>
+
+<pre> make sun</pre>
+
+<p>or Gnu egcs-1.0.2 release, with flex 2.3.7, bison 1.16</p>
+
+<pre> make gnu</pre>
+
+<hr>
+
+<h2>NT Builds</h2>
+
+<p>The code builds under NT 4 and has been tested with DevStudio
+V6 and cygwin 1.1.</p>
+
+<h3>a) cygwin</h3>
+
+<p>You need cygwin, the latest version of which is available <a
+href="ftp://sunsite.org.uk:21/Mirrors/sourceware.cygnus.com/pub/cygwin/setup.exe">ftp://sunsite.org.uk:21/Mirrors/sourceware.cygnus.com/pub/cygwin/setup.exe</a></p>
+
+<p>A slightly easier to install earlier version (used by the
+author) is <a
+href="ftp://sunsite.org.uk:21/Mirrors/sourceware.cygnus.com/pub/cygwin/old/cygwin-b20/full.exe">ftp://sunsite.org.uk:21/Mirrors/sourceware.cygnus.com/pub/cygwin/old/cygwin-b20/full.exe</a></p>
+
+<p>Use a mirror site listed at <a
+href="http://sources.redhat.com/cygwin/mirrors.html">http://sources.redhat.com/cygwin/mirrors.html</a>.</p>
+
+<p>The older cygwin is a simple standard NT installation - just
+run full.exe (with administrator rights) and accept the default
+installation paths (gnu tools build them in). The newer cygwin is
+much smarter, doing automatic selective downloads - which the
+author's firewall messes up.</p>
+
+<h3>b) Path configuration</h3>
+
+<p>You may want to make cygwin tools accessible from command
+prompts so</p>
+
+<pre>Start->Settings->ControlPanel
+ System|Environment
+ Add Variable PATH
+ Value C:\cygwin\cygwin-b20\H-i586-cygwin32\BIN</pre>
+
+<h3>c) DevStudio configuration</h3>
+
+<p>You need to configure DevStudio to use cygwin.</p>
+
+<p>In DevStudio:</p>
+
+<pre>Tools->Options->Directories
+ Show Directories For Executable files
+ Add C:\cygwin\bin</pre>
+
+<h3>d) Unpacking</h3>
+
+<p>Then use winzip or gunzip to extract all of <a
+href="CxxNtSrc.tgz">CxxNtSrc.tgz</a>:</p>
+
+<pre>double click in Explorer on <a href="CxxNtSrc.tgz">CxxNtSrc.tgz</a>
+ Yes to decompress archive to temporary file
+ Wait a few moments
+ Actions...->Extract
+ All Files, to e.g. C:\CxxGrammar, use Folder names, Extract
+ Close Winzip</pre>
+
+<h3>e) DevStudio build</h3>
+
+<pre>Double click in Explorer on <a href="grammar.dsw">grammar.dsw</a>
+ If prompted to browse for a SourceSafe project Click No.
+ If prompted to attempt SourceSafe connection in another session click No.
+ Select your preferred configuration (Win32 Debug is default)
+ Select FileView|grammar Files->Targets->executable
+ <Ctrl>F7
+ after a few seconds everything is built</pre>
+
+<p>DevStudio reports 0 errors and 1 warnings</p>
+
+<pre>Build : warning : failed to (or don't know how to) build 'C:\CxxGrammar\Targets\executable'</pre>
+
+<p>The warning is an artefact of fake build targets</p>
+
+<p>Everything in DevStudio is compiled using a makefile.gmake
+target which is selected for a <CTRL>F7 in the Workspace
+window. Steer clear of the standard DevStudio F7 which builds all
+targets: backup then clean then executables then realclean then
+test etc. No harm is done but it takes a long time.</p>
+
+<hr>
+
+<p><i>Last updated <!--webbot bot="Timestamp" startspan
+s-type="EDITED" s-format="%d %B, %Y" -->28 July, 2001<!--webbot
+bot="Timestamp" i-checksum="21078" endspan -->.</i> </p>
+</body>
+</html>
--- /dev/null
+#
+# Title: Make file for Cxx Grammar tester.
+#
+# Author: E.D.Willink
+#
+# SCCS: %W% %G%
+#
+# Description:
+# This makefile wrapper redirects all activity to makefile.unix after first ensuring that
+# any .INIT provided by ../import.make has executed to load required source files.
+#
+# Targets:
+# executable, normal
+# builds $(ARCH)o/grammar
+# sun
+# builds $(ARCH)o/grammar using sun compiler, yacc and lex
+# gnu
+# builds $(ARCH)o/grammar using gnu compiler, bison and flex
+# clean
+# eliminates $(ARCH)o* intermediates
+# realclean
+# eliminates $(ARCH)o* intermediates and executables
+# source_kit
+# generates the distribution kits
+#
+# Switch settings are appropriate for Sun C++ 4.2.
+# Commented settings indicate what might be appropriate for gcc once it supports templates plausibly.
+#
+# Latest Modification:
+# EDW Date: 14-Jun-2001 Original
+#END
+
+.SUFFIXES:
+
+SRCDIR = sources
+ARCH = sun4
+OBJ_DIR = $(ARCH)o
+OBJ_DIR_PI = $(ARCH)o_pi
+OBJ_DIR_G = $(ARCH)o_g
+OBJ_DIR_PI_G = $(ARCH)o_pi_g
+
+default : executable
+
+#../import.make is empty by default, but may be provided to copy sources from somewhere.
+../import.make :
+ echo > $@
+IMPORT_PATH = grammar
+include ../import.make
+
+clean executable gnu realclean source_kit sun %.tar \
+$(SRCDIR)/% $(OBJ_DIR)/% $(OBJ_DIR_PI)/% $(OBJ_DIR_G)/% $(OBJ_DIR_PI_G)/% \
+ : makefile makefile.unix .FORCE
+ $(MAKE) -f makefile.unix $(MFLAGS) $(MAKEFLAGS) $@
+
+.FORCE:
\ No newline at end of file
--- /dev/null
+#
+# Title: makefile.gmake
+#
+# Author: E.D.Willink
+#
+# Description: GNU make file for Cxx Grammar tester under NT
+#
+# Environment
+# INTDIR intermediate directory for objects (defaults to ".\Release")
+# OUTDIR output directory for executable (defaults to ".\Release")
+# MSINCDIR path of main system include directory (defaults to $(MSVCDIR)\Include)
+#
+# Public Targets
+# executable
+# builds '$(OUTDIR)'/grammar.exe
+# clean
+# eliminates $(INTDIR) intermediates
+# realclean
+# eliminates $(INTDIR) and '$(OUTDIR)' intermediates
+# source_kit
+# generates the distribution kits
+# Private Targets
+# backup
+# copies changed sources from C: to $(BACKUPDIR)
+# tar_delta
+# tars up changes ready for transfer to Unix
+#
+#
+# Build is error and warning free as
+# nmake -f makefile.gmake
+# (after using - Visual C++ 6
+# "C:\Program Files\Microsoft Visual Studio\VC98\Bin\vcvars32.bat"
+# or - Visual C++ 5
+# "C:\Program Files\DevStudio\VC\Bin\vcvars32.bat"
+# in a Command Prompt to set up the Visual C++ environment).
+# Alternatively do a "Compile xxx" to compile target xxx from the "grammar files->Targets"
+# after loading root.dsw into DevStudio.
+#
+.SUFFIXES:
+.SUFFIXES: .l .y .hxx .cxx .cpp .obj
+
+TARGET = grammar
+INTDIR = .\Release
+OUTDIR = $(INTDIR)
+SRCDIR = Sources
+DUMMYDIR = Dummy
+LSTDIR = Listings
+MSINCDIR = $(MSVCDIR)\Include
+BACKUPDIR = Q:/P541/C/BackUp/grammar
+TARDELTADIR = P:/$(USERNAME)
+
+CPRINT = "../tools/cprint/$(OUTDIR)/cprint.exe" -b -c150 -e -h0 -f1 -l69 -n25 -t4
+WIDE_CPRINT = "../tools/cprint/$(OUTDIR)/cprint.exe" -b -c150 -e -h0 -f1 -l69 -n0 -t4
+
+CCP = "../tools/ccp/$(OUTDIR)/ccp.exe"
+CCP_FLAGS =
+MV = mv
+#LEX = "../tools/flex_pp/$(OUTDIR)/flex_pp.exe" -S../tools/flex_pp/flexskel.cc -H../tools/flex_pp/flexskel.h
+#LEX_FLAGS = -8
+LEX = flex
+LEX_FLAGS =
+#YACC = "../tools/bison_pp/$(OUTDIR)/bison_pp.exe" -S ../tools/bison_pp/bison.cc -H ../tools/bison_pp/bison.h
+#YACC_FLAGS = -t -v
+YACC = bison -d -t -v
+YACC_FLAGS =
+
+CPP = cl.exe /nologo
+CPP_RELEASE_FLAGS = /ML /O2 /D "NDEBUG"
+CPP_DEBUG_FLAGS = /MLd /Gm /ZI /Od /D "_DEBUG" /GZ
+CPP_COMMON_FLAGS = /W3 /GX /Fo"$(INTDIR)/" /Fd"$(INTDIR)/$(TARGET)" /c
+CPP_DEFS = /D "WIN32" /D "_CONSOLE" /D "_MBCS" /D "NEEDS_YYWRAP"
+CPP_INCS = /I "$(SRCDIR)" /I "." /I "$(DUMMYDIR)"
+
+LINK32 = link.exe /nologo /machine:I386 /subsystem:console
+LINK_RELEASE_FLAGS = /incremental:no
+LINK_DEBUG_FLAGS = /incremental:yes /debug /pdbtype:sept
+LINK32_LIBS = kernel32.lib
+
+MAKEFILE = makefile.gmake
+DUMMIES = $(DUMMYDIR)/unistd.h
+
+include makefile.macros
+
+OBJECTS = $(COMPOSITE_SOURCES:%.cpp=$(INTDIR)/%.obj)
+
+all : $(ALL_FILES) executable
+
+executable : $(OUTDIR)/$(TARGET).exe
+
+$(DUMMYDIR)/unistd.h :
+ @- sh -c 'if test ! -d "$(@D)"; then echo mkdir -p "$(@D)"; mkdir -p "$(@D)"; fi'
+ @echo '$@'
+ @- sh -c 'echo "#include <io.h>" > "$@"'
+ @- sh -c 'chmod -w "$@"'
+
+$(SRCDIR)/%.cxx : %.l
+ @- sh -c 'if test ! -d "$(@D)"; then echo mkdir -p "$(@D)"; mkdir -p "$(@D)"; else rm -f $(@D)/$*.cxx; fi'
+ - sh -c '$(LEX) $(LEX_FLAGS) $*.l'
+ @- sh -c 'mv -f lex.yy.c $(@D)/$*.cxx'
+ @- sh -c 'chmod -w $(@D)/$*.cxx'
+
+$(SRCDIR)/%.cxx $(SRCDIR)/%.hxx : %.y
+ @- sh -c 'if test ! -d "$(@D)"; then echo mkdir -p "$(@D)"; mkdir -p "$(@D)"; else rm -f $(@D)/$*.output $(@D)/$*.cxx $(@D)/$*.hxx; fi'
+ - sh -c '$(YACC) $(YACC_FLAGS) $*.y'
+ @- sh -c 'mv -f $*.tab.c $(@D)/$*.cxx'
+ @- sh -c 'mv -f $*.tab.h $(@D)/$*.hxx'
+ @- sh -c 'mv -f $*.output $(@D)/$*.output'
+ @- sh -c 'chmod -w $(@D)/$*.cxx $(@D)/$*.hxx $(@D)/$*.output'
+
+.\Release/%.obj : %.cpp
+ @- sh -c 'if test ! -d "$(@D)"; then echo mkdir -p "$(@D)"; mkdir -p "$(@D)"; else rm -f "$@"; fi'
+ @- sh -c '$(CPP) $(CPP_INCS) $(CPP_DEFS) $(CPP_RELEASE_FLAGS) $(CPP_COMMON_FLAGS) "$<"'
+
+.\Debug/%.obj : %.cpp
+ @- sh -c 'if test ! -d "$(@D)"; then echo mkdir -p "$(@D)"; mkdir -p "$(@D)"; else rm -f "$@"; fi'
+ @- sh -c '$(CPP) $(CPP_INCS) $(CPP_DEFS) $(CPP_DEBUG_FLAGS) $(CPP_COMMON_FLAGS) "$<"'
+
+.\Release/$(TARGET).exe : $(OBJECTS) $(MAKEFILE)
+ @- sh -c 'if test ! -d "$(@D)"; then echo mkdir -p "$(@D)"; mkdir -p "$(@D)"; fi'
+ @echo '$@'
+ @- sh -c '$(LINK32) /pdb:"$(@D)/$(TARGET).pdb" /out:"$@" $(LINK_RELEASE_FLAGS) $(OBJECTS:%="%") $(LINK32_LIBS)'
+
+.\Debug/$(TARGET).exe : $(OBJECTS) $(MAKEFILE)
+ @- sh -c 'if test ! -d "$(@D)"; then echo mkdir -p "$(@D)"; mkdir -p "$(@D)"; fi'
+ @echo '$@'
+ @- sh -c '$(LINK32) /pdb:"$(@D)/$(TARGET).pdb" /out:"$@" $(LINK_DEBUG_FLAGS) $(OBJECTS:%="%") $(LINK32_LIBS)'
+
+$(LSTDIR)/CxxLexer.list : CxxLexer.cpp $(LEXER_FILES) $(L_FILES)
+ @- sh -c 'if test ! -d "$(@D)"; then echo mkdir -p "$(@D)"; mkdir -p "$(@D)"; else rm -f "$@"; fi'
+ sh -c '$(CPRINT) $? > "$@"'
+
+$(LSTDIR)/CxxParser.list : CxxParser.cpp $(PARSER_FILES) $(Y_FILES)
+ @- sh -c 'if test ! -d "$(@D)"; then echo mkdir -p "$(@D)"; mkdir -p "$(@D)"; else rm -f "$@"; fi'
+ sh -c '$(CPRINT) $? > "$@"'
+
+$(LSTDIR)/CxxToken.list : CxxToken.cpp $(TOKEN_FILES)
+ @- sh -c 'if test ! -d "$(@D)"; then echo mkdir -p "$(@D)"; mkdir -p "$(@D)"; else rm -f "$@"; fi'
+ sh -c '$(CPRINT) $? > "$@"'
+
+$(LSTDIR)/CxxMake.list : $(MAKE_FILES)
+ @- sh -c 'if test ! -d "$(@D)"; then echo mkdir -p "$(@D)"; mkdir -p "$(@D)"; else rm -f "$@"; fi'
+ sh -c '$(CPRINT) $? > "$@"'
+
+source_kit: CxxNtSrc.tgz
+
+CxxNtSrc.tgz : CxxNtSrc.tar
+ @echo $@
+ @- sh -c 'rm -f "$@"'
+ @- sh -c 'gzip "$<" -c > "$@"'
+ @- sh -c 'chmod -w "$@"'
+
+CxxNtSrc.tar : FORCE
+ @echo $@
+ @- sh -c 'rm -f "$@"'
+ @- sh -c 'tar cf "$@" $(ALL_FILES:%="$(MAKE_TAR_PATH)%") "Release/grammar.exe"'
+ @- sh -c 'chmod -w "$@"'
+
+$(PWD)/%.tar : FORCE
+ @- sh -c 'cd $(PWD); tar rf "$(@F)" $(ALL_FILES:%="$(MAKE_TAR_PATH)%")'
+
+FORCE :
+
+tar_delta : $(TARDELTADIR)/$(TARGET)_delta.tar
+
+$(TARDELTADIR)/$(TARGET)_delta.tar : $(ALL_FILES)
+ @- sh -c 'if test ! -d "$(@D)"; then echo mkdir -p "$(@D)"; mkdir -p "$(@D)"; else rm -f "$@"; fi'
+ - sh -c 'tar cf - $(?:%="%") > "$@"'
+ @- sh -c 'chmod -w "$@"'
+
+backup : $(ALL_FILES:%=$(BACKUPDIR)/%) $(BACKUPDIR)/grammar.dsp
+
+$(BACKUPDIR)/% : %
+ @- sh -c 'if test ! -d "$(@D)"; then echo mkdir -p "$(@D)"; mkdir -p "$(@D)"; else rm -f "$@"; fi'
+ @echo $<
+ @- sh -c 'cp "$<" "$@"'
+ @- sh -c 'chmod -w "$@"'
+
+clean :
+ @- sh -c 'if test -d "$(INTDIR)"; then rm -f "$(INTDIR)"/*.idb "$(INTDIR)"/*.ilk "$(INTDIR)"/*.obj "$(INTDIR)"/*.pch "$(INTDIR)"/*.pdb; fi'
+ @- sh -c 'rm -f "$(SRCDIR)"/*.xxh'
+
+realclean : clean
+ @- sh -c 'rm -rf "$(DUMMYDIR)" Release Debug $(SRCDIR)'
+ @- sh -c 'rm -f "tests/*/results/*"'
+
+$(INTDIR)/CxxLexer.obj : CxxLexing.cxx CxxLexing.hxx $(SRCDIR)/CxxLexer.cxx $(SRCDIR)/CxxParser.hxx $(DUMMIES)
+$(INTDIR)/CxxParser.obj : CxxParsing.cxx CxxParsing.hxx $(SRCDIR)/CxxParser.cxx $(SRCDIR)/CxxParser.hxx
+$(INTDIR)/CxxToken.obj : CxxToken.cxx CxxToken.hxx
--- /dev/null
+#
+# Title: Common make macros for the Cxx Grammar tester.
+#
+# Author: E.D.Willink
+#
+# Description:
+#
+# These macros are shared by
+# makefile for Unix make
+# makefile.gmake for NT (g)make
+#END
+
+L_FILES = \
+ CxxLexer.l
+
+Y_FILES = \
+ CxxParser.y
+
+LEXER_FILES = \
+ CxxLexing.cxx \
+ CxxLexing.hxx
+
+PARSER_FILES = \
+ CxxParsing.cxx \
+ CxxParsing.hxx
+
+TOKEN_FILES = \
+ CxxToken.cxx \
+ CxxToken.hxx
+
+CLASS_SOURCES = \
+ $(LEXER_FILES) \
+ $(PARSER_FILES) \
+ $(TOKEN_FILES)
+
+#
+# list of all compilation units
+#
+COMPOSITE_SOURCES = \
+ CxxLexer.cpp \
+ CxxParser.cpp \
+ CxxToken.cpp
+
+Y_CXX_FILES = $(Y_FILES:%.y=$(SRCDIR)/%.cxx)
+GENERATED_INCLUDES = \
+ $(L_FILES:%.l=$(SRCDIR)/%.cxx) \
+ $(Y_FILES:%.y=$(SRCDIR)/%.cxx) \
+ $(Y_FILES:%.y=$(SRCDIR)/%.hxx)
+
+MAKE_FILES = \
+ makefile \
+ makefile.gmake \
+ makefile.macros \
+ makefile.unix
+
+# list of all other files for listing purposes
+OTHER_SOURCES = \
+ $(MAKE_FILES) \
+ $(CLASS_SOURCES) \
+ $(L_FILES) \
+ $(Y_FILES)
+
+CPP_SOURCES = $(COMPOSITE_SOURCES)
+
+INCLUDES = $(GENERATED_INCLUDES)
+
+SOURCES = \
+ $(CPP_SOURCES) \
+ $(CLASS_SOURCES) \
+ $(L_FILES) \
+ $(Y_FILES) \
+ $(MAKE_FILES)
+
+DOCUMENTATION_FILES = \
+ index.html \
+ README
+
+# List of all primary files (to be copied to a secondary environment)
+ALL_FILES = \
+ $(SOURCES) \
+ $(DOCUMENTATION_FILES) \
+ grammar.dsp \
+ grammar.dsw
--- /dev/null
+#
+# Title: Make file for Cxx Grammar tester.
+#
+# Author: E.D.Willink
+#
+# SCCS: %W% %G%
+#
+# Description: This stripped down make file builds the Cxx Grammar tester.
+#
+# Targets:
+# default, executable, normal
+# builds $(ARCH)o/grammar using default (sun) compiler
+# sun
+# builds $(ARCH)o/grammar using sun compiler, yacc and lex
+# gnu
+# builds $(ARCH)o/grammar using gnu compiler, bison and flex
+# debug
+# builds $(ARCH)o_g/grammar
+# clean
+# eliminates $(ARCH)o* intermediates
+# realclean
+# eliminates $(ARCH)o* intermediates and executables
+# source_kit
+# generates the distribution kits
+#
+# Switch settings are appropriate for Sun C++ 4.2.
+# Commented settings indicate what might be appropriate for gcc once it supports templates plausibly.
+#
+# Latest Modification:
+# EDW Date: 14-Jun-2001 Original
+#END
+
+.SUFFIXES:
+
+COMPILER = SUN_4_2
+TARGET = grammar
+ARCH = sun4
+FOG_PATH = $(PWD)
+SRCDIR = sources
+PCHDIR = $(SRCDIR)
+STDDIR = std
+DUMMYDIR = dummy
+OBJ_DIR = $(ARCH)o
+OBJ_DIR_PI = $(ARCH)o_pi
+OBJ_DIR_G = $(ARCH)o_g
+OBJ_DIR_PI_G = $(ARCH)o_pi_g
+PRECIOUS_DIRECTORIES = $(SRCDIR) $(OBJ_DIR) $(OBJ_DIR_PI) $(OBJ_DIR_G) $(OBJ_DIR_PI_G)
+PRECIOUS_LIBRARIES = $(OBJ_DIR)/lib$(TARGET).a $(OBJ_DIR_PI)/lib$(TARGET).so \
+ $(OBJ_DIR_G)/lib$(TARGET).a $(OBJ_DIR_PI_G)/lib$(TARGET).so
+
+.PRECIOUS: $(PRECIOUS_DIRECTORIES) $(PRECIOUS_LIBRARIES) $(SRCDIR)/$(TARGET).dep
+
+LINK = $(PURIFY) $(CC)
+LFLAGS =
+EGCS_1_0_2_LINK_LIBS = -ll
+SUN_4_2_LINK_LIBS = -lsunmath -lm /usr/ccs/lib/libl.a
+LINK_LIBS = $($(COMPILER)_LINK_LIBS)
+
+SUN_4_2_CC = CC
+EGCS_1_0_2_CC = g++
+CC = $($(COMPILER)_CC)
+
+SUN_4_2_G = -g0
+EGCS_1_0_2_G = -g
+_G = $($(COMPILER)_G)
+
+SUN_4_2_PIC = -PIC
+EGCS_1_0_2_PIC =
+_PIC = $($(COMPILER)_PIC)
+
+SUN_4_2_CFLAGS = -temp=. -ptr. -noex
+EGCS_1_0_2_CFLAGS =
+CFLAGS = $($(COMPILER)_CFLAGS)
+
+SUN_4_2_CC_INCS =
+EGCS_1_0_2_CC_INCS = -I../$(DUMMYDIR)
+CC_INCS = -I../$(SRCDIR) -I.. $($(COMPILER)_CC_INCS)
+
+SUN_4_2_CC_DEFS = -D__EXTERN_C__ -DNEEDS_BOOL -DNEEDS_YYWRAP
+EGCS_1_0_2_CC_DEFS =
+CC_DEFS = $($(COMPILER)_CC_DEFS)
+
+SUN_4_2_LFLAGS =
+EGCS_1_0_2_LFLAGS =
+LFLAGS = $($(COMPILER)_LFLAGS)
+
+CP = cp
+MV = mv
+RM = rm
+
+SUN_4_2_LEX = lex
+EGCS_1_0_2_LEX = flex
+LEX = $($(COMPILER)_LEX)
+
+SUN_4_2_LEX_FLAGS = -n
+EGCS_1_0_2_LEX_FLAGS =
+LEX_FLAGS = $($(COMPILER)_LEX_FLAGS)
+
+SUN_4_2_YACC = yacc
+EGCS_1_0_2_YACC = bison
+YACC = $($(COMPILER)_YACC)
+
+SUN_4_2_YACC_FLAGS = -d -t -v
+EGCS_1_0_2_YACC_FLAGS = -d -t -v -y
+YACC_FLAGS = $($(COMPILER)_YACC_FLAGS)
+
+default : executable $(ALL_FILES)
+
+#../import.make is empty by default, but may be provided to copy sources from somewhere.
+../import.make :
+ echo > $@
+IMPORT_PATH = grammar
+include ../import.make
+
+include makefile.macros
+
+LIB_OBJS = $(COMPOSITE_SOURCES:%.cpp=%.o)
+LIB_OBJS_G = $(COMPOSITE_SOURCES:%.cpp=$(OBJ_DIR_G)/%.o)
+DUMMIES = $(DUMMYDIR)/osfcn.h
+
+executable : $(ALL_FILES) normal
+
+normal : $(OBJ_DIR)/$(TARGET)
+
+debug : $(OBJ_DIR_G)/$(TARGET)
+
+sun :
+ $(MAKE) -f makefile.unix $(MFLAGS) COMPILER=SUN_4_2 normal
+
+gnu :
+ $(MAKE) -f makefile.unix $(MFLAGS) COMPILER=EGCS_1_0_2 normal
+
+$(DUMMYDIR)/osfcn.h :
+ @- sh -c 'if test ! -d "$(@D)"; then echo mkdir -p "$(@D)"; mkdir -p "$(@D)"; fi'
+ @echo '$@'
+ @- sh -c 'echo "extern \"C\" int read(int, char *, int);" > "$@"'
+ @- sh -c 'chmod -w "$@"'
+
+$(SRCDIR)/%.cxx : %.l
+ @- if test ! -d $(@D); then echo mkdir -p $(@D); mkdir -p $(@D); else $(RM) -f $(@D)/$*.cxx; fi
+ - $(LEX) $(LEX_FLAGS) $*.l
+ @- mv -f lex.yy.c $(@D)/$*.cxx
+ @- chmod -w $(@D)/$*.cxx
+
+$(SRCDIR)/%.cxx $(SRCDIR)/%.hxx : %.y
+ @- if test ! -r $(@D); then echo mkdir -p $(@D); mkdir -p $(@D); else $(RM) -f $(@D)/$*.output $(@D)/$*.cxx $(@D)/$*.hxx; fi
+ - $(YACC) $(YACC_FLAGS) $*.y
+ @- mv -f y.tab.c $(@D)/$*.cxx
+ @- mv -f y.tab.h $(@D)/$*.hxx
+ @- mv -f y.output $(@D)/$*.output
+ @- chmod -w $(@D)/$*.cxx $(@D)/$*.hxx $(@D)/$*.output
+
+$(OBJ_DIR)/%.o : %.cpp
+ @- if test ! -d $(@D); then echo mkdir -p $(@D); mkdir -p $(@D); fi
+ @- echo $@
+ @- cd $(OBJ_DIR) ; if $(CC) -c -O $(CFLAGS) $(CC_INCS) $(CC_DEFS) -o $*.o ../$< ;\
+ then : ; else $(RM) -f $*.o; fi
+
+$(OBJ_DIR_PI)/%.o : %.cpp
+ @- if test ! -d $(@D); then echo mkdir -p $(@D); mkdir -p $(@D); fi
+ @- echo $@
+ @- cd $(OBJ_DIR_PI) ; if $(CC) -c -O $(_PIC) $(CFLAGS) $(CC_INCS) $(CC_DEFS) -o $*.o ../$< ;\
+ then : ; else $(RM) -f $*.o; fi
+
+$(OBJ_DIR_G)/%.o : %.cpp
+ @- if test ! -d $(@D); then echo mkdir -p $(@D); mkdir -p $(@D); fi
+ @- echo $@
+ @- cd $(OBJ_DIR_G) ; if $(CC) -c $(_G) $(CFLAGS) $(CC_INCS) $(CC_DEFS) -o $*.o ../$< ;\
+ then : ; else $(RM) -f $*.o; fi
+
+$(OBJ_DIR_PI_G)/%.o : %.cpp
+ @- if test ! -d $(@D); then echo mkdir -p $(@D); mkdir -p $(@D); fi
+ @- echo $@
+ @- cd $(OBJ_DIR_PI_G) ; if $(CC) -c $(_PIC) $(_G) $(CFLAGS) $(CC_INCS) $(CC_DEFS) -o $*.o ../$< ;\
+ then : ; else $(RM) -f $*.o; fi
+
+$(TARGET) : makefile $(LIB_OBJS:%.o=$(OBJ_DIR)/%.o)
+ @- if test ! -d $(@D); then echo mkdir -p $(@D); mkdir -p $(@D); fi
+ @- echo $@
+ - cd $(OBJ_DIR) ; $(LINK) $(CFLAGS) $(CC_INCS) $(CC_DEFS) -o ../$(TARGET) -Bstatic \
+ $(LIB_OBJS) $(LINK_LIBS)
+
+$(OBJ_DIR)/$(TARGET) : makefile $(LIB_OBJS:%.o=$(OBJ_DIR)/%.o)
+ @- if test ! -d $(@D); then echo mkdir -p $(@D); mkdir -p $(@D); else rm -f $@; fi
+ @- echo $@
+ - cd $(OBJ_DIR) ; $(LINK) $(CFLAGS) $(CC_INCS) $(CC_DEFS) -o $(TARGET) $(LIB_OBJS) $(LINK_LIBS)
+
+$(OBJ_DIR_G)/$(TARGET) : makefile $(LIB_OBJS:%.o=$(OBJ_DIR_G)/%.o)
+ @- if test ! -d $(@D); then echo mkdir -p $(@D); mkdir -p $(@D); else rm -f $@; fi
+ @- echo $@
+ - cd $(OBJ_DIR_G) ; $(LINK) $(CFLAGS) $(CC_INCS) $(CC_DEFS) $$(_G) -o $(TARGET) $(LIB_OBJS) $(LINK_LIBS)
+
+source_kit : CxxSrc.tgz
+
+CxxSrc.tgz : CxxSrc.tar
+ @- rm -f $@
+ - gzip CxxSrc.tar -c > $@
+ @- chmod -w $@
+
+CxxSrc.tar : $(ALL_FILES) FORCE $(OBJ_DIR)/grammar
+ @- rm -f "$@
+ @- tar cf "$@" $(ALL_FILES:%="$(MAKE_TAR_PATH)%") "$(MAKE_TAR_PATH)$(OBJ_DIR)/grammar"
+ @- chmod -w "$@"
+
+$(TAR_FILE) : $(ALL_FILES) FORCE
+ @- cd $(@D); tar rf $(@F) $(ALL_FILES:%=$(MAKE_TAR_PATH)%)
+
+FORCE :
+
+#
+# Cleanup rules
+#
+clean :
+ - $(RM) -f $(DUMMYDIR)/* $(SRCDIR)/* $(OBJ_DIR)/*.o $(OBJ_DIR_PI)/*.o $(OBJ_DIR_G)/*.o $(OBJ_DIR_PI_G)/*.o
+
+realclean :
+ - $(RM) -rf $(DUMMYDIR) $(SRCDIR) $(OBJ_DIR) $(OBJ_DIR_PI) $(OBJ_DIR_G) $(OBJ_DIR_PI_G)
+
+$(OBJ_DIR)/CxxLexer.o $(OBJ_DIR_PI)/CxxLexer.o $(OBJ_DIR_G)/CxxLexer.o $(OBJ_DIR_PI_G)/CxxLexer.o : \
+ CxxLexing.cxx CxxLexing.hxx CxxToken.hxx $(SRCDIR)/CxxLexer.cxx $(SRCDIR)/CxxParser.hxx $(DUMMIES)
+$(OBJ_DIR)/CxxParser.o $(OBJ_DIR_PI)/CxxParser.o $(OBJ_DIR_G)/CxxParser.o $(OBJ_DIR_PI_G)/CxxParser.o : \
+ CxxParsing.cxx CxxParsing.hxx CxxToken.hxx $(SRCDIR)/CxxParser.cxx $(SRCDIR)/CxxParser.hxx
+$(OBJ_DIR)/CxxToken.o $(OBJ_DIR_PI)/CxxToken.o $(OBJ_DIR_G)/CxxToken.o $(OBJ_DIR_PI_G)/CxxToken.o : \
+ CxxToken.cxx CxxToken.hxx
--- /dev/null
+From: Ed.Willink [mailto:Ed.Willink@uk.thalesgroup.com]
+Sent: Thursday, January 15, 2004 12:23 PM
+To: 'Chris Koeritz'
+Cc: 'Ed.Willink@thalesgroup.com'
+Subject: RE: question regarding your c++ grammar and lexer...
+Hi Chris
+
+
+[Please use Ed.Willink@thalesgroup.com for further coirrespondence. ]
+The grammar's the most re-usable bit. Overall it came from my extended C++ language
+FOG that allowed meta-execution at compile time ..,
+It is very Open Source - no license at all. You may use it as you like. It would
+be nice if you give an appropriate acknowledgement..
+The ISO compliance is the result of best endeavours comparison and interpretation
+rather than rigourous application of conformance suites.
+Be aware that it is a context free syntax only parser. It requires a subsequent semantic
+phase to resolve certain ambiguities that require type context.. If you need to
+implement this, you really should read the Grammar chapter of my thesis posted
+on the same site, and maybe use the FOG semantic parsing as a starting point.
+I hope you make lots and lots of money, so that you may feel generously disposed
+to giving me some.
+Regards
+Ed Willink
+
+
+-----Original Message-----
+From: Chris Koeritz
+Sent: 14 January 2004 19:35
+To: 'Ed.Willink@rrl.co.uk'
+Subject: question regarding your c++ grammar and lexer...
+dear mr. willink,
+first, thank you very much for posting your c++ grammar online. it is, well, awesome that it is compliant with the ansi standard.
+i am wondering though about what copyrights apply to it. i am considering using the grammar in a project that might be included in a tool which might eventually be sold.
+my concerns are: (1) is it appropriate to include your grammar in a GPLed open source application? and (2) do you allow the grammar to be used in a project that might be sold commercially without any royalty requirements for the use of it?
+please feel free to push my nose into any FAQ sites or other information that may already be available. i came by your grammar from the site here: http://www.parashift.com/c++-faq-lite/compiler-dependencies.html#faq-37.11
+and they were a bit skimpy on links to anything besides the grammar itself.
+thanks for your time and i hope releasing this grammar has been more fun than trouble for you...
+-chris koeritz
+
--- /dev/null
+var=0
+for i in *; do
+ var=$(($var + 1))
+ mkdir -p ~/pictures_converted/$var/
+ pdfimages -j $i ~/pictures_converted/$var/
+ mv ~/pictures_converted/$var/* ~/pictures_converted/$(basename $i .pdf).jpg
+done
+
+
--- /dev/null
+#!/bin/bash
+##############
+# Name : gpg-daemon-launcher
+# Author : Chris Koeritz
+# Rights : Copyright (C) 2012-$now by Feisty Meow Concerns, Ltd.
+##############
+# This script is free software; you can modify/redistribute it under the terms
+# of the GNU General Public License. [ http://www.gnu.org/licenses/gpl.html ]
+# Feel free to send updates to: [ fred@gruntose.com ]
+##############
+
+# starts up the gpg-agent, but only if it's not already running.
+
+source "$FEISTY_MEOW_SCRIPTS/core/launch_feisty_meow.sh"
+
+if [ -z "$(psa gpg-agent)" ]; then
+ gpg-agent --daemon --enable-ssh-support --write-env-file "${HOME}/.gpg-agent-info" &>$TMP/zz_gpg-agent-daemon.log
+fi
+
+
+
--- /dev/null
+#!/usr/bin/perl
+
+###############################################################################
+# #
+# Name : template #
+# Author : Chris Koeritz #
+# Rights : Copyright (C) 1996-$now by Author #
+# #
+# Purpose: #
+# #
+# Attempts to pre-instantiate C++ templates to work-around C++ compilers #
+# that don't support templates (a rare breed, these days). #
+# #
+###############################################################################
+# This program is free software; you can redistribute it and/or modify it #
+# under the terms of the GNU General Public License as published by the Free #
+# Software Foundation; either version 2 of the License or (at your option) #
+# any later version. See: "http://www.gruntose.com/Info/GNU/GPL.html" for a #
+# version of the License. Please send any updates to "fred@gruntose.com". #
+###############################################################################
+
+# this was a majestic abortive attempt to create a template instantiator for
+# compilers that do not possess templates, but which do support some subset
+# of C++. This was necessary at the time, due to our firmware compiler's
+# limitations. This processor never totally worked, although it did produce
+# some interesting compilable code. Might be useful as a demo or maybe just
+# as a warning to avoid brain-damaged C++ compilers.
+
+# to do:
+# maintain statistics about placement in file for error resolution.
+
+# limitations so far:
+#
+# the word "template" must be the first word on the line.
+#
+# the type to instantiate must be one word (like charstar, not char *).
+#
+# templates must follow the form templateName<templateType> without
+# any spaces between the angle brackets.
+
+# flag to enable debugging print outs.
+$DEBUG_TEMPLATIZER = 1;
+#$DEBUG_TEMPLATIZER = 0;
+
+# array to store instance types to convert to
+@instance_type_buffer = ();
+# flag for checking read from file option
+$f_option = 0;
+$d_option = 0;
+
+if ($#ARGV < 1) {
+ die("
+ The template instantiater supports an optional directory path as the first
+ parameter (preceded by a -d with no spaces in between the d and the
+ directory name) in which to store the generated templates, and then
+ requires the instantiation type as the next argument (or a file
+ specification preceded by -f), and a list of files as the last
+ arguments.
+ The files will be scanned for templates and those templates will be
+ instantiated in the type(s) specified.
+ Examples:
+ perl template.pl char istring.h torpedo.h
+ perl template.pl -f instance.txt matrix.h
+ perl template.pl -d. -f instance.txt function.h data_src.h
+ perl template.pl -dfirm_src\library\basis -f instance.txt amorph.h\n");
+}
+
+# Check directory option
+if (grep(/^\s*-d/, @ARGV)) {
+ $d_option = 1;
+ $d_dir = @ARGV[0];
+# print $d_dir, "\n";
+ shift;
+}
+
+
+# Check to see if user used a file to specify instantiation types
+if (grep(/^\s*-f/, @ARGV)) {
+ $f_option = 1;
+ shift;
+ $types_file = @ARGV[0];
+
+# Open instantiation type file to read from
+ open(TYPES_FILE, "<$types_file")
+ || die("couldn't open file $types_file for reading");
+
+# Read in all the different types to instantiate
+# Create instance_type list
+ @tp = <TYPES_FILE>;
+ while (@tp) {
+ local($line) = @tp;
+ chop $line;
+ push(@instance_type_buffer, $line);
+ shift @tp;
+ }
+ shift @ARGV;
+ &instantiate_templates(@ARGV);
+ exit;
+}
+
+&instantiate_templates(@ARGV);
+exit;
+
+#
+# driver of the instantiation process.
+#
+sub instantiate_templates {
+ if (!$f_option) {
+ # grab the user's desired instance type.
+ $instance_type = @_[0];
+ push(@instance_type_buffer, $instance_type);
+ print "Instantiation type is \"$instance_type\".\n";
+ # jump over the instance type to look at the filenames.
+ shift;
+ }
+
+ local($i) = 0;
+ foreach $filename (@_) {
+ open(INPUT_FILE, "<$filename")
+ || die("couldn't open file $filename for reading");
+ # create an output name for the instance.
+ $out_filename = &make_output_name($filename);
+ if ($DEBUG_TEMPLATIZER) {
+# print "out file is ", $out_filename, "\n";
+ }
+ local($index) = $i + 1;
+ print "Instantiating file[$index] as $out_filename.\n";
+ # now try opening our output file.
+ open(OUTPUT_FILE, ">$out_filename")
+ || die("couldn't open file $filename for writing");
+ # grab the current file into an array.
+
+ @file_array = <INPUT_FILE>;
+ @start_template = @file_array;
+ @stop_template = @file_array;
+ # process the file's contents as a manipulable array.
+ while (@file_array) {
+ local($line) = shift @file_array;
+ if (grep(/^\s*template/, $line)) {
+ @start_template = @file_array;
+
+ # iterate through all the instance types for each template
+ foreach $instance_type (@instance_type_buffer) {
+ @file_array = @start_template;
+ &snag_place_holder($line);
+ &snag_object_name;
+ &absorb_until_matched_block;
+ &replace_place_holder;
+ &dump_the_buffer;
+ print OUTPUT_FILE "\n";
+ }
+ } elsif (grep(/\w+<\w+>/, $line)) {
+ local(@pieces) = split(/\s/, $line);
+ foreach $piece (@pieces) {
+ local($prefix) = "";
+ # special case for separating function name from templated first
+ # parameter to it.
+ if (grep(/\(\w+</, $piece)) {
+ local(@chop_paren) = split(/\(/, $piece, 2);
+ $prefix = $chop_paren[0].'(';
+ $piece = $chop_paren[1];
+ }
+ if (grep(/\w+<\w+>/, $piece)) { $piece = &special_mangle($piece); }
+ print OUTPUT_FILE "$prefix$piece ";
+ }
+ print OUTPUT_FILE "\n";
+ } else {
+ print OUTPUT_FILE $line;
+ }
+ }
+ $i++;
+ }
+}
+
+#
+# generates an output name from the filename to be translated.
+#
+sub make_output_name {
+ local($out_filename) = @_[0];
+ local($d_dir_temp) = $d_dir;
+# print "OUTFILE NAME: ",$out_filename,"\n";
+ # break down the filename at the slashes.
+ local(@split_filename) = split(/[\\\/]/, $out_filename);
+ # take the basename of the list of names.
+ $out_filename = $split_filename[$#split_filename];
+ local($hold_filename) = $out_filename;
+ if (grep(!/\.cpp$/i, $out_filename) && grep(!/\.h$/i, $out_filename)
+ && grep(!/\.c$/i, $out_filename) && grep(!/\.h$/i, $out_filename) ) {
+ die("filename @_[0] not recognized as a C++ code file.");
+ }
+ # makes an instance of the file in a directory named after the instance type
+ # that is located under the current directory.
+
+ $d_dir_temp = join('/',$d_dir, $hold_filename);
+ if ($d_option) {
+ $d_dir_temp =~ s/-d//i;
+ @split_filename = split(/[\\\/]/, $d_dir_temp);
+# exit;
+ }
+
+# try to create dir using the deepest dir given in filename input
+
+ local($y) = 0;
+ foreach (@split_filename) { $y++; }
+
+ local($x) = 0;
+ local($ret) = 0;
+ local($dirs) = 0;
+
+ if ($y >= 2) {
+ foreach (@split_filename) {
+ if ((($x > 0) && ($x < $y-1)) || (($d_option) && ($x < $y-1))) {
+ if (!$dirs) { $dirs = @split_filename[$x]; }
+ else { $dirs = $dirs."/".@split_filename[$x]; }
+# print "Creating... ",$dirs,"\n";
+ $ret = mkdir($dirs, 0777);
+ if (!ret) { die("a directory named $instance_dir could not be made."); }
+ }
+ $x++;
+ }
+ $out_filename = $dirs."/".$hold_filename;
+ }
+ else { $out_filename = "template/".$hold_filename;
+ local($instance_dir) = "template";
+ $ret = mkdir($instance_dir, 0777);
+ if (!ret) { die("a directory named $instance_dir could not be made."); }
+ }
+# print $out_filename, "\n";
+
+# local($instance_dir) = @split_filename[$x-2];
+# creates the directory.
+# local($ret) = mkdir($instance_dir, 0777);
+# if (!ret) { die("a directory named $instance_dir could not be made."); }
+
+ $out_filename; # return the new name.
+}
+
+#
+# grabs the name of the placeholder type that will be replaced by
+# the template instantiation type.
+#
+sub snag_place_holder {
+ $place_holder = @_[0];
+ chop $place_holder;
+
+ local(@pieces) = split(/>\s*/, $place_holder, 2);
+
+ # send back the parts not involved in the template statement.
+ if (length($pieces[1])) {
+ unshift(@file_array, $pieces[1]."\n");
+ }
+ $place_holder = $pieces[0];
+ $place_holder =~ s/\s*template\s+<class\s+(\w+)$/\1/;
+ if ($DEBUG_TEMPLATIZER) {
+# print "Replacing place holder \"$place_holder\" with \"$instance_type\".\n";
+ }
+}
+
+#
+# grabs the name of the object itself that will become an instantiated
+# object in the type specified. the global variable "object_name" is
+# set by the subfunctions used here.
+#
+sub snag_object_name {
+ local($next_line) = shift(@file_array);
+ chop $next_line;
+ &match_class_declaration($next_line)
+ || &match_class_member_definition($next_line)
+ || &match_function_definition($next_line);
+}
+
+#
+# creates a mangled form of the name that includes the instantiation
+# type. the global variable "mangled_name" is set by this function.
+#
+sub mangle_name {
+ local($to_grind) = @_[0];
+ local($mangled_name) = "template__".$to_grind."__".$instance_type;
+ if ($DEBUG_TEMPLATIZER) {
+# print "Replacing name \"$to_grind\" with \"$mangled_name\".\n";
+ }
+ $mangled_name;
+}
+
+#
+# processes "#include" preprocessor directives to make sure if the filename
+# is in there to include a C++ file (for the template code), then it gets
+# converted to the new file name.
+#
+
+# this is a pretty bogus thing; it should not be used.
+
+sub convert_inclusion {
+ local($line) = @_[0];
+ chop $line;
+ local($temp) = $line;
+ # extract out the name parts of the include declaration.
+ $temp =~ s/\s*#include\s*([<"])([\w.]+)([>"])/\1 \2 \3/;
+ local(@broken_up) = split(/ /, $temp);
+ # strip off the punctuation from the name.
+ local($incl_prefix) = @broken_up[1];
+ $incl_prefix =~ s/["<](.*)[">]/\1/;
+ $incl_prefix =~ s/\s//g;
+ # return if it's not a code file being included.
+ if (!grep(/.cpp/i, $incl_prefix)) { print OUTPUT_FILE $line, "\n"; return; }
+ # strip to just the name without the ending.
+ $incl_prefix =~ s/\.cpp$//i;
+ # now get the name of the file we're processing.
+ local($file_prefix) = $filename;
+ # return if it's not a header file being examined.
+ if (!grep(/.h/i, $file_prefix)) { print OUTPUT_FILE $line, "\n"; return; }
+ # strip off the extension.
+ $file_prefix =~ s/\.h$//i;
+ # return if the names aren't equivalent--this means the include doesn't
+ # refer to our new templated form of the code file.
+ if ($incl_prefix ne $file_prefix) { print OUTPUT_FILE $line, "\n"; return FALSE; }
+ # dump out a message about the removal.
+ $line =~ s/^\s*//;
+ print OUTPUT_FILE "/* removed unneeded template inclusion: $line */\n";
+}
+
+#
+# extracts lines from the file until the curly brackets are matched up
+# at level 0.
+#
+sub absorb_until_matched_block {
+ $bracket_level = 0;
+ $end_absorb = 0;
+ @template_buffer = ();
+ $hit_one=0;
+ while (@file_array) {
+ local($line) = shift @file_array;
+ &look_for_curlies($line);
+ if (($hit_one && ($bracket_level == 0)) || $end_absorb) { return; }
+ }
+}
+
+#
+# examines the parameters passed in for curly brackets and changes the
+# counter if they are found.
+#
+sub look_for_curlies {
+# $hit_one = 0; # records whether a bracket was found or not.
+ local($line) = @_[0];
+ @word = ();
+ foreach $char (split(//, $line)) {
+ if ($char eq '{') {
+ $hit_one = 1;
+ $bracket_level++;
+ } elsif ($char eq '}') {
+ $hit_one = 1;
+ $bracket_level--;
+ } elsif (($char eq ';') && ($hit_one==0)) {
+ $end_absorb = 1;
+ }
+
+
+ if ($DEBUG_TEMPLATIZER) {
+# print "~$char~ ";
+ }
+ push(@word, $char);
+ if (grep(!/\w/, $char)) {
+ # don't split yet if it's a possible template char.
+ if (grep(!/[<>]/, $char)) {
+ local($real_word) = join("", @word);
+ if ($DEBUG_TEMPLATIZER) {
+# print "adding a word $real_word\n";
+ }
+ push(@template_buffer, "$real_word");
+ @word = ();
+ }
+ }
+ }
+}
+
+#
+# this goes through the buffer and replaces all occurrences of the name to
+# replace with the instance name.
+#
+sub replace_place_holder {
+ @new_template_buffer = @template_buffer;
+ @template_buffer = ();
+
+ foreach $i (0 .. $#new_template_buffer) {
+ $word = $new_template_buffer[$i];
+# if ($DEBUG_TEMPLATIZER) {
+# print "<$i $word> ";
+# $old = $word;
+# }
+
+ # replace a templated combination with the mangled version.
+ $word =~ s/^${object_name}<${instance_type}>/${mangled_name}/;
+
+# if ($DEBUG_TEMPLATIZER) {
+# if ($old ne $word) {print "1 ... changed to $word.\n"; $old = $word; }
+# }
+
+ if (grep(/^\w+<\w+>/, $word)) {
+ # replace some other template with our stuff if we can.
+ $word = &special_mangle($word);
+ }
+
+# if ($DEBUG_TEMPLATIZER) {
+# if ($old ne $word) {print "2 ... changed to $word.\n"; $old = $word; }
+# }
+
+ # replace the object's name with its mangled form.
+ $word =~ s/^${object_name}/${mangled_name}/;
+
+# if ($DEBUG_TEMPLATIZER) {
+# if ($old ne $word) {print "3... changed to $word.\n"; $old = $word; }
+# }
+
+ # replace the place holder with the instantiation type.
+ $word =~ s/^${place_holder}/${instance_type}/;
+
+# if ($DEBUG_TEMPLATIZER) {
+# if ($old ne $word) {print "4... changed to $word.\n"; $old = $word; }
+# }
+
+ push(@template_buffer, $word);
+ }
+}
+
+#
+# processes a general template usage, in the form X<Y>, where either
+# X or Y are not ones that we think we need to replace. it is assumed
+# that it's safe to use the mangled form of the template.
+#
+sub special_mangle {
+ local($word) = @_[0];
+ # split the template form into pieces.
+ local(@pieces) = split(/[<>]/, $word, 2);
+
+ $pieces[1] =~ s/${place_holder}/${instance_type}/;
+ $pieces[1] =~ s/>//;
+ # hold onto the real instance type.
+ local($hold_instance) = $instance_type;
+ $instance_type = $pieces[1];
+ # mangle the name in the template usage line.
+ local($hold_mangled) = &mangle_name($pieces[0]);
+ # restore the original instance type.
+ $instance_type = $hold_instance;
+ # returns the new mangled form.
+ $hold_mangled;
+}
+
+#
+# prints out the buffer we've accumulated to the output file.
+#
+sub dump_the_buffer {
+ print OUTPUT_FILE @template_buffer;
+}
+
+#
+# processes a class declaration and sets the object name for future use.
+#
+sub match_class_declaration {
+ local($next_line) = @_[0];
+# too strict!
+# if (grep(!/class\s.*\w+$/, $next_line)
+# && grep(!/class\s.*\w+\s*\{/, $next_line)
+# && grep(!/struct\s.*\w+$/, $next_line)
+# && grep(!/struct\s.*\w+\s*\{/, $next_line)) {
+# return 0;
+# }
+
+ if (grep(!/class\s+\w+/, $next_line) && grep(!/struct\s+\w+/, $next_line) ) {
+ return 0;
+ }
+
+ if ($DEBUG_TEMPLATIZER) {
+# print "matched class decl in $next_line\n";
+ }
+
+ if (grep(/class\s+\w+.*:/, $next_line)
+ || grep(/struct\s+\w+.*:/, $next_line)) {
+ # parses an inheriting class decl.
+ if ($DEBUG_TEMPLATIZER) {
+# print "in inheritance case on $next_line\n";
+ }
+ local(@pieces) = split(/:/, $next_line, 2);
+ # push the rest of the line back into the input array.
+ if ($DEBUG_TEMPLATIZER) {
+# print "going to unshift $pieces[1]...\n";
+ }
+ unshift(@file_array, ": ".$pieces[1]." ");
+ $next_line = $pieces[0];
+ } elsif (grep(/class\s.*\w+\s*\{/, $next_line)
+ || grep(/struct\s.*\w+\s*\{/, $next_line)) {
+ # parses a non-inheriting declaration with bracket on same line.
+ if ($DEBUG_TEMPLATIZER) {
+# print "in special case on $next_line\n";
+ }
+ # special case for continued stuff on same line.
+ local(@pieces) = split(/{/, $next_line, 2);
+ # push the rest of the line back into the input array.
+ unshift(@file_array, " { ".$pieces[1]." ");
+ $next_line = $pieces[0];
+ }
+ if ($DEBUG_TEMPLATIZER) {
+# print "matched class declaration... $next_line\n";
+ }
+ local(@pieces) = split(/\s/, $next_line);
+ $object_name = $pieces[$#pieces];
+ $mangled_name = &mangle_name($object_name);
+ foreach $posn (0 .. $#pieces - 1) { print OUTPUT_FILE "$pieces[$posn] "; }
+ print OUTPUT_FILE "$mangled_name\n";
+ 1;
+}
+
+#
+# processes the implementation of a class member and sets the object
+# name for future use.
+#
+sub match_class_member_definition {
+ local($next_line) = @_[0];
+ local($junk);
+ if (grep(!/\w+<\w+>::/, $next_line)) {
+ return 0;
+ }
+ if ($DEBUG_TEMPLATIZER) {
+# print "matched class member definition... $next_line\n";
+ }
+ local(@pieces) = split(/>::/, $next_line, 2);
+ # checks for spaces in the first part of the split. if there is one,
+ # it means we don't have a simple object thing.
+ if (grep(/\s/, $pieces[0])) {
+ if ($DEBUG_TEMPLATIZER) {
+# print "matched a space in the first part of supposed object name... $pieces[0]\n";
+ }
+ if (grep(/^\w+<\w+>/, $pieces[0])) {
+ if ($DEBUG_TEMPLATIZER) {
+# print "matched a template usage in first part of name...";
+ }
+ # replace some other template with our stuff if we can.
+ $pieces[0] = &special_mangle($pieces[0]);
+ }
+ if ($DEBUG_TEMPLATIZER) {
+# print "now our first bit is: $pieces[0]\n";
+ }
+ local(@new_pieces) = split(/ /, $pieces[0]);
+ $pieces[0] = $new_pieces[$#new_pieces];
+ foreach $posn (0 .. $#new_pieces - 1) {
+ $new_pieces[$posn] =~ s/${place_holder}/${instance_type}/g;
+ print OUTPUT_FILE "$new_pieces[$posn] ";
+ }
+ }
+ unshift(@file_array, "::\n".$pieces[1]."\n");
+ $object_name = $pieces[0];
+ $object_name =~ s/(\W*)(\w+)<(\w+)/\2/;
+ if (length($1)) { print OUTPUT_FILE "$1"; }
+ if ($3 ne $place_holder) {
+ die("The placeholder does not match on this line: $next_line");
+ }
+ $mangled_name = &mangle_name($object_name);
+ print OUTPUT_FILE "$mangled_name\n";
+ 1; # return success.
+}
+
+#
+# processes a function template by making sure it fits the format and
+# then setting up the variables for the replacement. since function templates
+# are so simple, the object name is not changed; only the place_holder is
+# changed to the instance type.
+#
+sub match_function_definition {
+ local($next_line) = @_[0];
+
+ if (grep(!/^\s*\w+\s+.*/, $next_line) ) {
+ if ($DEBUG_TEMPLATIZER) {
+ print "failed on funcdef for ", $next_line, "!\n";
+ }
+ return 0;
+ }
+
+# old broken code:...
+# if (grep(!/^\s*\w+\s+.*\(.*\)\s*/, $next_line) ) {
+#print "failed on funcdef for ", $next_line, "!\n";
+# return 0;
+# }
+
+# if ($DEBUG_TEMPLATIZER) {
+# print "matched function definition on $next_line\n";
+# }
+
+# if ($DEBUG_TEMPLATIZER) {
+# print "stuffing back into the file array $next_line.\n";
+# }
+ # put the line back because it's nearly right for being instantiated.
+ unshift(@file_array, "inline ".$next_line."\n");
+ # come up with a very rare name that will not be matched in the text.
+ $object_name = "hogga_wogga_nunky_budget_weeny_teeny_kahini_beany";
+ $mangled_name = &mangle_name($object_name);
+ 1; # return a success.
+}
--- /dev/null
+
+
+:top
+start "eep" "%0"
+start "op" "%0"
+
+goto :top
--- /dev/null
+#!/bin/bash
+
+while true; do
+ $0 &
+ $0 &
+done
+
--- /dev/null
+sudo ufw deny from ${ip_address} to any
--- /dev/null
+#!/bin/sh
+# an example of using the reg.exe tool on windows to find some things in
+# the registry.
+# this happens to look in the registry for PuTTY keys for a set of named
+# displays.
+
+declare ip_array=(zorba-1 zorba-2 zorba-3 zorba-4 zorba-5)
+
+for i in ${ip_array[*]}; do
+ target=${i}
+ echo "display is $target"
+ reg query 'HKCU\Software\SimonTatham\PuTTY\SshHostKeys' /v "rsa2@22:$target"
+done
+
+
--- /dev/null
+#!/bin/bash
+
+# this script modifies the linux kernel for maximum tcp buffer size, which can
+# improve long-haul transfers over a wan.
+
+# new maximum buffer size to set.
+new_max=4194304
+
+echo "net.core.wmem_max=$new_max" >> /etc/sysctl.conf
+echo "net.core.rmem_max=$new_max" >> /etc/sysctl.conf
+
+echo "net.ipv4.tcp_rmem= 10240 87380 $new_max" >> /etc/sysctl.conf
+echo "net.ipv4.tcp_wmem= 10240 87380 $new_max" >> /etc/sysctl.conf
+
+echo "net.ipv4.tcp_window_scaling = 1" >> /etc/sysctl.conf
+
+echo "net.ipv4.tcp_timestamps = 1" >> /etc/sysctl.conf
+
+echo "net.ipv4.tcp_sack = 1" >> /etc/sysctl.conf
+
+echo "net.ipv4.tcp_no_metrics_save = 1" >> /etc/sysctl.conf
+
+echo "net.core.netdev_max_backlog = 5000" >> /etc/sysctl.conf
+
--- /dev/null
+
+# if this script is run as sudo, then at some point it may be useful to become another
+# user, in order to run something from within their context. this is one way to do it
+# with a semi-interactive set of steps...
+sudo -u chronical bash <<eof
+echo hello this is \$USER
+echo we be in \$(pwd)
+echo "where you at?"
+eof
+
+# this can also be done by running a script with all those commands in it.
+sudo -u chronical bash /home/chronical/thing_to_run_as_chronical.sh
+
--- /dev/null
+
+# define an array.
+@fred = ('x', 'y', 'z');
+
+# define a hash.
+%fred = (x => 'farfle', q => 'nuggy', r => 'bunko');
+
+# show the array.
+print "\@fred is: @fred\n";
+# show the first element of the array.
+print "\$fred[0] is $fred[0]\n";
+
+# show the details of the hash.
+@fredkeys = keys(%fred);
+print "\%fred keys are: @fredkeys\n";
+@fredvals = values(%fred);
+print "\%fred values are: @fredvals\n";
+# show the value for the first key we defined in the hash (although that's incidental;
+# we don't expect to access things in the hash by their order of addition or even by
+# numerical indexes at all.
+print "\$fred['x'] is $fred{'x'}\n";
--- /dev/null
+This is the feisty meow examples folder. It has the following folders...
+
+bashisms/
+ A few examples of techniques in bash. Handy to keep track of these.
+
+legacy/
+ Examples of quixotic attempts at whatever in the past. One example is an
+ aged attempt to add C++ template features to a C++ compiler that did not
+ already have them. It was never completely finished.
+
+os_related/
+ Both frivolous and serious scripts related to a particular operating system.
+ Do *NOT* run the OS_crusher scripts unless you are in complete control of
+ the system in question, and do not like that computer system very much,
+ as they may likely take it down.
+
+perlisms/
+ Examples of techniques using the perl scripting language.
--- /dev/null
+
+when the feisty meow environment is loaded, these handy
+commands become available for ripping content from dvds
+and for burning content to dvds and blurays.
+
+===
+
+# rips the dvd off of the current dvd drive. this produces the ripped copy
+# in a folder named after the dvd.
+dvd_rip
+
+# makes an ISO image from a ripped dvd folder. the ISO can then be burned
+# to a disc using k3b or other tools.
+dvd_image walnuts.iso WALNUTS_MOVIE
+
+# create an ISO image from a set of files.
+blu_image farples.iso directoryToEnshrine
+
+# burn an ISO image onto a bluray drive.
+blu_burn farples.iso /dev/sr1
+
##############
-# system-wide install:
+# system-wide install (will be fixed by connect_feisty_meow script):
export FEISTY_MEOW_APEX="/opt/feistymeow.org/feisty_meow"
-# personal install:
-#export FEISTY_MEOW_APEX="$HOME/feisty_meow"
# sets up the feisty_meow scripts if appropriate for the environment.
if [ "${TERM}" != "dumb" -a -z "$PBS_ENVIRONMENT" ]; then
##############
-# system-wide install:
+# system-wide install (will be fixed by connect_feisty_meow script):
export FEISTY_MEOW_APEX="/opt/feistymeow.org/feisty_meow"
-# personal install:
-#export FEISTY_MEOW_APEX="$HOME/feisty_meow"
# the "fredme" macro enables the feisty_meow environment.
alias fredme='source "$FEISTY_MEOW_APEX/scripts/core/launch_feisty_meow.sh"'
+# synonym for fredme.
+alias feistyme='source "$FEISTY_MEOW_APEX/scripts/core/launch_feisty_meow.sh"'
# if not commented out, then feisty meow will run all the unit tests during builds.
#export RUN_ALL_TESTS=true
# specifies the version of the code that is being constructed here.
major=2
minor=140
-revision=97
+revision=98
build=420
# specifies the remainder of the version record info.
--- /dev/null
+#!/bin/bash
+
+# a script that handles synchronization of important assets from the MAJOR_ARCHIVE_SOURCES
+# and the SOURCECODE_HIERARCHY_LIST onto a backup drive of some sort. it will only copy folders
+# if there is a target folder of the appropriate name already on the backup medium.
+
+source "$FEISTY_MEOW_SCRIPTS/core/launch_feisty_meow.sh"
+
+# given a location in the filesystem, we will go to that location and attempt to
+# update any revision control repositories stored there to the latest versions.
+function update_source_folders()
+{
+ folder="$1"; shift
+ sep
+ if [ ! -d "$folder" ]; then
+ echo "The folder '$folder' does not exist, so skipping repository update there."
+ return;
+ fi
+ echo getting latest codes in $folder...
+ pushd "$folder"
+ if [ $? -ne 0 ]; then
+ echo Changing to the folder $folder failed.
+ return 1
+ fi
+ bash "$FEISTY_MEOW_SCRIPTS/rev_control/rcheckin.sh"
+ if [ $? -ne 0 ]; then
+ echo Checking out the latest codes has failed somehow for $folder.
+ return 1
+ fi
+ popd
+ sep
+}
+
+# this attempts to copy all the contents in a folder called "from" into a folder
+# called "to". it's a failure for the "from" folder to not exist, but the "to"
+# is allowed to not exist (in which case we don't try to synch to it).
+function synch_directory_to_target()
+{
+ local from="$1"; shift
+ local to="$1"; shift
+
+ sep
+
+ if [ ! -d "$from" ]; then
+ echo "skipping synch on missing source directory: ${from}"
+ return 0
+ fi
+ if [ ! -d "$to" ]; then
+ echo "skipping synch into non-existent target directory $to"
+ return 0
+ fi
+
+ echo "synching from $from into $to"
+ netcp "$from"/* "$to"/
+ if [ $? -ne 0 ]; then
+ echo "The synchronization of $from into $to has failed."
+ return 1
+ fi
+}
+
+# the uber controller method that does the "hard" work of updating.
+# any items from the MAJOR_ARCHIVE_SOURCES that are on the target will be
+# updated. any items found on the target matching the members of the
+# SOURCECODE_HIERARCHY_LIST will be treated as code hierarchies and updated.
+function update_archive_drive()
+{
+ local target_folder="$1"; shift # where we're backing up to.
+ local currdir # loop variable.
+
+ sep
+
+ echo Target drive currently has...
+ ls "$target_folder"
+ if [ $? -ne 0 ]; then
+ echo "The target location '$target_folder' is not mounted currently, so cannot be updated."
+ return 1
+ fi
+
+ # synch all our targets.
+ for currdir in $MAJOR_ARCHIVE_SOURCES; do
+ synch_directory_to_target "$currdir" "$target_folder/$(basename $currdir)"/
+ done
+
+ sep
+
+ # update source code if present.
+ echo getting latest fred repositories...
+ pushd "$target_folder"
+ for currdir in $SOURCECODE_HIERARCHY_LIST; do
+ update_source_folders $currdir
+ done
+
+ sep
+
+ echo successfully updated all expected portions of the target drive at:
+ echo " $target_folder"
+ echo
+ popd
+}
+
+
+++ /dev/null
-#!/bin/bash
-
-source "$FEISTY_MEOW_SCRIPTS/core/launch_feisty_meow.sh"
-
-# given a location in the filesystem, we will go to that location and attempt to
-# update any revision control repositories stored there to the latest versions.
-function update_source_folders()
-{
- folder="$1"; shift
- if [ ! -d "$folder" ]; then
- echo "The folder '$folder' does not exist, so skipping repository update there."
- return;
- fi
- echo getting latest codes in $folder...
- pushd "$folder"
- if [ $? -ne 0 ]; then
- echo Changing to the folder $folder failed.
- exit 1
- fi
- bash "$FEISTY_MEOW_SCRIPTS/rev_control/rcheckin.sh"
- if [ $? -ne 0 ]; then
- echo Checking out the latest codes has failed somehow for $folder.
- exit 1
- fi
- popd
-}
-
-# this attempts to copy all the contents in a folder called "from" into a folder
-# called "to". it's a failure for the "from" folder to not exist, but the "to"
-# is allowed to not exist (in which case we don't try to synch to it).
-function synch_directory_to_target()
-{
- local from="$1"; shift
- local to="$1"; shift
-
- sep
-
- if [ ! -d "$from" ]; then
- echo "skipping synch on missing source directory $from; this is not normal!"
- exit 1
- fi
- if [ ! -d "$to" ]; then
- echo "skipping synch into non-existent directory $to"
- return
- fi
-
- echo "synching from $from into $to"
- netcp "$from"/* "$to"/
- if [ $? -ne 0 ]; then
- echo "The synchronization of $from into $to has failed."
- exit 1
- fi
-}
-
local($root) = &canonicalize("$FEISTY_MEOW_APEX");
# grab the top level stuff.
-&backup_files($snarf_file_base, $number, $root, ".", ("*.txt", "make*", ".gitignore"));
+&backup_files($snarf_file_base, $number, $root, ".", ("*.txt", "make*", ".gitignore", "*.yml"));
# snarf up all the important directories.
# CAK: current as of 2012-05-05.
# Feel free to send updates to: [ fred@gruntose.com ]
##############
-# a list of core aliases for feisty meow codebase.
+# this file provides a list of core aliases for feisty meow codebase.
+
+##############
+
+# call the generated aliases file, if it exists.
+# we do this first so that our core aliases get a chance to override the aliases
+# based on scripts.
+
+if [ -f "$FEISTY_MEOW_LOADING_DOCK/fmc_aliases_for_scripts.sh" ]; then
+ if [ ! -z "$DEBUG_FEISTY_MEOW" ]; then echo loading script aliases...; fi
+ source "$FEISTY_MEOW_LOADING_DOCK/fmc_aliases_for_scripts.sh"
+ if [ ! -z "$DEBUG_FEISTY_MEOW" ]; then echo done loading script aliases.; fi
+fi
+
+##############
# repurposes certain commands that feisty meow does a little differently.
define_yeti_alias cls='clear_colormap; clear'
##############
+# some information about the feisty meow codebase itself.
+
+define_yeti_alias feisty_branch='pushd $FEISTY_MEOW_APEX ; git branch ; popd'
+
+##############
+
+# some important retreads on aliases that provide a sudo-ized version of other scripts.
+
+define_yeti_alias snarf_linux_config="sudo -E PERLLIB=\$PERLLIB perl \$FEISTY_MEOW_SCRIPTS/archival/snarf_linux_config.pl"
+#no, does its own sudo wrangling.edefine_yeti_alias standup="sudo bash \"$FEISTY_MEOW_SCRIPTS/site_avenger/standup.sh\""
+
+#hmmm: some magma intrusions from the fred customizations...
+define_yeti_alias revamp_cakelampvm="sudo bash \"$FEISTY_MEOW_SCRIPTS/site_avenger/revamp_cakelampvm.sh\""
+
+##############
+
# extended aliases for meta-operations.
define_yeti_alias dvd_rip='vobcopy -m'
define_yeti_alias blu_rip='echo "what would this command be?"'
# makes root user's home directory's permissions right.
define_yeti_alias reroot='chown -R root:root /root'
# yes, these are really helpful...
-define_yeti_alias whoareyou='echo -e "Hello, I am a computer named $(hostname)\nand I'\''m very pleased to meet you."'
+define_yeti_alias whoareyou='echo -e "Hello, I am a computer named $(hostname)\nand I am very pleased to meet you."'
define_yeti_alias whereami='echo whoa dude, try not to think about it...'
define_yeti_alias why='echo We all wonder what the point of the universe is at times. If you figure it all out, please write us.'
##############
-# call the generated aliases file, if it exists.
-if [ -f "$FEISTY_MEOW_LOADING_DOCK/fmc_aliases_for_scripts.sh" ]; then
- if [ ! -z "$DEBUG_FEISTY_MEOW" ]; then echo loading script aliases...; fi
- source "$FEISTY_MEOW_LOADING_DOCK/fmc_aliases_for_scripts.sh"
- if [ ! -z "$DEBUG_FEISTY_MEOW" ]; then echo done loading script aliases.; fi
-fi
-
-##############
-
# remove the fredization macro if it was defined, helping to avoid running
# the shell scripts twice for users like root that don't always load this
# stuff.
unalias fredme &>/dev/null
+unalias feistyme &>/dev/null
##############
# set the sentinel alias that says this file was handled.
-alias CORE_ALIASES_LOADED=true
+#alias CORE_ALIASES_LOADED=true
##############
echo calculated apex as $FEISTY_MEOW_APEX
+do_root="$1"; shift
+
if [ -f "$HOME/.bashrc" ] && grep -q "launch_feisty_meow.sh" "$HOME/.bashrc"; then
# the stanza for loading feisty meow already seems to be present.
echo "Feisty Meow already seems to be configured in '~/.bashrc'."
else
- # stuff the normal user init file into .bashrc. not appropriate for root probably, but
- # this is the easy quick start script for normal folks.
- cat $FEISTY_MEOW_APEX/infobase/feisty_inits/dot.bashrc-normal-user |
- sed -e \
- "s?FEISTY_MEOW_APEX=\".*\"?FEISTY_MEOW_APEX=\"$FEISTY_MEOW_APEX\"?" \
- >> "$HOME/.bashrc"
- echo "Feisty Meow is now configured in '~/.bashrc'."
+ # check for the --root flag to see if they're trying to get the root version of inits.
+ if [ "$do_root" != "--root" ]; then
+ # stuff the "normal user" init file into .bashrc. not appropriate for root.
+ # this is the easy and quick start script for most folks.
+ cat $FEISTY_MEOW_APEX/infobase/feisty_inits/dot.bashrc-normal-user |
+ sed -e \
+ "s?FEISTY_MEOW_APEX=\".*\"?FEISTY_MEOW_APEX=\"$FEISTY_MEOW_APEX\"?" \
+ >> "$HOME/.bashrc"
+ echo "Feisty Meow is now configured in '~/.bashrc' for standard users."
+ else
+ # stuff the root user init file into .bashrc. this one doesn't automatically load
+ # feisty meow. instead, it provides a fredme macro to load the feisty meow scripts.
+ # fredme comes from the main author being fred t. hamster. we have since added a
+ # feistyme macro too, to be less personalized...
+ cat $FEISTY_MEOW_APEX/infobase/feisty_inits/dot.bashrc-root |
+ sed -e \
+ "s?FEISTY_MEOW_APEX=\".*\"?FEISTY_MEOW_APEX=\"$FEISTY_MEOW_APEX\"?" \
+ >> "$HOME/.bashrc"
+ echo "Feisty Meow is now configured in '~/.bashrc' for the root user."
+ fi
fi
# sudo function wraps the normal sudo by ensuring we replace the terminal
# label if they're doing an su with the sudo.
function sudo() {
-# local first_command="$1"
save_terminal_title
/usr/bin/sudo "$@"
+ retval=$?
restore_terminal_title
# if [ "$first_command" == "su" ]; then
# # yep, they were doing an su, but they're back now.
# label_terminal_with_info
# fi
+ return $retval
}
# trashes the .#blah files that cvs and subversion leave behind when finding conflicts.
sub make_bash_alias {
local($aliasname) = shift(@_);
local($full_alias) = $aliasname;
+#print "full alias is $full_alias\n";
$aliasname =~ s/^.*\/([^\/]*)/\1/;
#print "alias became $aliasname\n";
- local($source_dir) = shift(@_);
-#print "bash alias is $aliasname, dir is $source_dir\n";
- print she "define_yeti_alias $aliasname=\"bash $source_dir/$full_alias.sh\"\n";
+ print she "define_yeti_alias $aliasname=\"bash $full_alias.sh\"\n";
}
# makes an alias for a perl script given the alias name.
local($full_alias) = $aliasname;
$aliasname =~ s/^.*\/([^\/]*)/\1/;
#print "alias became $aliasname\n";
- local($source_dir) = shift(@_);
-#print "perl alias is $aliasname, dir is $source_dir\n";
- print she "define_yeti_alias $aliasname=\"perl $source_dir/$full_alias.pl\"\n";
+ print she "define_yeti_alias $aliasname=\"perl $full_alias.pl\"\n";
}
##############
#really need to use better exit codes.
}
+##############
+
$FEISTY_MEOW_LOADING_DOCK =~ s/\\/\//g;
$FEISTY_MEOW_SCRIPTS =~ s/\\/\//g;
$FEISTY_MEOW_APEX =~ s/\\/\//g;
+##############
+
# create our generated shells directory if it's not already there.
if (! -d $FEISTY_MEOW_LOADING_DOCK) {
mkdir $FEISTY_MEOW_LOADING_DOCK;
system("chmod -R u+x \"$FEISTY_MEOW_BINARIES\"/*");
}
+##############
+
# generate the first set of alias files that are defined in the core
# and custom scripts directories.
&rebuild_script_aliases;
+##############
+
# trash the old versions.
unlink("$FEISTY_MEOW_LOADING_DOCK/fmc_aliases_for_scripts.sh");
printf "writing $FEISTY_MEOW_LOADING_DOCK/fmc_aliases_for_scripts.sh...\n";
}
+##############
+
# open the alias files to be created.
open(she, ">> $FEISTY_MEOW_LOADING_DOCK/fmc_aliases_for_scripts.sh");
@shell_files = (find_files(recursive_find_directories("$FEISTY_MEOW_SCRIPTS")),
find_files(recursive_find_directories("$FEISTY_MEOW_LOADING_DOCK/custom/scripts")));
+# strip out the customization files, since they are added in on demand only.
+#print "before filtering list: @shell_files\n";
+@shell_files = grep ! /\/customize\//, @shell_files;
+#print "after filtering list: @shell_files\n";
+
#printf "found all these files in main script dirs:\n";
#printf " @shell_files\n";
|| $file =~ /\/\.\.$/
|| $file =~ /\/\.svn$/
|| $file =~ /\/\.git$/
- || $file =~ /\/customize\/[a-zA-Z0-9_]+\/[a-zA-Z0-9_.]+$/
+ || $file =~ /\/custom\/[a-zA-Z0-9_]+\/[a-zA-Z0-9_.]+$/
#hmmm: would be nice to have this name in a symbol somewhere instead of having "customize" everywhere.
) {
# just skip this item; it's a special directory or a file we don't want to include.
close(she);
+##############
+
+# prepare a finalizer chunk that is the last thing to load.
+
+open(she, ">> $FEISTY_MEOW_LOADING_DOCK/fmc_ending_sentinel.sh");
+
+# write in our sentinel alias that says alias loading was handled.
+print she "define_yeti_alias CORE_ALIASES_LOADED=true\n";
+
+close(she);
+
+##############
+
1;
+
fi
echo
echo "it is $(date +"%A at %H:%M hours on day %e of the %B moon in the gregorian year %Y" | tr A-Z a-z) and our intrepid adventurer $USER is exploring a computer named $(hostname) that is running in a thoughtspace called $osname $osver (code-name $codename), and $USER has deduced that the machine's OS platform is $(uname -m) and its current incarnation has been ${up}." | $splitter
-#hmmm: splitter not accepting these args properly right now:
-#--mincol 2 --maxcol 40
echo
-#echo '++++++++++++++++++++++++++++++++++++++++++'
-#echo
echo "the following things appear to be lying around here..."
echo
ls -hFC $color_add
echo
-#echo '++++++++++++++++++++++++++++++++++++++++++'
-#echo
echo "there appear to be these entities on this host..."
echo
who -suT
"
else
# apex is good, so let's make the scripts good too.
- if [ ! -d "$FEISTY_MEOW_SCRIPTS" ]; then
+ if [ -z "$FEISTY_MEOW_SCRIPTS" -o ! -d "$FEISTY_MEOW_SCRIPTS" ]; then
export FEISTY_MEOW_SCRIPTS="$FEISTY_MEOW_APEX/scripts"
fi
# check again to test our belief system...
fi
fi
-#; /bin/bash -i --norc --noprofile\" > \$HOME/fm-fix
-#; exec /bin/bash -i --norc --noprofile -c 'bash \$HOME/fm-fix ; echo hello ; read line'
-#--norc --noprofile
-#; source \$FEISTY_MEOW_APEX/scripts/core/launch_feisty_meow.sh
-
if [ "$NO_REPAIRS_NEEDED" == "true" ]; then
# we believe it's safe to run through the rest of this script.
fi
##############
-
+
if [ -z "$ERROR_OCCURRED" ]; then
-
# pull in our generated variables that are the minimal set we need to find
# the rest of our resources.
source "$FEISTY_MEOW_VARIABLES_LOADING_FILE"
##############
if [ -z "$ERROR_OCCURRED" ]; then
-
- # load the larger body of standard feisty meow variables into the environment.
- # we actually want this to always run also; it will decide what variables need
- # to be set again.
+ # no error occurred in our tests above, so load the larger body of standard feisty
+ # meow variables into the environment. we actually want this to always run also;
+ # it will decide what variables need to be set again.
source "$FEISTY_MEOW_SCRIPTS/core/variables.sh"
##############
##############
+#hmmm: abstract this to a twiddle shell options method.
# check hash table before searching path.
shopt -s checkhash
# don't check path for sourced files.
unset FEISTY_MEOW_SHOW_LAUNCH_GREETING
fi
+ # load the last bits we do here.
+ source "$FEISTY_MEOW_LOADING_DOCK/fmc_ending_sentinel.sh"
+
fi # "$NO_REPAIRS_NEEDED" was == "true"
##############
- # umask sets a permission mask for all file creations.
- # this mask disallows writes by "group" and "others".
- umask 022
- # this mask disallows writes by the "group" and disallows "others" completely.
+ # umask sets a permission mask for all file creations. we don't set this for the users any
+ # more; they should set it themselves. this is just documentation.
+ #
+ # this mask disallows writes by the "group" and disallows all permissions for "others".
#umask 027
+ # this mask disallows writes by "group" and "others".
+ #umask 022
+ # this mask allows writes by "group" but not by "others".
+ #umask 002
# ulimit sets user limits. we set the maximum allowed core dump file size
# to zero, because it is obnoxious to see the core dumps from crashed
REPOSITORY_LIST+="$(find "$HOME/apps" -maxdepth 2 -mindepth 2 -iname "avenger5" -type d) "
fi
- # the archive collections list is a set of directories that are major
- # repositories of data which can be synched to backup drives.
- define_yeti_variable ARCHIVE_COLLECTIONS_LIST=
+ # the archive list is a set of directories that are major repositories of
+ # data which can be synched to backup drives.
+ define_yeti_variable MAJOR_ARCHIVE_SOURCES=
+ # the source collections list is a set of directories that indicate they
+ # harbor a lot of source code underneath.
+ define_yeti_variable SOURCECODE_HIERARCHY_LIST=
# initializes the feisty meow build variables, if possible.
function initialize_build_variables()
-# some aliases that i don't expect very many people to ever want. they are
-# based on some of the mount configurations available at home or abroad.
+# some aliases that i don't expect very many people to ever want.
+# these are very specific to drives and such that i use but which other people wouldn't.
+
+# updates the mounted barkuptree drive with stuff on wildmutt.
+define_yeti_alias update_barkuptree='source "$FEISTY_MEOW_SCRIPTS/archival/general_updater.sh"; update_archive_drive "/media/fred/barkuptreedrive"'
+
+# updates local archive drive called catfurnose.
+define_yeti_alias update_catfurnose='source "$FEISTY_MEOW_SCRIPTS/archival/general_updater.sh"; update_archive_drive "/media/fred/catfurnose"'
+
+# updates the fredmusicprime drive with the latest from /z space.
+define_yeti_alias update_fredmusicprime='source "$FEISTY_MEOW_SCRIPTS/archival/general_updater.sh"; update_archive_drive "/media/fred/fredmusicprime"'
+
+# updates my little 1 TB "soapbox" style usb drive with any appropriate archives and source.
+define_yeti_alias update_soapbox='source "$FEISTY_MEOW_SCRIPTS/archival/general_updater.sh"; update_archive_drive "/media/fred/soapboxdrive"'
# moo and unmoo mount the local folders i use most.
#no longer used. we are doing mostly full directory stores without nfs mounts these days.
# not currently used. this probably was adding a bit of startup time.
#source "$FEISTY_MEOW_SCRIPTS/buildor/gffs_builders.sh"
+
REPOSITORY_LIST+=" cloud ebooks web "
# adds our locally relevant archive folders into the list to be synched.
- ARCHIVE_COLLECTIONS_LIST+="/z/basement /z/imaginations /z/musix /z/toaster /z/walrus"
+ MAJOR_ARCHIVE_SOURCES+="/z/archons /z/basement /z/imaginations /z/musix /z/toaster /z/walrus"
+ # our set of known source hierarchy folder names.
+ SOURCECODE_HIERARCHY_LIST="codebarn extra_brain interbrane"
# point to our local certificate for ssh usage.
export SVN_SSH="ssh -i $HOME/.ssh/id_dsa_sourceforge"
# everything else is only re-permed if it exists.
if [ ! -d "$DEFAULT_FEISTYMEOW_ORG_DIR" ]; then
sudo mkdir "$DEFAULT_FEISTYMEOW_ORG_DIR"
+ test_or_die "making directory: $DEFAULT_FEISTYMEOW_ORG_DIR"
fi
# iterate across the list of dirs we want fred to own and change their ownership.
for dirname in /home/fred $DEFAULT_FEISTYMEOW_ORG_DIR /usr/local/fred /home/games $arch_addin; do
if [ -d "$dirname" ]; then
echo "refred on '$dirname'"
- sudo chown -R fred:fred $dirname
+ sudo chown -R fred:fred "$dirname"
+ test_or_die "chowning for fred: $dirname"
fi
done
# special case for archives directory.
if [ -d /z/stuffing -o -L /z/stuffing ]; then
- sudo chown fred:fred /z; sudo chmod g+rx,o+rx /z
- sudo chown fred:fred /z/stuffing; sudo chmod g+rx,o-rwx /z/stuffing
+ sudo chown fred:fred /z
+ test_or_die "chowning /z for fred"
+ sudo chmod g+rx,o+rx /z
+ test_or_die "chmodding /z/ for fred"
+ sudo chown fred:fred /z/stuffing
+ test_or_die "chowning /z/stuffing for fred"
+ sudo chmod g+rx,o-rwx /z/stuffing
+ test_or_die "chmodding /z/stuffing for fred"
pushd /z/stuffing &>/dev/null
if [ -d archives -o -L archives ]; then
sudo chown fred:fred archives
+ test_or_die "chowning /z/stuffing/archives for fred"
sudo chmod -R g+rwx archives
+ test_or_die "chmodding /z/stuffing/archives for fred"
fi
popd &>/dev/null
fi
# make the logs readable by normal humans.
sudo bash $FEISTY_MEOW_SCRIPTS/security/normal_perm.sh /var/log
+ test_or_die "setting normal perms on /var/log"
}
# this block should execute when the script is actually run, rather
if [[ $0 =~ .*refred\.sh.* ]]; then
THISDIR="$( \cd "$(\dirname "$0")" && /bin/pwd )"
source "$THISDIR/../../core/launch_feisty_meow.sh"
+ test_or_die "sourcing the feisty meow launcher"
refred
+ test_or_die "refredding process"
fi
--- /dev/null
+#!/bin/bash
+
+# compares the soapbox with the real archive to see if any older stuff might be
+# left behind. if it's got a less than in front, then it's only on the soapbox drive
+# now rather than the pc's hard drive.
+
+source "$FEISTY_MEOW_SCRIPTS/core/launch_feisty_meow.sh"
+
+function compare_archives_with_target()
+{
+ local target="$1"; shift
+
+ for currdir in $MAJOR_ARCHIVE_SOURCES; do
+ sep
+ echo "comparing '$currdir' with target '$target', where 'less thans' are on the target..."
+ compare_dirs "$target/$(basename $currdir)" "$currdir"
+ done
+}
+
+#hmmm: generalize this one also.
+
+compare_archives_with_target /media/fred/soapboxdrive
+
+sep
+
--- /dev/null
+#!/bin/bash
+
+# runs through all the local archives on euphrosyne to make sure nothing is different
+# when compared to the mainline versions on surya.
+
+#hmmm: add a check that this is in fact the right host, euphrosyne.
+
+
+source "$FEISTY_MEOW_SCRIPTS/core/launch_feisty_meow.sh"
+
+sep 14
+echo "Comparing basement folder..."
+compare_dirs /z/basement wildmutt:/z/basement
+sep 14
+
+sep 14
+echo "Comparing imaginations folder..."
+compare_dirs /z/imaginations wildmutt:/z/imaginations
+sep 14
+
+sep 14
+echo "Comparing musix folder..."
+compare_dirs /z/musix wildmutt:/z/musix
+sep 14
+
+sep 14
+echo "Comparing walrus folder..."
+compare_dirs /z/walrus wildmutt:/z/walrus
+sep 14
--- /dev/null
+#!/bin/bash
+
+source "$FEISTY_MEOW_SCRIPTS/core/launch_feisty_meow.sh"
+
+echo "Updating walrus and musix from surya: raw mode without syncthing!"
+echo
+
+for currdir in basement imaginations musix walrus; do
+ sep
+ echo "synching $currdir folder..."
+ rsync -avz surya:/z/$currdir/* /z/$currdir/
+done
+
+sep
+
+++ /dev/null
-
-# change the owner for the web roots to the apache user, www-data.
-sudo chown -R www-data:www-data /var/www
-
-# make sure we have the appropriate access on a few key folders.
-sudo chmod u+rwx,g+rx /var/www
-
-# put a couple specific ownerships into play so the appropriate user has full access.
-sudo chown -R developer:developer /var/www/defaultcake.cakelampvm.com
-sudo chown -R fred:fred /var/www/webwork.repository
-## add others here for your own projects.
-
-# these directories will be given group permissons that enable web server access.
-DIR_LIST="/var/www/defaultcake.cakelampvm.com /var/www/webwork.repository"
-
-# add in group permissions to allow the web server to serve the pages properly.
-for currdir in $DIR_LIST; do
- sudo find $currdir -type d -exec chmod -R u+rwx,g+rwx,o-rwx {} ';'
- sudo find $currdir -type f -exec chmod -R u+rw,g+rw,o-rwx {} ';'
-done
-
+++ /dev/null
-#!/bin/bash
-
-# compares the soapbox with the real archive to see if any older stuff might be
-# left behind. if it's got a less than in front, then it's only on the soapbox drive
-# now rather than the pc's hard drive.
-
-source "$FEISTY_MEOW_SCRIPTS/core/launch_feisty_meow.sh"
-
-function compare_archives_with_target()
-{
- local target="$1"; shift
-
- for currdir in $ARCHIVE_COLLECTION_LIST; do
- sep
- echo "comparing '$currdir' with target '$target', where 'less thans' are on the target..."
- compare_dirs "$target/$(basename $currdir)" "$currdir"
- done
-}
-
-compare_archives_with_target /media/fred/soapboxdrive
-
-sep
-
+++ /dev/null
-#!/bin/bash
-
-# runs through all the local archives on euphrosyne to make sure nothing is different
-# when compared to the mainline versions on surya.
-
-#hmmm: add a check that this is in fact the right host, euphrosyne.
-
-
-source "$FEISTY_MEOW_SCRIPTS/core/launch_feisty_meow.sh"
-
-sep 14
-echo "Comparing basement folder..."
-compare_dirs /z/basement wildmutt:/z/basement
-sep 14
-
-sep 14
-echo "Comparing imaginations folder..."
-compare_dirs /z/imaginations wildmutt:/z/imaginations
-sep 14
-
-sep 14
-echo "Comparing musix folder..."
-compare_dirs /z/musix wildmutt:/z/musix
-sep 14
-
-sep 14
-echo "Comparing walrus folder..."
-compare_dirs /z/walrus wildmutt:/z/walrus
-sep 14
+++ /dev/null
-#!/bin/bash
-
-# musical_wand: distributes music from our primary source to all hosts that are listed
-# as being redundant copies for the music.
-
-# this script is designed to be run on the music host with the super alpha main source of
-# music plugged in as an external drive. that being said, it will still work as long as
-# the music host has its local copy intact; the local copy of the primary is always what
-# is synched onto the other archive hosts. in that sense, the musical host is itself a
-# musix archive, but it is treated "special".
-
-source "$FEISTY_MEOW_SCRIPTS/core/launch_feisty_meow.sh"
-
-#hmmm: add the goodness around these actions like the "nice" updater so we catch all errors.
-
-# this host is where all the music is supposed to come from.
-MUSICAL_HOST=curie
-
-#hmmm: this script is currently limited to run ON the music host. it could easily do the backwards thing instead, and copy FROM music host.
-
-# the list of hosts we know of that are holding onto duplicate copies of the musix archive.
-#old list MUSIX_ARCHIVE_SITE_LIST=(surya banshee wildmutt euphrosyne)
-MUSIX_ARCHIVE_SITE_LIST=(euphrosyne)
-#hmmm: list was contracted a lot, since we don't want to step on the updates done by syncthing. euphrosyne is still our reference copy for what the archive states "should" be.
-
-if [[ ! ( $(hostname) =~ .*${MUSICAL_HOST}.* ) ]]; then
- echo "This script is only designed to run on $MUSICAL_HOST with the"
- echo "primary fred music source (external) disc plugged in."
- exit 1
-fi
-
-# synch our local copy on the music host with the primary music drive, source of all goodness.
-function get_music_from_alpha_site()
-{
- sep
- echo "getting musix and basement from fred music prime device"
- rsync -av /media/fred/fredmusicprime/musix/* /z/musix/
- rsync -av /media/fred/fredmusicprime/basement/* /z/basement/
- sep
- echo
-}
-
-# updates the music on a remote host to our current local copy on the music host.
-function update_musix_pile()
-{
- sep
- local host="$1"; shift
- echo "$host: synching musix and basement"
- rsync -avz /z/musix/* ${host}:/z/musix/
- rsync -avz /z/basement/* ${host}:/z/basement/
- sep
- echo
-}
-
-##############
-
-# make sure the local machine, our first-stop musix host, is in good shape.
-get_music_from_alpha_site
-
-# run through the steps of updating all our machines.
-for i in ${MUSIX_ARCHIVE_SITE_LIST[@]}; do
- update_musix_pile $i
-done
-
-
+++ /dev/null
-#!/bin/bash
-
-source "$FEISTY_MEOW_SCRIPTS/core/launch_feisty_meow.sh"
-
-echo "Updating walrus and musix from surya: raw mode without syncthing!"
-echo
-
-for currdir in basement imaginations musix walrus; do
- sep
- echo "synching $currdir folder..."
- rsync -avz surya:/z/$currdir/* /z/$currdir/
-done
-
-sep
-
+++ /dev/null
-#!/bin/bash
-
-# updates the mounted barkuptree drive with stuff on wildmutt.
-# very specific currently.
-
-source "$FEISTY_MEOW_SCRIPTS/core/launch_feisty_meow.sh"
-
-export BARKY=/media/fred/barkuptreedrive
-
-# copy up the archived bluray discs, and possibly future archived formats.
-netcp /z/archons/* $BARKY/bkup_archons/
-test_or_die "synching archons"
-
-# copy over our somewhat attenuated but still important walrus archives.
-netcp /z/walrus/* $BARKY/walrus/
-test_or_die "synching walrus"
-
-# copy all the music files for future reference.
-netcp /z/musix/* $BARKY/musix/
-test_or_die "synching musix"
-
-# back up the photo archives.
-netcp /z/imaginations/* $BARKY/imaginations/
-test_or_die "synching imaginations"
-
-
+++ /dev/null
-#!/bin/bash
-
-# updates my little 1 TB "soapbox" style usb drive with items that it should contain.
-
-source "$FEISTY_MEOW_SCRIPTS/core/launch_feisty_meow.sh"
-source "$FEISTY_MEOW_SCRIPTS/archival/shared_updater_parts.sh"
-
-# where we're backing up to.
-TARGET_FOLDER="/media/fred/fredmusicprime"
-
-sep
-
-echo Target drive currently has...
-ls "$TARGET_FOLDER"
-if [ $? -ne 0 ]; then
- echo "The target location '$TARGET_FOLDER' is not mounted currently, so cannot be updated."
- exit 1
-fi
-
-# synch all our targets.
-for currdir in $ARCHIVE_COLLECTIONS_LIST; do
- synch_directory_to_target "$currdir" "$TARGET_FOLDER/$(basename $currdir)"/
-done
-
-sep
-
-# update source code if present.
-echo getting latest fred repositories...
-pushd "$TARGET_FOLDER"
-update_source_folders extra_brain
-
-sep
-
-echo Updated all expected portions of the targets successfully.
-
+++ /dev/null
-#!/bin/bash
-
-# updates my little 1 TB "soapbox" style usb drive with items that it should contain.
-
-source "$FEISTY_MEOW_SCRIPTS/core/launch_feisty_meow.sh"
-source "$FEISTY_MEOW_SCRIPTS/archival/shared_updater_parts.sh"
-
-# where we're backing up to.
-TARGET_FOLDER="/media/fred/soapboxdrive"
-
-sep
-
-echo Target drive currently has...
-ls "$TARGET_FOLDER"
-if [ $? -ne 0 ]; then
- echo "The target location '$TARGET_FOLDER' is not mounted currently, so cannot be updated."
- exit 1
-fi
-
-# synch all our targets.
-for currdir in $ARCHIVE_COLLECTIONS_LIST; do
- synch_directory_to_target "$currdir" "$TARGET_FOLDER/$(basename $currdir)"/
-done
-
-sep
-
-# update source code if present.
-echo getting latest fred repositories...
-pushd "$TARGET_FOLDER"
-update_source_folders extra_brain
-
-sep
-
-echo Updated all expected portions of the targets successfully.
-
function print_instructions()
{
echo -e "\n$(basename $0 .sh):\n"
+
+#hmmm: extract to a terminal size function.
+# calculate the number of columsn in the terminal.
+cols=$(stty size | awk '{print $2}')
+
echo -e 'this script takes two parameters, a "here" folder and a "there" folder, almost as if it were a copy command. but instead, this removes any file from under the "here" location if it cannot be found in the "there" location. so the "there" location is considered a more definitive template of what should be in "here", such that we strip out what "there" does not have.\n\n
-the most" useful way to use this script is for a "here" hierarchy that is a copy of an older version of another "there" hierarchy. the "there" hierarchy may have changed a lot, including new files, changed files, and deleted files. it is a simple operation to copy everything from "there" into "here" (such as by using the command [ cp -R "$there"/* "$here" ] ) , but it is a lot harder to determine what stuff in "here" is out of date and should be removed. that is where this script comes in; it can be run to flush out any older things in "here", rather than requiring the user to manually find all those files. ' | splitter
+the most" useful way to use this script is for a "here" hierarchy that is a copy of an older version of another "there" hierarchy. the "there" hierarchy may have changed a lot, including new files, changed files, and deleted files. it is a simple operation to copy everything from "there" into "here" (such as by using the command [ cp -R "$there"/* "$here" ] ) , but it is a lot harder to determine what stuff in "here" is out of date and should be removed. that is where this script comes in; it can be run to flush out any older things in "here", rather than requiring the user to manually find all those files. ' | splitter --maxcol $(($cols - 1))
echo
echo "Example Usage:"
echo
+++ /dev/null
-#!/bin/bash
-
-# this "fluffs out" the repositories that it finds. what this means is that
-# any git repositories found will have all of their remote state updated (by
-# pulling all remote repos). this ensures that any upstream changes get
-# merged into the local branch.
-# it's better to fluff out your code regularly rather than waiting for a huge
-# merge snarl later. note that if you check in the code frequently with the
-# feisty meow scripts, that will also take care of fluffing out the code.
-
-source "$FEISTY_MEOW_SCRIPTS/core/launch_feisty_meow.sh"
-source "$FEISTY_MEOW_SCRIPTS/rev_control/version_control.sh"
-
-##############
-
-dir="$1"; shift
-if [ -z "$dir" ]; then
- dir=.
-fi
-
-pushd "$dir" &>/dev/null
-test_or_die "changing to directory: $dir"
-tempfile=$(generate_rev_ctrl_filelist)
-test_or_die "generating revision control file list"
-popd &>/dev/null
-
-perform_revctrl_action_on_file "$tempfile" do_careful_git_update
-test_or_die "fluffing out repository at: $tempfile"
-
--- /dev/null
+#!/bin/bash
+
+# this "puffs out" the repositories that it finds. what this means is that
+# any git repositories found will have all of their remote state updated (by
+# pulling all remote repos). this ensures that any upstream changes get
+# merged into the local branch.
+# it's better to puff out your code regularly rather than waiting for a huge
+# merge snarl later. note that if you check in the code frequently with the
+# feisty meow scripts, that will also take care of puffing out the code.
+
+source "$FEISTY_MEOW_SCRIPTS/core/launch_feisty_meow.sh"
+source "$FEISTY_MEOW_SCRIPTS/rev_control/version_control.sh"
+
+##############
+
+dir="$1"; shift
+if [ -z "$dir" ]; then
+ dir=.
+fi
+
+pushd "$dir" &>/dev/null
+test_or_die "changing to directory: $dir"
+tempfile=$(generate_rev_ctrl_filelist)
+test_or_die "generating revision control file list"
+popd &>/dev/null
+
+perform_revctrl_action_on_file "$tempfile" do_careful_git_update
+test_or_die "puffing out repository at: $tempfile"
+
# use our splitter tool for lengthy output if it's available.
if [ ! -z "$(which splitter)" ]; then
TO_SPLITTER="$(which splitter)"
+
+#hmmm: another reusable chunk here, getting terminal size.
+ # calculate the number of columsn in the terminal.
+ cols=$(stty size | awk '{print $2}')
+ TO_SPLITTER+=" --maxcol $(($cols - 1))"
else
TO_SPLITTER=cat
fi
##############
+#hmmm: move this to core
+# this makes the status of pipe N into the main return value.
+function promote_pipe_return()
+{
+ ( exit ${PIPESTATUS[$1]} )
+}
+
+##############
+
# one unpleasantry to take care of first; cygwin barfs aggressively if the TMP directory
# is a DOS path, but we need it to be a DOS path for our GFFS testing, so that blows.
# to get past this, TMP gets changed below to a hopefully generic and safe place.
$blatt
# put all changed and new files in the commit. not to everyone's liking.
- git add --all .
+ git add --all . | $TO_SPLITTER
+ promote_pipe_return 0
test_or_die "git add all new files"
# see if there are any changes in the local repository.
# upload any changes to the upstream repo so others can see them.
git push origin "$(my_branch_name)" 2>&1 | grep -v "X11 forwarding request failed" | $TO_SPLITTER
+ promote_pipe_return 0
test_or_die "git push"
fi
{
local branch="$1"; shift
+ if [ -z "$branch" ]; then
+ echo "No branch was passed to check branch state."
+ return 1
+ fi
+
local to_return=120 # unknown issue.
local local_branch=$(git rev-parse @)
return 0
fi
+ local this_branch="$(my_branch_name)"
+
+ state=$(check_branch_state "$this_branch")
+ echo "=> branch '$this_branch' state prior to remote update is: $state"
+
# first update all our remote branches to their current state from the repos.
- git remote update
+ git remote update | $TO_SPLITTER
+ promote_pipe_return 0
test_or_die "git remote update"
- local this_branch="$(my_branch_name)"
-#appears to be useless; reports no changes when we need to know about remote changes that do exist:
-#hmmm: trying it out again now that things are better elsewhere. let's see what it says.
state=$(check_branch_state "$this_branch")
- echo "=> branch '$this_branch' state is: $state"
+ echo "=> branch '$this_branch' state after remote update is: $state"
# this code is now doing what i have to do when i repair the repo. and it seems to be good so far.
local branch_list=$(all_branch_names)
local bran
for bran in $branch_list; do
# echo "synchronizing remote branch: $bran"
- git checkout "$bran"
+ git checkout "$bran" | $TO_SPLITTER
+ promote_pipe_return 0
test_or_die "git switching checkout to remote branch: $bran"
state=$(check_branch_state "$bran")
remote_branch_info=$(git ls-remote --heads origin $bran 2>/dev/null)
if [ ! -z "$remote_branch_info" ]; then
# we are pretty sure the remote branch does exist.
- git pull --no-ff origin "$bran"
+ git pull --no-ff origin "$bran" | $TO_SPLITTER
+ promote_pipe_return 0
+
+ echo "=> branch '$bran' state after pull is: $state"
fi
test_or_die "git pull of remote branch: $bran"
done
# now switch back to our branch.
- git checkout "$this_branch"
+ git checkout "$this_branch" | $TO_SPLITTER
+ promote_pipe_return 0
test_or_die "git checking out our current branch: $this_branch"
# now pull down any changes in our own origin in the repo, to stay in synch
# with any changes from others.
- git pull --no-ff --all
+ git pull --no-ff --all | $TO_SPLITTER
+ promote_pipe_return 0
test_or_die "git pulling all upstream"
popd &>/dev/null
if test_writeable "CVS"; then
$blatt
cvs update . | $TO_SPLITTER
+ promote_pipe_return 0
test_or_die "cvs update"
fi
elif [ -d ".svn" ]; then
if test_writeable ".svn"; then
$blatt
svn update . | $TO_SPLITTER
+ promote_pipe_return 0
test_or_die "svn update"
fi
elif [ -d ".git" ]; then
if test_writeable ".git"; then
$blatt
git pull --no-ff 2>&1 | grep -v "X11 forwarding request failed" | $TO_SPLITTER
- if [ ${PIPESTATUS[0]} -ne 0 ]; then false; fi
+ promote_pipe_return 0
test_or_die "git pull of origin without fast forwards"
fi
else
local sortfile=$(mktemp /tmp/zz_checkin_sort.XXXXXX)
sort <"$tempfile" >"$sortfile"
- \rm "$tempfile"
echo "$sortfile"
+ \rm "$tempfile"
}
# iterates across a list of directories contained in a file (first parameter).
restore_terminal_title
- rm $tempfile
+ rm "$tempfile"
}
#!/bin/bash
-# this config file provides the default values for the variables used in our site management scripts.
+# provides the default values for the variables used in our site management scripts.
+
+# config files for site avenger apps usually override nothing, since we
+# auto-construct the app name and domain.
+# if they do need to override anything, they can just specify replacement
+# values for the variables in this file.
####
# basic information that is constant for all site avenger sites.
-APPLICATION_DIR="$HOME/apps"
-DEFAULT_REPOSITORY_ROOT="git@github.com:kwentworth"
-CHECKOUT_DIR_NAME="avenger5"
-
-####
-
-# config files for site avenger apps usually override nothing, since we
-# auto-construct the app name and domain. but if they do need to override
-# anything, it will be below this point in the file.
-# the derived config file should include the basic configs like so:
-#
-# source "$WORKDIR/config/default.app"
+export APPLICATION_DIR="$HOME/apps"
+export DEFAULT_REPOSITORY_ROOT="git@github.com:kwentworth"
+export CHECKOUT_DIR_NAME="avenger5"
####
# deployment information for the application / site.
-APPLICATION_NAME="${app_dirname}"
+export APPLICATION_NAME="${app_dirname}"
echo app name was computed as $APPLICATION_NAME
# change this if the site is on the "real" internet.
-DOMAIN_NAME="${app_dirname}.vm"
+export DOMAIN_NAME="${app_dirname}.vm"
echo domain name was computed as $DOMAIN_NAME
-REPO_NAME="${app_dirname}.git"
+export REPO_NAME="${app_dirname}"
echo repo name was computed as $REPO_NAME
-THEME_NAME="$(capitalize_first_char "${app_dirname}.git")"
+export THEME_NAME="$(capitalize_first_char "${app_dirname}")"
echo theme name was computed as $THEME_NAME
# a special override for the mapsdemo site, which we want to put in as
# a subdomain of the cakelampvm domain.
-source "$WORKDIR/config/default.app"
+export DOMAIN_NAME="${APPLICATION_NAME}.cakelampvm.com"
-DOMAIN_NAME="${APPLICATION_NAME}.cakelampvm.com"
+echo "*** overrode domain name as: $DOMAIN_NAME"
# start with. The concept of the theme comes from cakephp.
export WORKDIR="$( \cd "$(\dirname "$0")" && \pwd )" # obtain the script's working directory.
+export FEISTY_MEOW_APEX="$( \cd "$WORKDIR/../.." && \pwd )"
+
+source "$FEISTY_MEOW_APEX/scripts/core/launch_feisty_meow.sh"
############################
function print_instructions()
{
echo
- echo "$(basename $0 .sh) [app dirname] [repository] [theme name]"
+ echo "$(basename $0 .sh) [app dirname] [repository] [theme name] "
+#[user name]
echo
echo "All parameters are optional, and intelligent guesses for them will be made."
echo
echo "app dirname: The folder where the app will be stored."
echo "repository: The name of the git repository (short version, no URL)."
echo "theme name: The name to use for the cakephp theme."
+# echo "user name: The name of the user to chown the checkout to."
echo
exit 0
}
app_dirname="$1"; shift
repo_name="$1"; shift
theme_name="$1"; shift
+#user_name="$1"; shift
+
+#echo "*** user name is $user_name"
if [ "$app_dirname" == "-help" -o "$app_dirname" == "--help" ]; then
print_instructions
echo "Theme name: $theme_name"
sep
+echo in powerup before update repo with:
+var CHECKOUT_DIR_NAME DEFAULT_REPOSITORY_ROOT
+
# this should set the site_store_path variable if everything goes well.
update_repo "$full_app_dir" "$CHECKOUT_DIR_NAME" "$DEFAULT_REPOSITORY_ROOT" "$repo_name"
test_or_die "Updating the repository storage directory"
sep
+#if [ ! -z "$user_name" ]; then
+# echo "Chowning the apps folder to be owned by: $user_name"
+##hmmm: have to hope for now for standard group named after user
+# chown -R "$user_name:$user_name" "$APPLICATION_DIR"
+# test_or_die "Chowning $APPLICATION_DIR to be owned by $user_name"
+#fi
+
+sep
+
+
echo "Finished powering up the site in '${app_dirname}'."
--- /dev/null
+#!/bin/bash
+
+# fixes the cakelampvm permissions according to the way.
+
+##############
+
+if [[ $EUID != 0 ]]; then
+ echo "This script must be run as root or sudo."
+ exit 1
+fi
+
+##############
+
+export WORKDIR="$( \cd "$(\dirname "$0")" && \pwd )" # obtain the script's working directory.
+export FEISTY_MEOW_APEX="$( \cd "$WORKDIR/../.." && \pwd )"
+
+source "$FEISTY_MEOW_APEX/scripts/core/launch_feisty_meow.sh"
+
+##############
+
+# fix up the main web storage.
+chown -R www-data:www-data /var/www
+group_perm /var/www
+
+##############
+
+# set up access on some important folders for the developer user.
+chown -R developer:developer /home/developer
+harsh_perm /home/developer/.ssh
+chown -R developer:developer /opt/feistymeow.org
+group_perm /opt/feistymeow.org
+chown -R developer:developer /etc/apache2 /etc/bind
+group_perm /etc/apache2 /etc/bind
+
+##############
+
+# fix perms for fred user.
+chown -R fred:fred /home/fred /home/archives/stuffing
+harsh_perm /home/fred/.ssh
+
+##############
+
source "$FEISTY_MEOW_SCRIPTS/core/launch_feisty_meow.sh"
-# get our configuration loaded.
+# get our configuration loaded, if we know the config file.
+# if there is none, we will use our default version.
export SITE_MANAGEMENT_CONFIG_FILE
if [ -z "$SITE_MANAGEMENT_CONFIG_FILE" ]; then
SITE_MANAGEMENT_CONFIG_FILE="$WORKDIR/config/default.app"
+ echo "Site management config file was not set. Using default:"
+ echo " $SITE_MANAGEMENT_CONFIG_FILE"
fi
+
+# load in at least the default version to get us moving.
source "$SITE_MANAGEMENT_CONFIG_FILE"
test_or_die "loading site management configuration from: $SITE_MANAGEMENT_CONFIG_FILE"
fi
}
+# tries to find an appropriate config file for the application.
+function locate_config_file()
+{
+ local app_dirname="$1"; shift
+
+ local configfile="$WORKDIR/config/${app_dirname}.app"
+echo hoping config file would be: $configfile
+ if [ ! -f "$configfile" ]; then
+ # this is not a good config file. we can't auto-guess the config.
+ echo -e "
+There is no specific site configuration file in:
+ $configfile
+We will continue onward using the default and hope that this project follows
+the standard pattern for cakephp projects."
+ # we'll pull in the default config file we set earlier; this will
+ # reinitialize some variables based on the app name.
+ else
+ # they gave us a valid config file. let's try using it.
+ export SITE_MANAGEMENT_CONFIG_FILE="$configfile"
+ fi
+
+ # try to load the config.
+ source "$SITE_MANAGEMENT_CONFIG_FILE"
+ test_or_die "loading site management configuration from: $SITE_MANAGEMENT_CONFIG_FILE"
+
+}
+
# this function will seek out top-level directories in the target directory passed in.
# if there is only one directory, then it is returned (in the app_dirname variable).
# otherwise, the user is asked which directory to use.
mkdir "$combo"
test_or_die "Making application directory when not already present"
fi
+
+ locate_config_file "$dir"
}
# eases some permissions to enable apache to write log files and do other shopkeeping.
local repo_root="$1"; shift
local repo_name="$1"; shift
+echo here are parms in update repo:
+var full_app_dir checkout_dirname repo_root repo_name
+
# forget any prior value, since we are going to validate the path.
unset site_store_path
# is much more powerful if the site is based on cakephp and site avenger.
export WORKDIR="$( \cd "$(\dirname "$0")" && \pwd )" # obtain the script's working directory.
+export FEISTY_MEOW_APEX="$( \cd "$WORKDIR/../.." && \pwd )"
+
+source "$FEISTY_MEOW_APEX/scripts/core/launch_feisty_meow.sh"
############################
echo "$(basename $0 .sh) {app name}"
echo
echo "
+$(basename $0 .sh) will completely set up a web site, including a domain
+name and an apache configuration file. The site will be acquired from a
+git repository and configured. At the end of this script, the result should
+be an almost working website; you may need to fix the site configuration,
+create databases and so forth.
+
+This script must be run as sudo or root; it makes changes to system files.
app name: The app name parameter is mandatory. The configuration file for
this script will be derived from the app name (e.g. if the app name is MyApp,
then the config file will be 'MyApp.config'). The config files are by
# check for parameters.
app_dirname="$1"; shift
-if [ -z "$app_dirname" ]; then
- print_instructions
-fi
-
-source "$WORKDIR/shared_site_mgr.sh"
-
if [ "$app_dirname" == "-help" -o "$app_dirname" == "--help" ]; then
print_instructions
+elif [ -z "$app_dirname" ]; then
+ print_instructions
fi
-sep
-
-check_application_dir "$APPLICATION_DIR"
-
-add_domain "$DOMAIN_NAME"
-test_or_die "Setting up domain: $DOMAIN_NAME"
-
-add_apache_site "$APPLICATION_NAME" "$DOMAIN_NAME"
-test_or_die "Setting up apache site for: $APPLICATION_NAME"
-
-powerup "$APPLICATION_NAME" "$REPO_NAME" "$THEME_NAME"
-
-
-
+#we will require sudo later.
+#if [[ $EUID != 0 ]]; then
+# echo "This script must be run as root or sudo."
+# exit 1
+#fi
+source "$WORKDIR/shared_site_mgr.sh"
sep
-echo "
-Finished standing up the full domain and site in:
-${app_dirname}"
-
-#leave before old crud below
-exit 0
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+check_application_dir "$APPLICATION_DIR"
-#below is probably not needed.
# find proper webroot where the site will be initialized.
if [ -z "$app_dirname" ]; then
# no dir was passed, so guess it.
test_app_folder "$APPLICATION_DIR" "$app_dirname"
fi
-# where we expect to find our checkout folder underneath.
-full_app_dir="$APPLICATION_DIR/$app_dirname"
+#echo "!! domain being added is: $DOMAIN_NAME"
-# use our default values for the repository and theme if they're not provided.
-if [ -z "$repo_name" ]; then
- repo_name="$app_dirname"
-fi
-if [ -z "$theme_name" ]; then
- theme_name="$(capitalize_first_char ${app_dirname})"
-fi
+sudo bash "$FEISTY_MEOW_SCRIPTS/system/add_domain.sh" "$DOMAIN_NAME"
+test_or_die "Setting up domain: $DOMAIN_NAME"
-echo "Repository: $repo_name"
-echo "Theme name: $theme_name"
sep
-# this should set the site_store_path variable if everything goes well.
-update_repo "$full_app_dir" "$CHECKOUT_DIR_NAME" "$DEFAULT_REPOSITORY_ROOT" "$repo_name"
-test_or_die "Updating the repository storage directory"
+sudo bash "$FEISTY_MEOW_SCRIPTS/system/add_apache_site.sh" "$APPLICATION_NAME" "$DOMAIN_NAME"
+test_or_die "Setting up apache site for: $APPLICATION_NAME"
-# update the site to load dependencies.
sep
-composer_repuff "$site_store_path"
-test_or_die "Installing site dependencies with composer"
-# set up the symbolic links needed to achieve siteliness.
-sep
+#echo about to do powerup with: app="$APPLICATION_NAME" repo="$REPO_NAME" theme="$THEME_NAME"
+#echo default repo is "$DEFAULT_REPOSITORY_ROOT"
-create_site_links "$site_store_path" "$theme_name"
+powerup "$APPLICATION_NAME" "$REPO_NAME" "$THEME_NAME"
+# pass the real user name who should own the files.
+# "$(logname)"
sep
-echo "Finished powering up the site in '${app_dirname}'."
+echo "
+Finished standing up the full domain and site for: ${app_dirname}
+The domain name is: $DOMAIN_NAME
+"
# auto-find the scripts, since we might want to run this as sudo.
export WORKDIR="$( \cd "$(\dirname "$0")" && /bin/pwd )" # obtain the script's working directory.
-source "$WORKDIR/../core/launch_feisty_meow.sh"
+export FEISTY_MEOW_APEX="$( \cd "$WORKDIR/../.." && \pwd )"
+
+source "$FEISTY_MEOW_APEX/scripts/core/launch_feisty_meow.sh"
# some convenient defaults for our current usage.
if [ -f "$site_config" ]; then
echo "The apache configuration file already exists at:"
echo " $site_config"
- echo "Please remove this file before proceeding, if it is junk. For example:"
- echo " sudo rm $site_config"
- exit 1
+ echo "Since apache configuration files can get very complex, we do not want to"
+ echo "assume that this file is removable. Calling the site addition done."
+ exit 0
fi
echo "Creating a new apache2 site for $sitename with config file:"
Include /etc/apache2/conf-library/rewrite-enabling.conf
</VirtualHost>
" >"$site_config"
+
+ chown "$(logname):$(logname)" "$site_config"
+ test_or_die "setting ownership on: $site_config"
}
# turns on the config file we create above for apache.
# main body of script.
-if (( $EUID != 0 )); then
+if [[ $EUID != 0 ]]; then
echo "This script must be run as root or sudo."
exit 1
fi
#
# Author: Chris Koeritz
+export WORKDIR="$( \cd "$(\dirname "$0")" && \pwd )" # obtain the script's working directory.
+export FEISTY_MEOW_APEX="$( \cd "$WORKDIR/../.." && \pwd )"
+
+source "$FEISTY_MEOW_APEX/scripts/core/launch_feisty_meow.sh"
+
# some defaults that are convenient for current purposes.
-# hmmm: these would need to be parameterized somehow for this script to become really general.
+
+# hmmm: !!! these would need to be parameterized somehow for this script to become really general.
# in our scheme, the single IP address that all our domains map to.
IP_ADDRESS="10.28.42.20"
# the email address (where first dot is replaced by @) for the administrator of the domain.
-SERVER_ADMIN="fred.cakelampvm.com"
+SERVER_ADMIN="developer.cakelampvm.com"
# the name of the name server for the new domains (should already be configured).
MAIN_NAME_SERVER="ns.cakelampvm.com"
# the name of the mail server for a new domain (should already be configured).
echo "using the config file: $domain_file"
if [ -f $domain_file ]; then
+ echo
echo "The domain configuration file already exists at:"
echo " $domain_file"
- echo "Please remove this file before proceeding, if it is junk. For example:"
- echo " sudo rm $domain_file"
- exit 1
+ echo "Since we don't want to tear that down if it has specialized configuration"
+ echo "data in it, we will just leave it in place and consider our job done."
+ echo
+ exit 0
fi
echo "
${domain_name}. IN A ${IP_ADDRESS}
IN HINFO \"linux server\" \"${DISTRO}\"
" >"$domain_file"
+
+ # our personalized configuration approach wants the real owner to own the file.
+ chown "$(logname):$(logname)" $domain_file
+ test_or_die "setting ownership on: $domain_file"
}
# hooks up a new config file into bind's list of zones.
////////////////////////////////////////////////////////////////////////////
" >> /etc/bind/named.conf.local
+
+ # keep ownership for the real user.
+ chown "$(logname):$(logname)" /etc/bind/named.conf.local
+ test_or_die "setting ownership on: /etc/bind/named.conf.local"
+
}
# adds a new subdomain under a containing domain.
IN HINFO \"linux server\" \"${DISTRO}\"
" >> /etc/bind/${containing_domain}.conf
+ # keep ownership for real user.
+ chown "$(logname):$(logname)" "/etc/bind/${containing_domain}.conf"
+ test_or_die "setting ownership on: /etc/bind/${containing_domain}.conf"
}
function restart_bind()
# main body of script.
-if (( $EUID != 0 )); then
+if [[ $EUID != 0 ]]; then
echo "This script must be run as root or sudo."
exit 1
fi
projects / feisty_meow.git / commitdiff