From ngcr@planet8.planet8.sp.unisys.com Thu Jan 10 16:23:26 1991 Received: from cs.Princeton.EDU (cs.Princeton.EDU) by fs.Princeton.EDU (4.0/1.105) id AA12318; Thu, 10 Jan 91 16:23:23 EST Received: from fs.Princeton.EDU by cs.Princeton.EDU (5.57/1.105) id AA09028; Thu, 10 Jan 91 16:23:19 EST Received: from Princeton.EDU (Princeton.EDU.) by fs.Princeton.EDU (4.0/1.105) id AA12315; Thu, 10 Jan 91 16:23:15 EST Received: from [129.218.60.4] by Princeton.EDU (5.61++/2.62/princeton) id AA16288; Thu, 10 Jan 91 16:23:09 -0500 Received: by email.sp.unisys.com (5.57/Ultrix3.0-C) id AA15274; Thu, 10 Jan 91 15:22:05 -0600 Received: from pablo.sp.unisys.com. by planet8.planet8.sp.unisys.com. (4.0/SMI-4.0) id AA12500; Thu, 10 Jan 91 15:22:39 CST Date: Thu, 10 Jan 91 15:22:39 CST From: ngcr<@fs>@Princeton.EDU (Sylvester Fernandez) Message-Id: <9101102122.AA12500@planet8.planet8.sp.unisys.com.> To: nr@Princeton.EDU Subject: Re: Ada Web Status: R All the bugs I found were in the grammar. Here is the modified version we are using now: ----------- ada.spider ----------- # Copyright 1989 by Norman Ramsey, Odyssey Research Associates # Not to be sold, but may be used freely for any purpose # For more information, see file COPYRIGHT in the parent directory # Modified by Sylvester Fernandez language Ada extension ada at_sign @ module definition stmt use stmt comment begin end newline macros begin \def\commentbegin{{\tt -- }} macros end line begin end <""> default translation <*> mathness yes token identifier category math mathness maybe token number category math mathness yes token newline category ignore_scrap translation <> mathness maybe token pseudo_semi translation <> category semi mathness maybe macros begin \let\R\relax macros end # Delimiters token & category binop translation <"\\amp"> token ( category open token ) category close token * category binop token + category unorbinop token , category binop translation <",\\,"-opt-3> token - category unorbinop token . category binop token / category binop token : category binop token ; category semi translation <";"-space-opt-2> token < category binop token = category binop token > category binop token | category binop translation <"\\mid"> # Compound delimiters token => category arrow translation <"\\AR"> token .. category binop translation <"\\.{..}\\>"> token ** category binop translation <"\\mathbin{**}"> token := category binop translation <"\\mathbin{:=}"> token /= translation <"\\I"> category binop token >= translation <"\\G"> category binop token <= translation <"\\L"> category binop token << translation <"\\LL"> category openlabel token >> translation <"\\GG"> category closelabel token <> translation <"\\LG"> category math # Hacks no ', and this becomes a binary op token ' category binop mathness no token # category math translation <"\\#"> default mathness maybe translation <*> reserved abort ilk math_like reserved abs ilk unop_like reserved accept ilk proc_like reserved access ilk math_like reserved all ilk math_like reserved and ilk and_like reserved array ilk math_like reserved at ilk at_like reserved begin ilk begin_like reserved body ilk math_like reserved case ilk case_like reserved constant ilk math_like reserved declare ilk decl_like reserved delay ilk math_like reserved delta ilk math_like reserved digits ilk math_like reserved do ilk do_like reserved else ilk else_like reserved elsif ilk elsif_like reserved end ilk end_like reserved entry ilk proc_like reserved exception ilk ex_like reserved exit ilk math_like reserved for ilk math_like reserved function ilk proc_like reserved generic ilk gen_like reserved goto ilk math_like reserved if ilk if_like reserved in ilk unorbinop_like reserved is ilk is_like reserved limited ilk math_like reserved loop ilk loop_like reserved mod ilk binop_like reserved new ilk unop_like reserved not ilk unop_like reserved null ilk math_like reserved of ilk math_like reserved or ilk or_like reserved others ilk math_like reserved out ilk math_like reserved package ilk proc_like reserved pragma ilk math_like reserved private ilk private_like reserved procedure ilk proc_like reserved raise ilk math_like reserved range ilk math_like reserved record ilk record_like reserved rem ilk binop_like reserved renames ilk math_like reserved return ilk math_like reserved reverse ilk math_like reserved select ilk select_like reserved separate ilk separate_like reserved subtype ilk math_like reserved task ilk proc_like reserved terminate ilk math_like reserved then ilk then_like reserved type ilk math_like reserved use ilk math_like reserved when ilk when_like reserved while ilk math_like reserved with ilk with_like reserved xor ilk binop_like ilk and_like translation <*> category and ilk at_like translation <*> category at ilk begin_like translation <*-indent> category beginning ilk binop_like translation <"\\"-space-*-"\\"-space> category binop ilk case_like translation <*> category case ilk decl_like translation <*-indent> category declaration ilk do_like translation <*> category do ilk else_like translation <*> category else ilk elsif_like translation <*> category elsif ilk end_like translation <*> category close ilk ex_like translation <*> category exception ilk gen_like translation <*-indent> category generic ilk if_like translation <*> category if ilk is_like translation <*> category is ilk loop_like translation <*> category loop ilk math_like translation <*> category math ilk or_like translation <*> category or ilk private_like translation <*> category private ilk proc_like translation category proc ilk record_like translation <*> category record ilk select_like translation <*> category select ilk separate_like translation <*> category separate ilk then_like translation <*> category then ilk unop_like translation <*-"\\"-space> category unop ilk unorbinop_like translation <"\\"-space-*-"\\"-space> category resunorbinop ilk when_like translation <*> category when ilk with_like translation <*> category with # \MC means ``math close'' and sets \MS to ``math set'' macros begin \def\MC{\ifmmode\global\let\MS$\else\global\let\MS\relax\fi\relax\MS} \def\LG{\mathord{<}\mathord{>}} \let\IG=\ignorespaces macros end beginning continuation ending --> stmt beginning ending --> stmt # beginning (stmt|ignore_scrap) --> beginning beginning stmt --> beginning case <"\\"-space> math <"\\"-space> is --> beginning close semi --> ending close <"\\"-space> ? semi --> ending close <"\\"-space> ? <"\\"-space> ? semi --> ending continuation stmt --> continuation continuation continuation --> continuation declaration beginning continuation ending --> stmt declaration beginning ending --> stmt declaration ending --> stmt declaration (declaration|stmt) --> declaration else --> continuation elsif <"\\"-space> math <"\\"-space> then --> continuation exception --> continuation generic declaration --> declaration generic stmt --> generic if <"\\"-space> math <"\\"-space> then --> ifthen ifthen stmt --> beginning ifthen <"\\"-space> math <"\\"-space> else --> ifthen ifthen <"\\"-space> math <"\\"-space> close <"\\"-space> if --> math ifthen <"\\"-space> math <"\\"-space> elsif --> if is --> math loop --> beginning math [ <"\\"-space> and <"\\"-space> then <"\\"-space> ] --> math binop math [ <"\\"-space> and <"\\"-space> ] --> math binop math (binop|unorbinop) math --> math math <"\\"-space> resunorbinop <"\\"-space> math --> math (unorbinop|unop) math --> math resunorbinop <"\\"-space> math --> math # This doesn't apply in Ada: math unop --> math math arrow --> math math <"\\"-space> at --> math math binop <"\\"-space> exception --> math math <"\\"-space> is --> math math <"\\"-space> loop --> loop math <"\\"-space> math --> math math [ <"\\"-space> or <"\\"-space> else <"\\"-space> ] --> math binop math [ <"\\"-space> or <"\\"-space> ] --> math binop math <"\\"-space> private --> math math <"\\"-space> separate --> math math stmt --> stmt math terminator --> stmt open close --> math open math close --> math open [ math semi ] --> open math openlabel math closelabel --> math or --> continuation private --> beginning proc <"\\"-space> math <"\\"-space> is <"\\"-space> unop --> math proc <"\\"-space> math <"\\"-space> is <"\\"-space> separate --> math proc <"\\"-space> math <"\\"-space> is --> declaration proc <"\\"-space> math <"\\"-space> do --> beginning proc <"\\"-space> math terminator --> declaration #record <"\\"-space> at <"\\"-space> math terminator --> beginning record --> beginning select --> beginning semi --> terminator separate math --> stmt stmt declaration --> declaration stmt stmt --> stmt stmt ending --> stmt when <"\\"-space> math arrow --> whengroup [ when <"\\"-space> math ] terminator --> math terminator whengroup stmt ending --> ending whengroup stmt continuation --> continuation whengroup stmt whengroup --> whengroup with <"\\"-space> math --> math with <"\\"-space> proc <"\\"-space> math --> math ? ignore_scrap --> #1 macros begin \let\AR=\Longrightarrow macros end ------------------ End of ada.spider ------------------ I'll let you know about the change you suggested. Until the problem has been fixed, I have asked users here not use bases larger than ten when specifying numeric constants. Sylvester Fernandez