home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / unix / volume11 / inline / part04 < prev    next >
Text File  |  1987-09-14  |  41KB  |  2,213 lines
  1. Subject:  v11i042:  Inline code expander for C, Part04/04
  2. Newsgroups: comp.sources.unix
  3. Sender: sources
  4. Approved: rs@uunet.UU.NET
  5.  
  6. Submitted-by: omepd!mcg
  7. Posting-number: Volume 11, Issue 42
  8. Archive-name: inline/Part04
  9.  
  10. # This is a shell archive.  Remove anything before this line
  11. # then unpack it by saving it in a file and typing "sh file"
  12. # (Files unpacked will be owned by you and have original permissions).
  13. # This archive contains the following files:
  14. #    ./patchlevel.h
  15. #    ./Makefile
  16. #    ./scan.l
  17. #    ./BUGS
  18. #    ./MINVERS
  19. #    ./test.c
  20. #    ./test2.c
  21. #
  22. if `test ! -s ./patchlevel.h`
  23. then
  24. echo "writing ./patchlevel.h"
  25. sed 's/^X//' > ./patchlevel.h << '\Rogue\Monster\'
  26. X/* patchlevel file */
  27. X
  28. X#define PATCHLEVEL 0
  29. X
  30. X
  31. \Rogue\Monster\
  32. else
  33.   echo "will not over write ./patchlevel.h"
  34. fi
  35. chmod 444 ./patchlevel.h
  36. if [ `wc -c ./patchlevel.h | awk '{printf $1}'` -ne 46 ]
  37. then
  38. echo `wc -c ./patchlevel.h | awk '{print "Got " $1 ", Expected " 46}'`
  39. fi
  40. if `test ! -s ./Makefile`
  41. then
  42. echo "writing ./Makefile"
  43. sed 's/^X//' > ./Makefile << '\Rogue\Monster\'
  44. X#
  45. X# Makefile for 'inline' program - C inline code substituter
  46. X#
  47. X# (c) copyright 1986, 1987, S. McGeady, all rights reserved
  48. X#
  49. X#
  50. X# NOTE - comment out some lines below if you don't have RCS
  51. X#
  52. X
  53. X# CFLAGS=-g -pg
  54. X# CFLAGS=-g
  55. XCFLAGS=-O
  56. X
  57. Xall: inline test
  58. X
  59. XMAJVERS = "3"
  60. XHDRS = inline.h tokens.h
  61. XSRCS = inline.c declare.c expand.c rewrite.c yylex.c tokens.c utils.c mem.c
  62. XOBJS = inline.o declare.o expand.o rewrite.o yylex.o tokens.o utils.o mem.o
  63. X
  64. Xinline: $(OBJS) vers.o
  65. X    $(CC) -o inline $(CFLAGS) $(OBJS) vers.o
  66. X
  67. Xyylex.o: yylex.c $(HDRS)
  68. Xdeclare.o: declare.c $(HDRS)
  69. Xexpand.o: expand.c $(HDRS)
  70. Xutils.o: utils.c $(HDRS)
  71. Xinline.o: inline.c $(HDRS)
  72. Xrewrite.o: rewrite.c $(HDRS)
  73. Xmem.o: mem.c
  74. Xtokens.o: tokens.c
  75. X
  76. Xvers.o: $(OBJS) patchlevel.h
  77. X    -@chmod u+w MINVERS
  78. X    -expr "`cat MINVERS`" + 1 > MINVERS
  79. X    echo '#include "patchlevel.h"' > vers.c
  80. X    echo 'static char *vers[] = {' >> vers.c
  81. X    echo '"$$''Header: inline version' $(MAJVERS).`cat MINVERS` 'compiled' "`date`" "flags '$(CFLAGS)'" '$$",' >> vers.c
  82. X    # if you don't have RCS, this will fail
  83. X    # COMMENT THIS LINE OUT IF YOU DON'T HAVE RCS ON YOUR SYSTEM
  84. X    # perhaps replace with:
  85. X    # grep '\$$''Header:' $(HDRS) $(SRCS) | sed 's/^.*\$$\(.*\)\$$$$/"$$\1$$",/' >> vers.c
  86. X    -ident $(HDRS) $(SRCS) | grep '\$$''Header:' | sed 's/^.*\$$\(.*\)\$$$$/"$$\1$$",/' >> vers.c
  87. X
  88. X    # END OF RCS SECTION
  89. X
  90. X    echo '};' >> vers.c
  91. X    $(CC) -c vers.c
  92. X
  93. X#
  94. X# this is all for verification
  95. X#
  96. X
  97. Xbasex: test.c
  98. X    $(CC) -o basex -Dinline=static test.c
  99. X
  100. Xtestx: inline test.c
  101. X    ./inline -w -s < test.c > x.c
  102. X    $(CC) -o testx x.c
  103. X
  104. Xtest2x: inline test2.c
  105. X    ./inline -w -2 -s test2.c > x2.c
  106. X    $(CC) -o test2x x2.c
  107. X
  108. Xtest: inline basex testx test2x
  109. X    @echo 'starting validation tests'
  110. X    ./basex > base.out
  111. X    ./testx > test.out
  112. X    @sh -c 'if grep -s FAIL base.out; then echo "your compiler is broken"; exit 1; else exit 0; fi'
  113. X    @sh -c 'if grep -s FAIL test.out; then echo "something is wrong with inline or your compiler"; exit 1; else exit 0; fi'
  114. X    @sh -c 'if test `wc -l <base.out` -ne `wc -l <test.out`; then echo "something is wrong with inline or your compiler"; exit 1; else exit 0; fi'
  115. X    @echo 'testing two-pass mode'
  116. X    ./test2x > test2.out
  117. X    @sh -c 'if grep -s FAIL test2.out; then echo "something is wrong with inline in 2-pass mode"; exit 1; else exit 0; fi'
  118. X    @sh -c 'if test `wc -l <base.out` -ne `wc -l <test2.out`; then echo "something is wrong with inline in 2-pass mode"; exit 1; else exit 0; fi'
  119. X    @echo 'testing complete - everything looks ok'
  120. X
  121. Xclean:
  122. X    rm -f scan.c tstscan.c $(OBJS) vers.o \
  123. X        mon.out core tstscan.o x.c basex testx base.out test.out
  124. X
  125. Xlint:    $(SRCS) $(HDRS)
  126. X    lint -h -c -n inline.c declare.c expand.c rewrite.c utils.c mem.c yylex.c tokens.c
  127. X
  128. X#
  129. X# this expects the 'rogue monster' (mips!roger) shar 
  130. X# -c includes size checking, -p retains permissions, -x X prepends 'X' to lines
  131. X#
  132. Xshar:    $(SRCS) $(HDRS) Makefile inline.1 scan.l
  133. X    shar -c -p -x X -f inline. inline.1 $(HDRS) $(SRCS) patchlevel.h \
  134. X        Makefile scan.l NOTES COPYRIGHT BUGS MINVERS test.c test2.c
  135. X
  136. X
  137. X# scan.o: scan.l inline.h tokens.h
  138. X# tstscan: scan.c tokens.o
  139. X#    cp scan.c tstscan.c
  140. X#    $(CC) -c -DTEST tstscan.c
  141. X#    $(CC) -o tstscan -g tstscan.o tokens.o
  142. X
  143. \Rogue\Monster\
  144. else
  145.   echo "will not over write ./Makefile"
  146. fi
  147. chmod 444 ./Makefile
  148. if [ `wc -c ./Makefile | awk '{printf $1}'` -ne 3126 ]
  149. then
  150. echo `wc -c ./Makefile | awk '{print "Got " $1 ", Expected " 3126}'`
  151. fi
  152. if `test ! -s ./scan.l`
  153. then
  154. echo "writing ./scan.l"
  155. sed 's/^X//' > ./scan.l << '\Rogue\Monster\'
  156. XD            [0-9]
  157. XL            [a-zA-Z_]
  158. XH            [a-fA-F0-9]
  159. XE            [Ee][+-]?{D}+
  160. XLS            (l|L)
  161. XUS            (u|U)
  162. X
  163. X%{
  164. X/*
  165. X * inline code expander
  166. X *
  167. X * (c) 1986 - copyright 1986, s. mcgeady, all rights reserved
  168. X */
  169. X
  170. X/* $Header: scan.l,v 1.5 87/04/27 18:16:48 mcg Rel $ */
  171. X
  172. X
  173. X#include <stdio.h>
  174. X#include "tokens.h"
  175. X#include "inline.h"
  176. X
  177. X#ifdef COUNTCOLUMN
  178. Xvoid count();
  179. X#else
  180. X#define    count()
  181. X#endif
  182. X
  183. X#define    COMMENT        1
  184. X#define    CPPLINE        2
  185. X#define    STRING        3
  186. X
  187. Xextern char *gather();
  188. X
  189. Xchar *yylval;
  190. X
  191. Xint line = 1;
  192. Xint column = 0;
  193. X
  194. Xstatic int bracelev = 0;
  195. Xstatic int parenlev = 0;
  196. X%}
  197. X
  198. X%%
  199. X"/*"            { count(); yylval = gather(COMMENT,yytext);
  200. X                /* T_COMMENT gets changed to T_WS later */
  201. X                return(T_COMMENT); }
  202. X^[ \t]*#        { count(); yylval = gather(CPPLINE,yytext);
  203. X                return(T_CPP); }
  204. X\"            { count(); yylval = gather(STRING,yytext);
  205. X                return(T_STR); }
  206. X
  207. X"auto"            { count(); yylval = 0; return(T_AUTO); }
  208. X"break"            { count(); yylval = 0; return(T_BREAK); }
  209. X"case"            { count(); yylval = 0; return(T_CASE); }
  210. X"char"            { count(); yylval = 0; return(T_CHAR); }
  211. X"const"            { count(); yylval = 0; return(T_CONST); }
  212. X"continue"        { count(); yylval = 0; return(T_CONTINUE); }
  213. X"default"        { count(); yylval = 0; return(T_DEFAULT); }
  214. X"do"            { count(); yylval = 0; return(T_DO); }
  215. X"double"        { count(); yylval = 0; return(T_DOUBLE); }
  216. X"else"            { count(); yylval = 0; return(T_ELSE); }
  217. X"enum"            { count(); yylval = 0; return(T_ENUM); }
  218. X"extern"        { count(); yylval = 0; return(T_EXTERN); }
  219. X"float"            { count(); yylval = 0; return(T_FLOAT); }
  220. X"for"            { count(); yylval = 0; return(T_FOR); }
  221. X"goto"            { count(); yylval = 0; return(T_GOTO); }
  222. X"if"            { count(); yylval = 0; return(T_IF); }
  223. X"inline"        { count(); yylval = 0; return(T_INLINE); }
  224. X"int"            { count(); yylval = 0; return(T_INT); }
  225. X"long"            { count(); yylval = 0; return(T_LONG); }
  226. X"register"        { count(); yylval = 0; return(T_REGISTER); }
  227. X"return"        { count(); yylval = 0; return(T_RETURN); }
  228. X"short"            { count(); yylval = 0; return(T_SHORT); }
  229. X"signed"        { count(); yylval = 0; return(T_SIGNED); }
  230. X"sizeof"        { count(); yylval = 0; return(T_SIZEOF); }
  231. X"static"        { count(); yylval = 0; return(T_STATIC); }
  232. X"struct"        { count(); yylval = 0; return(T_STRUCT); }
  233. X"switch"        { count(); yylval = 0; return(T_SWITCH); }
  234. X"typedef"        { count(); yylval = 0; return(T_TYPEDEF); }
  235. X"union"            { count(); yylval = 0; return(T_UNION); }
  236. X"unsigned"        { count(); yylval = 0; return(T_UNSIGNED); }
  237. X"void"            { count(); yylval = 0; return(T_VOID); }
  238. X"volatile"        { count(); yylval = 0; return(T_VOLATILE); }
  239. X"while"            { count(); yylval = 0; return(T_WHILE); }
  240. X
  241. X{L}({L}|{D})*        { count(); yylval= yytext; return(T_IDENT);
  242. X            /* typedefing is checked in gettok() */ }
  243. X
  244. X"0fnan"            { count(); yylval = yytext; return(T_NUM); }
  245. X"0fNAN"            { count(); yylval = yytext; return(T_NUM); }
  246. X"0finf"            { count(); yylval = yytext; return(T_NUM); }
  247. X"0fINF"            { count(); yylval = yytext; return(T_NUM); }
  248. X
  249. X0[xX]{H}+{LS}?{US}?    { count(); yylval = yytext; return(T_NUM); }
  250. X0[xX]{H}+{US}?{LS}?    { count(); yylval = yytext; return(T_NUM); }
  251. X0{D}+{LS}?{US}?        { count(); yylval = yytext; return(T_NUM); }
  252. X0{D}+{US}?{LS}?        { count(); yylval = yytext; return(T_NUM); }
  253. X{D}+{LS}?{US}?        { count(); yylval = yytext; return(T_NUM); }
  254. X{D}+{US}?{LS}?        { count(); yylval = yytext; return(T_NUM); }
  255. X
  256. X{D}+{E}{LS}?        { count(); yylval = yytext; return(T_NUM); }
  257. X{D}*"."{D}+({E})?{LS}?    { count(); yylval = yytext; return(T_NUM); }
  258. X{D}+"."{D}*({E})?{LS}?    { count(); yylval = yytext; return(T_NUM); }
  259. X
  260. X'(\\.|[^\\'])+'        { count(); yylval = yytext; return(T_CHARCONST); }
  261. X"..."            { count(); yylval = 0; return(T_ELLIPSES); }
  262. X">>="            { count(); yylval = 0; return(T_RS_EQ); }
  263. X"<<="            { count(); yylval = 0; return(T_LS_EQ); }
  264. X"+="            { count(); yylval = 0; return(T_ADD_EQ); }
  265. X"-="            { count(); yylval = 0; return(T_SUB_EQ); }
  266. X"*="            { count(); yylval = 0; return(T_MUL_EQ); }
  267. X"/="            { count(); yylval = 0; return(T_DIV_EQ); }
  268. X"%="            { count(); yylval = 0; return(T_MOD_EQ); }
  269. X"&="            { count(); yylval = 0; return(T_AND_EQ); }
  270. X"^="            { count(); yylval = 0; return(T_XOR_EQ); }
  271. X"|="            { count(); yylval = 0; return(T_OR_EQ); }
  272. X">>"            { count(); yylval = 0; return(T_RS); }
  273. X"<<"            { count(); yylval = 0; return(T_LS); }
  274. X"++"            { count(); yylval = 0; return(T_INC); }
  275. X"--"            { count(); yylval = 0; return(T_DEC); }
  276. X"->"            { count(); yylval = 0; return(T_PTR); }
  277. X"&&"            { count(); yylval = 0; return(T_CAND); }
  278. X"||"            { count(); yylval = 0; return(T_COR); }
  279. X"<="            { count(); yylval = 0; return(T_LE); }
  280. X">="            { count(); yylval = 0; return(T_GE); }
  281. X"=="            { count(); yylval = 0; return(T_CEQ); }
  282. X"!="            { count(); yylval = 0; return(T_NE); }
  283. X";"            { count(); yylval = 0; return(T_SEMIC); }
  284. X"{"            { count(); yylval = 0; bracelev++; return(T_LBRACE); }
  285. X"}"            { count(); yylval = 0; bracelev--; return(T_RBRACE); }
  286. X","            { count(); yylval = 0; return(T_COMMA); }
  287. X":"            { count(); yylval = 0; return(T_COLON); }
  288. X"="            { count(); yylval = 0; return(T_EQ); }
  289. X"("            { count(); yylval = 0; parenlev++; return(T_LPAREN); }
  290. X")"            { count(); yylval = 0; parenlev--; return(T_RPAREN); }
  291. X"["            { count(); yylval = 0; return(T_LSQ); }
  292. X"]"            { count(); yylval = 0; return(T_RSQ); }
  293. X"."            { count(); yylval = 0; return(T_DOT); }
  294. X"&"            { count(); yylval = 0; return(T_AMPER); }
  295. X"!"            { count(); yylval = 0; return(T_NOT); }
  296. X"~"            { count(); yylval = 0; return(T_TILDE); }
  297. X"-"            { count(); yylval = 0; return(T_MINUS); }
  298. X"+"            { count(); yylval = 0; return(T_PLUS); }
  299. X"*"            { count(); yylval = 0; return(T_STAR); }
  300. X"/"            { count(); yylval = 0; return(T_DIV); }
  301. X"%"            { count(); yylval = 0; return(T_MOD); }
  302. X"<"            { count(); yylval = 0; return(T_LT); }
  303. X">"            { count(); yylval = 0; return(T_GT); }
  304. X"^"            { count(); yylval = 0; return(T_XOR); }
  305. X"|"            { count(); yylval = 0; return(T_OR); }
  306. X"?"            { count(); yylval = 0; return(T_QUEST); }
  307. X
  308. X[ \t\v\n\f]*        { count(); yylval = yytext; return(T_WS); }
  309. X.            { /* ignore bad characters */ }
  310. X
  311. X%%
  312. X
  313. Xyywrap()
  314. X{
  315. X    return(1);
  316. X}
  317. X
  318. X/*
  319. X */
  320. X
  321. Xchar *
  322. Xgather(type,init)
  323. Xint type;
  324. Xchar *init;
  325. X{
  326. X    char buf[1024];
  327. X    register char *tbuf;
  328. X    register int tbufsize = 0;
  329. X    register char *bb = buf;
  330. X    register char *p = bb;
  331. X    register char *ebuf = &buf[1023];
  332. X    
  333. X
  334. X    strcpy(buf,init);
  335. X    p = buf + strlen(init);
  336. X    while (*p = input()) {
  337. X        if (*p == 0)
  338. X            break;
  339. X        switch (type) {
  340. X        case COMMENT:
  341. X            if (*p == '/' && p != bb && p[-1] == '*') {
  342. X                goto end;
  343. X            }
  344. X            break;
  345. X        case CPPLINE:
  346. X            if (*p == '\n' && p != bb && p[-1] != '\\') {
  347. X                unput('\n');
  348. X                *p = '\0';
  349. X                goto end;
  350. X            }
  351. X            break;
  352. X        case STRING:
  353. X            if (*p == '"' && p != bb && p[-1] != '\\') {
  354. X                goto end;
  355. X            }
  356. X            break;
  357. X        }
  358. X        if (++p >= ebuf) {
  359. X            *p = '\0';
  360. X            if (tbufsize == 0) {
  361. X                tbufsize = 1024;
  362. X            }
  363. X            tbuf = (char *) malloc(tbufsize *= 2);
  364. X            strcpy(tbuf, bb);
  365. X            p = tbuf + (p - bb);
  366. X            if (bb != buf) {
  367. X                free(bb);
  368. X            }
  369. X            bb = tbuf;
  370. X            ebuf = bb + tbufsize;
  371. X        }
  372. X    }
  373. X    end:
  374. X    *++p = '\0';
  375. X    p++;
  376. X    if (tbufsize == 0) {
  377. X        tbuf = (char *) malloc(p-bb);
  378. X        strcpy(tbuf, bb);
  379. X        bb = tbuf;
  380. X    }
  381. X    return(bb);
  382. X}
  383. X
  384. X#ifdef COUNTCOLUMN
  385. Xvoid
  386. Xcount()
  387. X{
  388. X    int i;
  389. X
  390. X    for (i = 0; yytext[i] != '\0'; i++)
  391. X        if (yytext[i] == '\n') {
  392. X            column = 0;
  393. X            line++;
  394. X        }
  395. X        else if (yytext[i] == '\t')
  396. X            column += 8 - (column % 8);
  397. X        else
  398. X            column++;
  399. X}
  400. X#endif
  401. X
  402. X#ifndef TEST
  403. X
  404. Xcheck_type(tok)
  405. Xregister struct token *tok;
  406. X{
  407. X    register int i;
  408. X    register char **p;
  409. X
  410. X    for (i = 0; (i < NSCOPE) && (typeid[i] != NIL); i++) {
  411. X        for (p = typeid[i]->type_id; *p != NIL; p++) {
  412. X            if (strcmp(tok->t_id,*p) == 0) {
  413. X                tok->t_tok = T_TYPE_ID;
  414. X                return;
  415. X            }
  416. X        }
  417. X    }
  418. X}
  419. X
  420. Xstruct token *
  421. Xgettok(mem)
  422. Xregister int mem;
  423. X{
  424. X    register int t;
  425. X    struct token *tok;
  426. X
  427. X    if ((t = yylex()) == 0)
  428. X        return((struct token *) 0);
  429. X    tok = newtok(mem, t, yylval);
  430. X    tok->t_line = yylineno;
  431. X    switch(t) {
  432. X    case T_COMMENT:
  433. X    case T_CPP:
  434. X        tok->t_tok = T_WS;
  435. X        /*FALLTHROUGH*/
  436. X    case T_STR:
  437. X        free(yylval);
  438. X        break;
  439. X
  440. X    case T_LBRACE:
  441. X        tok->t_level = bracelev-1;
  442. X        tok->t_paren = parenlev;
  443. X        pushscope(bracelev);
  444. X        break;
  445. X    case T_LPAREN:
  446. X        tok->t_paren = parenlev-1;
  447. X        tok->t_level = bracelev;
  448. X        break;
  449. X    case T_RBRACE:
  450. X        popscope(bracelev+1);
  451. X        /*FALLTHROUGH*/
  452. X    default:
  453. X        tok->t_level = bracelev;
  454. X        tok->t_paren = parenlev;
  455. X        break;
  456. X    }
  457. X    if (t == T_IDENT) {
  458. X        check_type(tok);
  459. X    }
  460. X    return(tok);
  461. X}
  462. X#endif
  463. X
  464. X#ifdef TEST
  465. Xmain() {
  466. X    int tok;
  467. X    extern char *tokens[];
  468. X
  469. X    while(tok = yylex()) {
  470. X        switch (tok) {
  471. X        case T_COMMENT:
  472. X        case T_STR:
  473. X        case T_CPP:
  474. X            free(yylval);
  475. X
  476. X        case T_IDENT:
  477. X        case T_WS:
  478. X        case T_NUM:
  479. X        case T_CHARCONST:
  480. X        case T_TYPE_ID:
  481. X            fputs(yylval,stdout);
  482. X            break;
  483. X        case T_ACTUAL:
  484. X            fputs("<ACTUAL>",stdout);
  485. X            break;
  486. X        case T_RETVAL:
  487. X            fputs("<RETVAL>",stdout);
  488. X            break;
  489. X        case T_ARGLIST:
  490. X            fprintf(stdout,"%s(ARGLIST)", yylval);
  491. X            break;
  492. X        case T_RETLAB:
  493. X            fputs("<RETLAB>",stdout);
  494. X            break;
  495. X        case T_FORMAL:
  496. X            fprintf(stdout,"<FORMAL '%s'>",yylval);
  497. X            break;
  498. X        default:
  499. X            if (tok <= T_INLINE)
  500. X                fputs(tokens[tok],stdout);
  501. X            else
  502. X                fputs("???",stdout);
  503. X
  504. X            break;
  505. X        }
  506. X    }
  507. X}
  508. X#endif
  509. \Rogue\Monster\
  510. else
  511.   echo "will not over write ./scan.l"
  512. fi
  513. chmod 444 ./scan.l
  514. if [ `wc -c ./scan.l | awk '{printf $1}'` -ne 8829 ]
  515. then
  516. echo `wc -c ./scan.l | awk '{print "Got " $1 ", Expected " 8829}'`
  517. fi
  518. if `test ! -s ./BUGS`
  519. then
  520. echo "writing ./BUGS"
  521. sed 's/^X//' > ./BUGS << '\Rogue\Monster\'
  522. XFri May  8 17:13:05 PDT 1987
  523. X
  524. XCurrent bugs:
  525. X    - multi-line comments that begin on pre-processor lines are not
  526. X      handled correctly
  527. X
  528. X    - comma operators don't work correctly, e.g.
  529. X        x = (cond, inline_func());
  530. X      (inline_func() gets called too soon) 
  531. X
  532. XImportant enhancements to be added:
  533. X
  534. X    -
  535. X
  536. XMiscellaneous features to be added:
  537. X
  538. X    -
  539. \Rogue\Monster\
  540. else
  541.   echo "will not over write ./BUGS"
  542. fi
  543. chmod 444 ./BUGS
  544. if [ `wc -c ./BUGS | awk '{printf $1}'` -ne 329 ]
  545. then
  546. echo `wc -c ./BUGS | awk '{print "Got " $1 ", Expected " 329}'`
  547. fi
  548. if `test ! -s ./MINVERS`
  549. then
  550. echo "writing ./MINVERS"
  551. sed 's/^X//' > ./MINVERS << '\Rogue\Monster\'
  552. X0
  553. \Rogue\Monster\
  554. else
  555.   echo "will not over write ./MINVERS"
  556. fi
  557. chmod 444 ./MINVERS
  558. if [ `wc -c ./MINVERS | awk '{printf $1}'` -ne 2 ]
  559. then
  560. echo `wc -c ./MINVERS | awk '{print "Got " $1 ", Expected " 2}'`
  561. fi
  562. if `test ! -s ./test.c`
  563. then
  564. echo "writing ./test.c"
  565. sed 's/^X//' > ./test.c << '\Rogue\Monster\'
  566. X
  567. X/* test cases for 'inline' */
  568. X
  569. X/* $Header: test.c,v 1.6 87/06/24 13:06:22 mcg Rel $ */
  570. X
  571. X
  572. X/* simple inline */
  573. Xinline int foo(a,b) {
  574. X    register int x = 0;
  575. X
  576. X    printf("foo(%d, %d)\n", a,b);
  577. X    return(a+b);
  578. X}
  579. Xinline int bar(x,y) {
  580. X    register int a;
  581. X
  582. X    a = 0;
  583. X    printf("bar(%d, %d)\n", x,y);
  584. X    return(x-y);
  585. X}
  586. X/* inline with some control flow */
  587. Xinline biff(a) {
  588. X    while(1) return a;
  589. X}
  590. X
  591. X/* inline with a switch */
  592. Xinline insw(i)
  593. Xint i;
  594. X{
  595. X    switch(i) {
  596. X    case 0:    return('0');
  597. X    case 1: return('1');
  598. X    case 2: return('2');
  599. X    case 3: return('3');
  600. X    case 4: return(foo(i,'0'));
  601. X    case 5: return('5');
  602. X    case 6: return('6');
  603. X    case 7: return(foo(i,'0'));
  604. X    case 8: return('8');
  605. X    case 9: return('9');
  606. X    }
  607. X    return(0);
  608. X}
  609. X
  610. Xtypedef char *cptr;
  611. X
  612. Xinline barf() {
  613. X    printf("!!!\n");
  614. X}
  615. X
  616. X/* inline returning a typedef */
  617. Xinline cptr
  618. Xboff(c,s)
  619. Xchar c;
  620. Xcptr s;
  621. X{
  622. X    s[0] = c;
  623. X    return(&s[1]);
  624. X}
  625. X
  626. X/* inline returning a pointer type */
  627. Xinline char *
  628. Xboff2(c,s)
  629. Xchar c;
  630. Xcptr s;
  631. X{
  632. X    s[0] = c;
  633. X    return(&s[1]);
  634. X}
  635. X
  636. Xstruct str {
  637. X    int a;
  638. X    int b;
  639. X    int c;
  640. X};
  641. X
  642. X/* inline returning a structure */
  643. Xinline struct str bipp(a,b,c)
  644. Xint a, b, c;
  645. X{
  646. X    struct str x;
  647. X
  648. X    x.a = a;
  649. X    x.b = b;
  650. X    x.c = c;
  651. X    return(x);
  652. X}
  653. X
  654. X/* inline returning a structure pointer */
  655. Xinline struct str *bupp(z,a,b,c)
  656. Xregister struct str *z;
  657. Xregister int a,b,c;
  658. X{
  659. X    z->a = a;
  660. X    z->b = b;
  661. X    z->c = c;
  662. X    return(z);
  663. X}
  664. X
  665. Xnil(){}
  666. X
  667. X/* inline returning function pointer */
  668. Xinline int (*fp())()
  669. X{
  670. X    return(nil);
  671. X}
  672. X
  673. Xint effect = 0;
  674. X
  675. Xinline int side_effect(a)
  676. Xint a;
  677. X{
  678. X    int old;
  679. X
  680. X    old = effect;
  681. X    effect = a;
  682. X
  683. X    return(old);
  684. X}
  685. X
  686. X/* should have no effect on arguments */
  687. Xinline int swaparg(a,b)
  688. X{
  689. X    int tmp;
  690. X
  691. X    tmp = a;
  692. X    a = b;
  693. X    b = tmp;
  694. X
  695. X    return(a+b);
  696. X}
  697. X
  698. Xinline struct str modarg(a,b)
  699. Xint a;
  700. Xstruct str b;    /* struct arg */
  701. X{
  702. X    switch(a) {
  703. X    case 0:
  704. X        a = 1;
  705. X        b.a = 1;
  706. X        break;
  707. X    case 1:
  708. X        a >>= 1;
  709. X        a <<= 1;
  710. X        b.a = a;
  711. X        break;
  712. X    case 2:
  713. X        a *= 3;
  714. X        b.a = a;
  715. X        break;
  716. X    }
  717. X    return(b);
  718. X}
  719. X
  720. Xinline hardcase1(a,b)
  721. Xint a,b;
  722. X{
  723. X    { ; }
  724. X    if (a);
  725. X    {{}}
  726. X    if (a) { } else ;
  727. X    return(b);
  728. X}
  729. Xinline char *
  730. Xhardcase2(a,b,c)
  731. Xchar *a;
  732. Xint b,c;
  733. X{
  734. X    char *s = "foo", c = 'c';
  735. X    int x = b;
  736. X
  737. X    if (a) return(s);
  738. X    else {
  739. X        if (b) return(a+c);
  740. X    }
  741. X    return(a+c);
  742. X}
  743. X
  744. Xinline expr1(a,b)
  745. Xint a,b;
  746. X{
  747. X    int x = 0;
  748. X
  749. X    if (foo(0,a+b) == 100) return x+2;    /* a+b == 100, ret = 2 */
  750. X    if (foo(50,50) == 100 && a) return x;    /* a != 0, return = 0 */
  751. X    if (foo(100,0) == 100 && b) return x+1;    /* a == 0 && b != 0, ret = 1 */
  752. X    return x+3;                /* ret = 3 */
  753. X}
  754. X
  755. Xinline expr2(a,b)
  756. Xint a,b;
  757. X{
  758. X    register int x = 0, y = 1;
  759. X
  760. X    if (a) {
  761. X        return(x+y);    /* a != 0, return = 1 */
  762. X    } else {
  763. X        register int x = 100, y = 101;
  764. X
  765. X        if (b) {
  766. X            return(x+y);    /* a == 0 && b != 0, return = 201 */
  767. X        } else {
  768. X            register int x = 200, y = 300;
  769. X
  770. X            return(x+y);    /* a == 0 && b == 0, return = 500 */
  771. X        }
  772. X    }
  773. X}
  774. X
  775. Xinline labs(i)
  776. Xint i;
  777. X{
  778. X    if (i == 1) goto L1;
  779. X    if (i == 2) goto L2;
  780. X    if (i == 3) goto L3;
  781. X    if (i == 4) goto L4;
  782. X    goto L5;
  783. XL6:
  784. X    return(i);
  785. X
  786. XL1:    i++; return(1);
  787. XL2:    if (i == 2) return(2);
  788. XL3:    return(3);
  789. XL4:    {
  790. X    return(4);
  791. X    }
  792. XL5:    goto L6;
  793. X}
  794. X
  795. Xm() {
  796. X    register int x,y,z;
  797. X
  798. X    x = foo(x++,y++);
  799. X}
  800. X
  801. Xmain() {
  802. X    t1(1);
  803. X    t2(2);
  804. X    t3(3);
  805. X    t4(4);
  806. X    t5(5);
  807. X    t6(6);
  808. X    t7(7);
  809. X    t8(8);
  810. X    t9(9);
  811. X    t10(10);
  812. X    t11(11);
  813. X    t12(12);
  814. X    t13(13);
  815. X    t14(14);
  816. X    t15(15,50);
  817. X    t16(16);
  818. X    t17(17);
  819. X    t18(18);
  820. X    return(0);
  821. X}
  822. X
  823. X/*
  824. X * basic expansion of single inline
  825. X */
  826. X
  827. Xt1(i)
  828. Xint i;
  829. X{
  830. X    int a;
  831. X
  832. X    printf("test%d:\n",i);
  833. X    a = foo(1,2);
  834. X    if (a == 3) {
  835. X        printf("test%d ok\n",i);
  836. X    } else {
  837. X        printf("test%d FAIL\n",i);
  838. X    }
  839. X}
  840. X
  841. X/*
  842. X * expansion of multiple inlines in single expression
  843. X */
  844. X
  845. Xt2(i)
  846. Xint i;
  847. X{
  848. X    int a;
  849. X
  850. X    printf("test%d:\n",i);
  851. X    a = foo(1,2) + foo(3,4);
  852. X    if (a == 10) {
  853. X        printf("test%d ok\n",i);
  854. X    } else {
  855. X        printf("test%d FAIL\n",i);
  856. X    }
  857. X}
  858. X
  859. X/*
  860. X * expansion of inlines in various styles of if() statement
  861. X * - check parsing of if compound statement
  862. X */
  863. X
  864. Xt3(i)
  865. Xint i;
  866. X{
  867. X    printf("test%d:\n",i);
  868. X    if (foo(1,2) != 3) {
  869. X        printf("test%d FAIL\n",i); 
  870. X        return;
  871. X    }
  872. X
  873. X    if (foo(1,2) == 3) {
  874. X        ;
  875. X    } else {
  876. X        printf("test%d FAIL\n"); 
  877. X        return;
  878. X    }
  879. X
  880. X    if (!foo(1,2)) printf("test%d FAIL\n",i);
  881. X
  882. X    if (foo(1,2) == 3) nil(); else printf("test%d FAIL\n",i);
  883. X
  884. X    if (foo(1,2) == 3) nil(); else {
  885. X        printf("test%d FAIL\n",i);
  886. X    }
  887. X
  888. X    if (foo(1,2) == 3) {
  889. X        printf("test%d ok\n",i);
  890. X    } else
  891. X        printf("test%d FAIL\n",i);
  892. X}
  893. X
  894. X/*
  895. X * inlines as arguments to other inlines
  896. X */
  897. X
  898. Xt4(i)
  899. Xint i;
  900. X{
  901. X    register int a;
  902. X
  903. X    printf("test%d:\n",i);
  904. X    a = foo(foo(1,2),2);
  905. X    if (a != 5) {
  906. X        printf("test%d FAIL\n",i);
  907. X    }
  908. X
  909. X    a = foo(100,bar(5,4));
  910. X    if (a != 101) {
  911. X        printf("test%d FAIL\n",i);
  912. X    }
  913. X    printf("test%d ok\n",i);
  914. X}
  915. X
  916. X/*
  917. X */
  918. X
  919. Xt5(j)
  920. Xint j;
  921. X{
  922. X    register int i;
  923. X    for(i=0; i < 10; i++) {
  924. X        switch(insw(i)) {
  925. X        case '0':
  926. X            if (foo(i,i) != 0) break;
  927. X            if (i != 0) break;
  928. X            continue;
  929. X        case '1':
  930. X            if (i != 1) break;
  931. X            if (foo(i,i) != 2) break;
  932. X            continue;
  933. X        case '2':
  934. X            if (foo(i,i) != 4) break;
  935. X            if (i != 2) break;
  936. X            continue;
  937. X        case '3':
  938. X            if (foo(i,i) != 6) break;
  939. X            if (i != 3) break;
  940. X            continue;
  941. X        case '4':
  942. X            if (i != 4) break;
  943. X            if (foo(i,i) != 8) break;
  944. X            continue;
  945. X        case '5':
  946. X            if (foo(i,i) != 10) break;
  947. X            if (i != 5) break;
  948. X            continue;
  949. X        case '6':
  950. X            if (foo(i,i) != 12) break;
  951. X            if (i != 6) break;
  952. X            continue;
  953. X        case '7':
  954. X            if (i != 7) break;
  955. X            if (foo(i,i) != 14) break;
  956. X            continue;
  957. X        case '8':
  958. X            if (foo(i,i) != 16) break;
  959. X            if (i != 8) break;
  960. X            continue;
  961. X        case '9':
  962. X            if (i != 9) break;
  963. X            continue;
  964. X        }
  965. X        printf("test5 FAIL\n");
  966. X        return;
  967. X    }
  968. X    printf("test5 ok\n");
  969. X}
  970. X
  971. X/*
  972. X * inlines with typedefs and pointer return types
  973. X */
  974. X
  975. Xt6(i)
  976. Xint i;
  977. X{
  978. X    char buf[20];
  979. X    cptr p;
  980. X
  981. X    p = boff('c',buf);
  982. X    if (p != &buf[1] || buf[0] != 'c') {
  983. X        printf("test6 FAIL\n");
  984. X    }
  985. X    p = boff('b',p);
  986. X    if (p != &buf[2] || buf[1] != 'b') {
  987. X        printf("test6 FAIL\n");
  988. X    }
  989. X    p = boff2('d',buf);
  990. X    if (p != &buf[1] || buf[0] != 'd') {
  991. X        printf("test6 FAIL\n");
  992. X    }
  993. X    p = boff2('e',p);
  994. X    if (p != &buf[2] || buf[1] != 'e') {
  995. X        printf("test6 FAIL\n");
  996. X    }
  997. X    printf("test6 ok\n");
  998. X}
  999. X
  1000. X/*
  1001. X * inlines with looping structures inside
  1002. X */
  1003. X
  1004. Xt7(i)
  1005. Xint i;
  1006. X{
  1007. X    if (biff(1) != 1) {
  1008. X        printf("test7 FAIL\n");
  1009. X    }
  1010. X    if (1) biff(1);
  1011. X    if (1) nil();
  1012. X    else printf("test7 FAIL\n");
  1013. X    printf("test7 ok\n");
  1014. X}
  1015. X
  1016. Xt8(i)
  1017. Xint i;
  1018. X{
  1019. X    if (fp() != nil) {
  1020. X        printf("test8 FAIL\n");
  1021. X        return;
  1022. X    }
  1023. X    printf("test8 ok\n");
  1024. X}
  1025. X
  1026. X/*
  1027. X * inlines with structure and structure pointer returns
  1028. X */
  1029. X
  1030. Xt9(j)
  1031. Xint j;
  1032. X{
  1033. X    struct str z;
  1034. X    struct str *zp, *zp2;
  1035. X    int i;
  1036. X
  1037. X    z = bipp(1,100,3000);
  1038. X    if ((z.a != 1) || (z.b != 100) || (z.c != 3000)) {
  1039. X        printf("test9 FAIL\n");
  1040. X        return;
  1041. X    }
  1042. X    z = bipp(foo(100,bar(5,4)), z.c, z.b);
  1043. X    if ((z.a != 101) || (z.b != 3000) || (z.c != 100)) {
  1044. X        printf("test9 FAIL\n");
  1045. X        return;
  1046. X    }
  1047. X/****************
  1048. X    i = bipp(1,2,3).a;
  1049. X    if (i != 1) {
  1050. X        printf("test9 FAIL\n");
  1051. X        return;
  1052. X    }
  1053. X*************/
  1054. X    zp = &z;
  1055. X    i = bupp(&z,1,2,3)->a;
  1056. X    if (i != 1) {
  1057. X        printf("test9 FAIL\n");
  1058. X        return;
  1059. X    }
  1060. X    if (zp != bupp(zp,1,2,3)) {
  1061. X        printf("test9 FAIL\n");
  1062. X        return;
  1063. X    }
  1064. X    printf("test 9 ok\n");
  1065. X}
  1066. X
  1067. X
  1068. X/* special syntax check for function pointer returns */
  1069. X
  1070. X/* declare fp as function returning pointer to function returning int */
  1071. Xint (*fp3())() { return nil; }
  1072. X
  1073. X/* declare fp as function returning pointer to function returning int */
  1074. Xinline int (*fp2())() { return nil; }
  1075. X
  1076. X/* declare fp as function returning pointer to function returning pointer
  1077. X * to function returning int */
  1078. Xinline int (*(*fp1())())() { return fp3; }
  1079. X
  1080. X
  1081. Xfpt1() {
  1082. X
  1083. X/* declare fp as pointer to function returning pointer to function
  1084. X * returning int
  1085. X */
  1086. X    int (*(*fx)())();
  1087. X 
  1088. X    fx = fp1();
  1089. X}
  1090. X
  1091. X/***/
  1092. X
  1093. X/* declare fp as pointer to function returning int */
  1094. Xfpt2() {
  1095. X
  1096. X    int (*fx)();
  1097. X
  1098. X    fx = fp2();
  1099. X}
  1100. X
  1101. X/* check expression rewriting cases */
  1102. X
  1103. Xt10(n)
  1104. Xint n;
  1105. X{
  1106. X    int i = 0;
  1107. X    int j;
  1108. X
  1109. X    while (i < foo(5,5)) {
  1110. X        if (i < 0 || i > 10) {
  1111. X            printf("test10 FAIL\n");
  1112. X            return;
  1113. X        }
  1114. X        i = foo(i,1);
  1115. X        j = foo(1,2);
  1116. X        if (j != 3) {
  1117. X            printf("test10 FAIL\n");
  1118. X            return;
  1119. X        }
  1120. X    }
  1121. X
  1122. X    for (i = foo(5,5); i > 0; i--) {
  1123. X        if (i < 0 || i > 10) {
  1124. X            printf("test10 FAIL\n");
  1125. X            return;
  1126. X        }
  1127. X        j = foo(1,2);
  1128. X        if (j != 3) {
  1129. X            printf("test10 FAIL\n");
  1130. X            return;
  1131. X        }
  1132. X    }
  1133. X    printf("test10 ok\n");
  1134. X}
  1135. X
  1136. X/*
  1137. X * side-effect tests
  1138. X */
  1139. X
  1140. Xt11(n)
  1141. Xint n;
  1142. X{
  1143. X    register int i;
  1144. X
  1145. X    effect = 0;
  1146. X
  1147. X    if (effect == 1 && (side_effect(1) == 0)) {
  1148. X        printf("test11 FAIL\n");
  1149. X        return;
  1150. X    }
  1151. X
  1152. X    /* effect should still be 0 */
  1153. X
  1154. X    if (effect == 0 || (side_effect(1) == 1)) {
  1155. X        nil();
  1156. X    }
  1157. X
  1158. X    /* effect should still be 0 */
  1159. X
  1160. X    if (effect != 0) {
  1161. X        printf("test11 FAIL\n");
  1162. X        return;
  1163. X    }
  1164. X
  1165. X    i = (side_effect(1) ? 100 : 200);    /* assert i == 200 */
  1166. X                        /* assert effect == 1 */
  1167. X
  1168. X    if (i != 200) {
  1169. X        printf("test11 FAIL\n");
  1170. X        return;
  1171. X    }
  1172. X
  1173. X    /* a non-expansion case */
  1174. X    i = (effect ? side_effect(100) : side_effect(200));
  1175. X                        /* assert i == 1 */
  1176. X
  1177. X    if (i != 1) {
  1178. X        printf("test11 FAIL\n");
  1179. X        return;
  1180. X    }
  1181. X
  1182. X    if (effect != 100) {
  1183. X        printf("test11 FAIL\n");
  1184. X        return;
  1185. X    }
  1186. X
  1187. X    /* should have a comma-operator test, but it breaks now */
  1188. X
  1189. X    printf("test11 ok\n");
  1190. X}
  1191. X
  1192. X/*
  1193. X * more side-effect tests
  1194. X */
  1195. X
  1196. Xt12(n)
  1197. Xint n;
  1198. X{
  1199. X    int i,j,k,l;
  1200. X    struct str b;
  1201. X
  1202. X    /* might cause syntax errors, might return wrong value */
  1203. X    i = swaparg(1,2);
  1204. X    if (i != 3) {
  1205. X        printf("test12 FAIL\n");
  1206. X        return;
  1207. X    }
  1208. X    i = 100;
  1209. X    j = 200;
  1210. X    if (swaparg(i,j) != 300 || i != 100 || j != 200) {
  1211. X        printf("test12 FAIL\n");
  1212. X        return;
  1213. X    }
  1214. X    for (i = 0;  i < 3; i++) {
  1215. X        j = i;
  1216. X        b = modarg(i,b);
  1217. X        if (i != j) {
  1218. X            printf("test12 FAIL\n");
  1219. X            return;
  1220. X        }
  1221. X        if (i == 2) {
  1222. X            if (b.a != 6 || j != 2) {
  1223. X                printf("test12 FAIL\n");
  1224. X                return;
  1225. X            } 
  1226. X        }
  1227. X    }
  1228. X    printf("test12 ok\n");
  1229. X}
  1230. X
  1231. Xt13(n)
  1232. Xint n;
  1233. X{
  1234. X    register int i,j,k;
  1235. X
  1236. X    for (i = 0; i < 5; i++) {
  1237. X        if (i == 1) goto i2;
  1238. X         i1:
  1239. X        j = foo(i,100);
  1240. X        if (i == 2) {
  1241. X         i2:    k = foo(i,200);
  1242. X            if (i > 1 && j != i+100) { printf("test 13 FAIL\n"); return;}
  1243. X            goto i4;
  1244. X        }
  1245. X        if (i == 3) {
  1246. X            foo(i,300);
  1247. X         i3 /* comment */ :
  1248. X            if (j != i+100) { printf("test 13 FAIL\n"); return;}
  1249. X            continue;
  1250. X        }
  1251. X        if (i == 4) {
  1252. X            if (j != i+100) { printf("test 13 FAIL\n"); return;}
  1253. X            k = foo(i,400);
  1254. X         i4:
  1255. X            if (i == 2 && k != 202) { printf("test 13 FAIL\n"); return; }
  1256. X            if (i == 4 && k != 404) { printf("test 13 FAIL\n"); return; }
  1257. X            k = foo(i,500);
  1258. X            continue;
  1259. X        }
  1260. X        k = foo(i,600);
  1261. X        j = 0;
  1262. X    }
  1263. X    printf("test13 ok\n");
  1264. X}
  1265. X
  1266. Xint var = 0;
  1267. X
  1268. Xinline evar() {
  1269. X    return(var);
  1270. X}
  1271. X
  1272. Xinline mvar(x) {
  1273. X    var = x;
  1274. X}
  1275. X 
  1276. Xt14(n)
  1277. Xint n;
  1278. X{
  1279. X    int var = 1;    /* hide outer def'n */
  1280. X
  1281. X    if (evar() != 0) { printf("test14 FAIL\n"); return;}
  1282. X    if (var != 1) { printf("test14 FAIL\n"); return;}
  1283. X    mvar(100);
  1284. X    if (var != 1) { printf("test14 FAIL\n"); return;}
  1285. X    if (evar() != 100) { printf("test14 FAIL\n"); return;}
  1286. X    printf("test14 ok\n");
  1287. X}
  1288. X
  1289. Xt15(i,var)
  1290. Xint i;
  1291. Xint var;
  1292. X{
  1293. X    int a,b,c;
  1294. X
  1295. X    mvar(-100);
  1296. X
  1297. X    a = 1;
  1298. X    b = 2;
  1299. X    c = 3;
  1300. X
  1301. X    {
  1302. X        int a,b;
  1303. X
  1304. X        a = 100;
  1305. X        b = 200;
  1306. X
  1307. X        c = foo(a,b);
  1308. X    }
  1309. X
  1310. X    if (a != 1 || b != 2 || c != 300) { printf("test15 FAIL\n"); return; }
  1311. X
  1312. X    c = var;
  1313. X    {
  1314. X        int var;
  1315. X
  1316. X        var = 1000;
  1317. X
  1318. X        {
  1319. X            cptr var, a, b, c;
  1320. X    
  1321. X            a = "-1";
  1322. X            b = "-2";
  1323. X            c = "-3";
  1324. X            var = "-4";
  1325. X            if (evar() != -100) { printf("test15 FAIL\n"); return;}
  1326. X        }
  1327. X
  1328. X        if (evar() != -100) { printf("test15 FAIL\n"); return;}
  1329. X    }
  1330. X    if (var != c) { printf("test15 FAIL\n"); return; }
  1331. X    if (evar() != -100) { printf("test15 FAIL\n"); return;}
  1332. X    printf("test15 ok\n");
  1333. X}
  1334. X
  1335. Xt16(n)
  1336. Xint n;
  1337. X{
  1338. X    char *s = "foo";
  1339. X
  1340. X    if (hardcase1(0,1) != 1) { printf("test16 FAIL\n"); return;}
  1341. X    while (1 && (hardcase1(0,1) != 1)) printf("test16 FAIL\n");
  1342. X    s = hardcase2("foo",1,0);
  1343. X    printf("test16 ok\n");
  1344. X}
  1345. X
  1346. Xt17(n)
  1347. Xint n;
  1348. X{
  1349. X    int x = 1;
  1350. X
  1351. X    if (x && expr1(1,0) != 0) {printf("test17 FAIL(1)\n"); return;}
  1352. X    if (x && expr1(0,1) != 1) {printf("test17 FAIL(2)\n"); return;}
  1353. X    if (x && expr1(0,100) != 2) {printf("test17 FAIL(3)\n"); return;}
  1354. X    if (x && expr1(0,0) != 3) {printf("test17 FAIL(4)\n"); return;}
  1355. X    if (x && expr2(1,0) != 1) {printf("test17 FAIL(5)\n"); return;}
  1356. X    if (x && expr2(0,1) != 201) {printf("test17 FAIL(6)\n"); return;}
  1357. X    if (x && expr2(0,0) != 500) {printf("test17 FAIL(7)\n"); return;}
  1358. X    printf("test17 ok\n");
  1359. X}
  1360. X
  1361. Xt18(n)
  1362. Xint n;
  1363. X{
  1364. X    int i,j;
  1365. X
  1366. X    i = 0;
  1367. XL1:
  1368. X    j = labs(i);
  1369. X    if (j != i) {printf("test18 FAIL\n"); return; }
  1370. X    i++;
  1371. X    if (i > 10) goto L2;
  1372. X    goto L1;
  1373. XL2:
  1374. X    printf("test18 ok\n");
  1375. X}
  1376. X
  1377. \Rogue\Monster\
  1378. else
  1379.   echo "will not over write ./test.c"
  1380. fi
  1381. chmod 444 ./test.c
  1382. if [ `wc -c ./test.c | awk '{printf $1}'` -ne 11843 ]
  1383. then
  1384. echo `wc -c ./test.c | awk '{print "Got " $1 ", Expected " 11843}'`
  1385. fi
  1386. if `test ! -s ./test2.c`
  1387. then
  1388. echo "writing ./test2.c"
  1389. sed 's/^X//' > ./test2.c << '\Rogue\Monster\'
  1390. X
  1391. X/* test cases for 'inline' */
  1392. X
  1393. X/* $Header: test2.c,v 1.2 87/06/24 13:06:48 mcg Rel $ */
  1394. X
  1395. X
  1396. Xm() {
  1397. X    register int x,y,z;
  1398. X
  1399. X    x = foo(x++,y++);
  1400. X}
  1401. X
  1402. Xmain() {
  1403. X    t1(1);
  1404. X    t2(2);
  1405. X    t3(3);
  1406. X    t4(4);
  1407. X    t5(5);
  1408. X    t6(6);
  1409. X    t7(7);
  1410. X    t8(8);
  1411. X    t9(9);
  1412. X    t10(10);
  1413. X    t11(11);
  1414. X    t12(12);
  1415. X    t13(13);
  1416. X    t14(14);
  1417. X    t15(15,50);
  1418. X    t16(16);
  1419. X    t17(17);
  1420. X    t18(18);
  1421. X    return(0);
  1422. X}
  1423. X
  1424. X/*
  1425. X * basic expansion of single inline
  1426. X */
  1427. X
  1428. Xt1(i)
  1429. Xint i;
  1430. X{
  1431. X    int a;
  1432. X
  1433. X    printf("test%d:\n",i);
  1434. X    a = foo(1,2);
  1435. X    if (a == 3) {
  1436. X        printf("test%d ok\n",i);
  1437. X    } else {
  1438. X        printf("test%d FAIL\n",i);
  1439. X    }
  1440. X}
  1441. X
  1442. X/*
  1443. X * expansion of multiple inlines in single expression
  1444. X */
  1445. X
  1446. Xt2(i)
  1447. Xint i;
  1448. X{
  1449. X    int a;
  1450. X
  1451. X    printf("test%d:\n",i);
  1452. X    a = foo(1,2) + foo(3,4);
  1453. X    if (a == 10) {
  1454. X        printf("test%d ok\n",i);
  1455. X    } else {
  1456. X        printf("test%d FAIL\n",i);
  1457. X    }
  1458. X}
  1459. X
  1460. X/*
  1461. X * expansion of inlines in various styles of if() statement
  1462. X * - check parsing of if compound statement
  1463. X */
  1464. X
  1465. Xt3(i)
  1466. Xint i;
  1467. X{
  1468. X    printf("test%d:\n",i);
  1469. X    if (foo(1,2) != 3) {
  1470. X        printf("test%d FAIL\n",i); 
  1471. X        return;
  1472. X    }
  1473. X
  1474. X    if (foo(1,2) == 3) {
  1475. X        ;
  1476. X    } else {
  1477. X        printf("test%d FAIL\n"); 
  1478. X        return;
  1479. X    }
  1480. X
  1481. X    if (!foo(1,2)) printf("test%d FAIL\n",i);
  1482. X
  1483. X    if (foo(1,2) == 3) nil(); else printf("test%d FAIL\n",i);
  1484. X
  1485. X    if (foo(1,2) == 3) nil(); else {
  1486. X        printf("test%d FAIL\n",i);
  1487. X    }
  1488. X
  1489. X    if (foo(1,2) == 3) {
  1490. X        printf("test%d ok\n",i);
  1491. X    } else
  1492. X        printf("test%d FAIL\n",i);
  1493. X}
  1494. X
  1495. X/*
  1496. X * inlines as arguments to other inlines
  1497. X */
  1498. X
  1499. Xt4(i)
  1500. Xint i;
  1501. X{
  1502. X    register int a;
  1503. X
  1504. X    printf("test%d:\n",i);
  1505. X    a = foo(foo(1,2),2);
  1506. X    if (a != 5) {
  1507. X        printf("test%d FAIL\n",i);
  1508. X    }
  1509. X
  1510. X    a = foo(100,bar(5,4));
  1511. X    if (a != 101) {
  1512. X        printf("test%d FAIL\n",i);
  1513. X    }
  1514. X    printf("test%d ok\n",i);
  1515. X}
  1516. X
  1517. X/*
  1518. X */
  1519. X
  1520. Xt5(j)
  1521. Xint j;
  1522. X{
  1523. X    register int i;
  1524. X    for(i=0; i < 10; i++) {
  1525. X        switch(insw(i)) {
  1526. X        case '0':
  1527. X            if (foo(i,i) != 0) break;
  1528. X            if (i != 0) break;
  1529. X            continue;
  1530. X        case '1':
  1531. X            if (i != 1) break;
  1532. X            if (foo(i,i) != 2) break;
  1533. X            continue;
  1534. X        case '2':
  1535. X            if (foo(i,i) != 4) break;
  1536. X            if (i != 2) break;
  1537. X            continue;
  1538. X        case '3':
  1539. X            if (foo(i,i) != 6) break;
  1540. X            if (i != 3) break;
  1541. X            continue;
  1542. X        case '4':
  1543. X            if (i != 4) break;
  1544. X            if (foo(i,i) != 8) break;
  1545. X            continue;
  1546. X        case '5':
  1547. X            if (foo(i,i) != 10) break;
  1548. X            if (i != 5) break;
  1549. X            continue;
  1550. X        case '6':
  1551. X            if (foo(i,i) != 12) break;
  1552. X            if (i != 6) break;
  1553. X            continue;
  1554. X        case '7':
  1555. X            if (i != 7) break;
  1556. X            if (foo(i,i) != 14) break;
  1557. X            continue;
  1558. X        case '8':
  1559. X            if (foo(i,i) != 16) break;
  1560. X            if (i != 8) break;
  1561. X            continue;
  1562. X        case '9':
  1563. X            if (i != 9) break;
  1564. X            continue;
  1565. X        }
  1566. X        printf("test5 FAIL\n");
  1567. X        return;
  1568. X    }
  1569. X    printf("test5 ok\n");
  1570. X}
  1571. X
  1572. X/*
  1573. X * inlines with typedefs and pointer return types
  1574. X */
  1575. X
  1576. Xt6(i)
  1577. Xint i;
  1578. X{
  1579. X    char buf[20];
  1580. X    cptr p;
  1581. X
  1582. X    p = boff('c',buf);
  1583. X    if (p != &buf[1] || buf[0] != 'c') {
  1584. X        printf("test6 FAIL\n");
  1585. X    }
  1586. X    p = boff('b',p);
  1587. X    if (p != &buf[2] || buf[1] != 'b') {
  1588. X        printf("test6 FAIL\n");
  1589. X    }
  1590. X    p = boff2('d',buf);
  1591. X    if (p != &buf[1] || buf[0] != 'd') {
  1592. X        printf("test6 FAIL\n");
  1593. X    }
  1594. X    p = boff2('e',p);
  1595. X    if (p != &buf[2] || buf[1] != 'e') {
  1596. X        printf("test6 FAIL\n");
  1597. X    }
  1598. X    printf("test6 ok\n");
  1599. X}
  1600. X
  1601. X/*
  1602. X * inlines with looping structures inside
  1603. X */
  1604. X
  1605. Xt7(i)
  1606. Xint i;
  1607. X{
  1608. X    if (biff(1) != 1) {
  1609. X        printf("test7 FAIL\n");
  1610. X    }
  1611. X    if (1) biff(1);
  1612. X    if (1) nil();
  1613. X    else printf("test7 FAIL\n");
  1614. X    printf("test7 ok\n");
  1615. X}
  1616. X
  1617. Xt8(i)
  1618. Xint i;
  1619. X{
  1620. X    if (fp() != nil) {
  1621. X        printf("test8 FAIL\n");
  1622. X        return;
  1623. X    }
  1624. X    printf("test8 ok\n");
  1625. X}
  1626. X
  1627. X/*
  1628. X * inlines with structure and structure pointer returns
  1629. X */
  1630. X
  1631. Xt9(j)
  1632. Xint j;
  1633. X{
  1634. X    struct str z;
  1635. X    struct str *zp, *zp2;
  1636. X    int i;
  1637. X
  1638. X    z = bipp(1,100,3000);
  1639. X    if ((z.a != 1) || (z.b != 100) || (z.c != 3000)) {
  1640. X        printf("test9 FAIL\n");
  1641. X        return;
  1642. X    }
  1643. X    z = bipp(foo(100,bar(5,4)), z.c, z.b);
  1644. X    if ((z.a != 101) || (z.b != 3000) || (z.c != 100)) {
  1645. X        printf("test9 FAIL\n");
  1646. X        return;
  1647. X    }
  1648. X/****************
  1649. X    i = bipp(1,2,3).a;
  1650. X    if (i != 1) {
  1651. X        printf("test9 FAIL\n");
  1652. X        return;
  1653. X    }
  1654. X*************/
  1655. X    zp = &z;
  1656. X    i = bupp(&z,1,2,3)->a;
  1657. X    if (i != 1) {
  1658. X        printf("test9 FAIL\n");
  1659. X        return;
  1660. X    }
  1661. X    if (zp != bupp(zp,1,2,3)) {
  1662. X        printf("test9 FAIL\n");
  1663. X        return;
  1664. X    }
  1665. X    printf("test 9 ok\n");
  1666. X}
  1667. X
  1668. X
  1669. X/* special syntax check for function pointer returns */
  1670. X
  1671. X/* declare fp as function returning pointer to function returning int */
  1672. Xint (*fp3())() { return nil; }
  1673. X
  1674. X/* declare fp as function returning pointer to function returning int */
  1675. Xinline int (*fp2())() { return nil; }
  1676. X
  1677. X/* declare fp as function returning pointer to function returning pointer
  1678. X * to function returning int */
  1679. Xinline int (*(*fp1())())() { return fp3; }
  1680. X
  1681. X
  1682. Xfpt1() {
  1683. X
  1684. X/* declare fp as pointer to function returning pointer to function
  1685. X * returning int
  1686. X */
  1687. X    int (*(*fx)())();
  1688. X 
  1689. X    fx = fp1();
  1690. X}
  1691. X
  1692. X/***/
  1693. X
  1694. X/* declare fp as pointer to function returning int */
  1695. Xfpt2() {
  1696. X
  1697. X    int (*fx)();
  1698. X
  1699. X    fx = fp2();
  1700. X}
  1701. X
  1702. X/* check expression rewriting cases */
  1703. X
  1704. Xt10(n)
  1705. Xint n;
  1706. X{
  1707. X    int i = 0;
  1708. X    int j;
  1709. X
  1710. X    while (i < foo(5,5)) {
  1711. X        if (i < 0 || i > 10) {
  1712. X            printf("test10 FAIL\n");
  1713. X            return;
  1714. X        }
  1715. X        i = foo(i,1);
  1716. X        j = foo(1,2);
  1717. X        if (j != 3) {
  1718. X            printf("test10 FAIL\n");
  1719. X            return;
  1720. X        }
  1721. X    }
  1722. X
  1723. X    for (i = foo(5,5); i > 0; i--) {
  1724. X        if (i < 0 || i > 10) {
  1725. X            printf("test10 FAIL\n");
  1726. X            return;
  1727. X        }
  1728. X        j = foo(1,2);
  1729. X        if (j != 3) {
  1730. X            printf("test10 FAIL\n");
  1731. X            return;
  1732. X        }
  1733. X    }
  1734. X    printf("test10 ok\n");
  1735. X}
  1736. X
  1737. X/*
  1738. X * side-effect tests
  1739. X */
  1740. X
  1741. Xt11(n)
  1742. Xint n;
  1743. X{
  1744. X    register int i;
  1745. X
  1746. X    effect = 0;
  1747. X
  1748. X    if (effect == 1 && (side_effect(1) == 0)) {
  1749. X        printf("test11 FAIL\n");
  1750. X        return;
  1751. X    }
  1752. X
  1753. X    /* effect should still be 0 */
  1754. X
  1755. X    if (effect == 0 || (side_effect(1) == 1)) {
  1756. X        nil();
  1757. X    }
  1758. X
  1759. X    /* effect should still be 0 */
  1760. X
  1761. X    if (effect != 0) {
  1762. X        printf("test11 FAIL\n");
  1763. X        return;
  1764. X    }
  1765. X
  1766. X    i = (side_effect(1) ? 100 : 200);    /* assert i == 200 */
  1767. X                        /* assert effect == 1 */
  1768. X
  1769. X    if (i != 200) {
  1770. X        printf("test11 FAIL\n");
  1771. X        return;
  1772. X    }
  1773. X
  1774. X    /* a non-expansion case */
  1775. X    i = (effect ? side_effect(100) : side_effect(200));
  1776. X                        /* assert i == 1 */
  1777. X
  1778. X    if (i != 1) {
  1779. X        printf("test11 FAIL\n");
  1780. X        return;
  1781. X    }
  1782. X
  1783. X    if (effect != 100) {
  1784. X        printf("test11 FAIL\n");
  1785. X        return;
  1786. X    }
  1787. X
  1788. X    /* should have a comma-operator test, but it breaks now */
  1789. X
  1790. X    printf("test11 ok\n");
  1791. X}
  1792. X
  1793. X/*
  1794. X * more side-effect tests
  1795. X */
  1796. X
  1797. Xt12(n)
  1798. Xint n;
  1799. X{
  1800. X    int i,j,k,l;
  1801. X    struct str b;
  1802. X
  1803. X    /* might cause syntax errors, might return wrong value */
  1804. X    i = swaparg(1,2);
  1805. X    if (i != 3) {
  1806. X        printf("test12 FAIL\n");
  1807. X        return;
  1808. X    }
  1809. X    i = 100;
  1810. X    j = 200;
  1811. X    if (swaparg(i,j) != 300 || i != 100 || j != 200) {
  1812. X        printf("test12 FAIL\n");
  1813. X        return;
  1814. X    }
  1815. X    for (i = 0;  i < 3; i++) {
  1816. X        j = i;
  1817. X        b = modarg(i,b);
  1818. X        if (i != j) {
  1819. X            printf("test12 FAIL\n");
  1820. X            return;
  1821. X        }
  1822. X        if (i == 2) {
  1823. X            if (b.a != 6 || j != 2) {
  1824. X                printf("test12 FAIL\n");
  1825. X                return;
  1826. X            } 
  1827. X        }
  1828. X    }
  1829. X    printf("test12 ok\n");
  1830. X}
  1831. X
  1832. Xt13(n)
  1833. Xint n;
  1834. X{
  1835. X    register int i,j,k;
  1836. X
  1837. X    for (i = 0; i < 5; i++) {
  1838. X        if (i == 1) goto i2;
  1839. X         i1:
  1840. X        j = foo(i,100);
  1841. X        if (i == 2) {
  1842. X         i2:    k = foo(i,200);
  1843. X            if (i > 1 && j != i+100) { printf("test 13 FAIL\n"); return;}
  1844. X            goto i4;
  1845. X        }
  1846. X        if (i == 3) {
  1847. X            foo(i,300);
  1848. X         i3 /* comment */ :
  1849. X            if (j != i+100) { printf("test 13 FAIL\n"); return;}
  1850. X            continue;
  1851. X        }
  1852. X        if (i == 4) {
  1853. X            if (j != i+100) { printf("test 13 FAIL\n"); return;}
  1854. X            k = foo(i,400);
  1855. X         i4:
  1856. X            if (i == 2 && k != 202) { printf("test 13 FAIL\n"); return; }
  1857. X            if (i == 4 && k != 404) { printf("test 13 FAIL\n"); return; }
  1858. X            k = foo(i,500);
  1859. X            continue;
  1860. X        }
  1861. X        k = foo(i,600);
  1862. X        j = 0;
  1863. X    }
  1864. X    printf("test13 ok\n");
  1865. X}
  1866. X
  1867. Xint var = 0;
  1868. X
  1869. Xinline evar() {
  1870. X    return(var);
  1871. X}
  1872. X
  1873. Xinline mvar(x) {
  1874. X    var = x;
  1875. X}
  1876. X 
  1877. Xt14(n)
  1878. Xint n;
  1879. X{
  1880. X    int var = 1;    /* hide outer def'n */
  1881. X
  1882. X    if (evar() != 0) { printf("test14 FAIL\n"); return;}
  1883. X    if (var != 1) { printf("test14 FAIL\n"); return;}
  1884. X    mvar(100);
  1885. X    if (var != 1) { printf("test14 FAIL\n"); return;}
  1886. X    if (evar() != 100) { printf("test14 FAIL\n"); return;}
  1887. X    printf("test14 ok\n");
  1888. X}
  1889. X
  1890. Xt15(i,var)
  1891. Xint i;
  1892. Xint var;
  1893. X{
  1894. X    int a,b,c;
  1895. X
  1896. X    mvar(-100);
  1897. X
  1898. X    a = 1;
  1899. X    b = 2;
  1900. X    c = 3;
  1901. X
  1902. X    {
  1903. X        int a,b;
  1904. X
  1905. X        a = 100;
  1906. X        b = 200;
  1907. X
  1908. X        c = foo(a,b);
  1909. X    }
  1910. X
  1911. X    if (a != 1 || b != 2 || c != 300) { printf("test15 FAIL\n"); return; }
  1912. X
  1913. X    c = var;
  1914. X    {
  1915. X        int var;
  1916. X
  1917. X        var = 1000;
  1918. X
  1919. X        {
  1920. X            cptr var, a, b, c;
  1921. X    
  1922. X            a = "-1";
  1923. X            b = "-2";
  1924. X            c = "-3";
  1925. X            var = "-4";
  1926. X            if (evar() != -100) { printf("test15 FAIL\n"); return;}
  1927. X        }
  1928. X
  1929. X        if (evar() != -100) { printf("test15 FAIL\n"); return;}
  1930. X    }
  1931. X    if (var != c) { printf("test15 FAIL\n"); return; }
  1932. X    if (evar() != -100) { printf("test15 FAIL\n"); return;}
  1933. X    printf("test15 ok\n");
  1934. X}
  1935. X
  1936. Xt16(n)
  1937. Xint n;
  1938. X{
  1939. X    char *s = "foo";
  1940. X
  1941. X    if (hardcase1(0,1) != 1) { printf("test16 FAIL\n"); return;}
  1942. X    while (1 && (hardcase1(0,1) != 1)) printf("test16 FAIL\n");
  1943. X    s = hardcase2("foo",1,0);
  1944. X    printf("test16 ok\n");
  1945. X}
  1946. X
  1947. Xt17(n)
  1948. Xint n;
  1949. X{
  1950. X    int x = 1;
  1951. X
  1952. X    if (x && expr1(1,0) != 0) {printf("test17 FAIL(1)\n"); return;}
  1953. X    if (x && expr1(0,1) != 1) {printf("test17 FAIL(2)\n"); return;}
  1954. X    if (x && expr1(0,100) != 2) {printf("test17 FAIL(3)\n"); return;}
  1955. X    if (x && expr1(0,0) != 3) {printf("test17 FAIL(4)\n"); return;}
  1956. X    if (x && expr2(1,0) != 1) {printf("test17 FAIL(5)\n"); return;}
  1957. X    if (x && expr2(0,1) != 201) {printf("test17 FAIL(6)\n"); return;}
  1958. X    if (x && expr2(0,0) != 500) {printf("test17 FAIL(7)\n"); return;}
  1959. X    printf("test17 ok\n");
  1960. X}
  1961. X
  1962. Xt18(n)
  1963. Xint n;
  1964. X{
  1965. X    int i,j;
  1966. X
  1967. X    i = 0;
  1968. XL1:
  1969. X    j = labs(i);
  1970. X    if (j != i) {printf("test18 FAIL\n"); return; }
  1971. X    i++;
  1972. X    if (i > 10) goto L2;
  1973. X    goto L1;
  1974. XL2:
  1975. X    printf("test18 ok\n");
  1976. X}
  1977. X
  1978. X/* simple inline */
  1979. Xinline int foo(a,b) {
  1980. X    register int x = 0;
  1981. X
  1982. X    printf("foo(%d, %d)\n", a,b);
  1983. X    return(a+b);
  1984. X}
  1985. Xinline int bar(x,y) {
  1986. X    register int a;
  1987. X
  1988. X    a = 0;
  1989. X    printf("bar(%d, %d)\n", x,y);
  1990. X    return(x-y);
  1991. X}
  1992. X/* inline with some control flow */
  1993. Xinline biff(a) {
  1994. X    while(1) return a;
  1995. X}
  1996. X
  1997. X/* inline with a switch */
  1998. Xinline insw(i)
  1999. Xint i;
  2000. X{
  2001. X    switch(i) {
  2002. X    case 0:    return('0');
  2003. X    case 1: return('1');
  2004. X    case 2: return('2');
  2005. X    case 3: return('3');
  2006. X    case 4: return(foo(i,'0'));
  2007. X    case 5: return('5');
  2008. X    case 6: return('6');
  2009. X    case 7: return(foo(i,'0'));
  2010. X    case 8: return('8');
  2011. X    case 9: return('9');
  2012. X    }
  2013. X    return(0);
  2014. X}
  2015. X
  2016. Xtypedef char *cptr;
  2017. X
  2018. Xinline barf() {
  2019. X    printf("!!!\n");
  2020. X}
  2021. X
  2022. X/* inline returning a typedef */
  2023. Xinline cptr
  2024. Xboff(c,s)
  2025. Xchar c;
  2026. Xcptr s;
  2027. X{
  2028. X    s[0] = c;
  2029. X    return(&s[1]);
  2030. X}
  2031. X
  2032. X/* inline returning a pointer type */
  2033. Xinline char *
  2034. Xboff2(c,s)
  2035. Xchar c;
  2036. Xcptr s;
  2037. X{
  2038. X    s[0] = c;
  2039. X    return(&s[1]);
  2040. X}
  2041. X
  2042. Xstruct str {
  2043. X    int a;
  2044. X    int b;
  2045. X    int c;
  2046. X};
  2047. X
  2048. X/* inline returning a structure */
  2049. Xinline struct str bipp(a,b,c)
  2050. Xint a, b, c;
  2051. X{
  2052. X    struct str x;
  2053. X
  2054. X    x.a = a;
  2055. X    x.b = b;
  2056. X    x.c = c;
  2057. X    return(x);
  2058. X}
  2059. X
  2060. X/* inline returning a structure pointer */
  2061. Xinline struct str *bupp(z,a,b,c)
  2062. Xregister struct str *z;
  2063. Xregister int a,b,c;
  2064. X{
  2065. X    z->a = a;
  2066. X    z->b = b;
  2067. X    z->c = c;
  2068. X    return(z);
  2069. X}
  2070. X
  2071. Xnil(){}
  2072. X
  2073. X/* inline returning function pointer */
  2074. Xinline int (*fp())()
  2075. X{
  2076. X    return(nil);
  2077. X}
  2078. X
  2079. Xint effect = 0;
  2080. X
  2081. Xinline int side_effect(a)
  2082. Xint a;
  2083. X{
  2084. X    int old;
  2085. X
  2086. X    old = effect;
  2087. X    effect = a;
  2088. X
  2089. X    return(old);
  2090. X}
  2091. X
  2092. X/* should have no effect on arguments */
  2093. Xinline int swaparg(a,b)
  2094. X{
  2095. X    int tmp;
  2096. X
  2097. X    tmp = a;
  2098. X    a = b;
  2099. X    b = tmp;
  2100. X
  2101. X    return(a+b);
  2102. X}
  2103. X
  2104. Xinline struct str modarg(a,b)
  2105. Xint a;
  2106. Xstruct str b;    /* struct arg */
  2107. X{
  2108. X    switch(a) {
  2109. X    case 0:
  2110. X        a = 1;
  2111. X        b.a = 1;
  2112. X        break;
  2113. X    case 1:
  2114. X        a >>= 1;
  2115. X        a <<= 1;
  2116. X        b.a = a;
  2117. X        break;
  2118. X    case 2:
  2119. X        a *= 3;
  2120. X        b.a = a;
  2121. X        break;
  2122. X    }
  2123. X    return(b);
  2124. X}
  2125. X
  2126. Xinline hardcase1(a,b)
  2127. Xint a,b;
  2128. X{
  2129. X    { ; }
  2130. X    if (a);
  2131. X    {{}}
  2132. X    if (a) { } else ;
  2133. X    return(b);
  2134. X}
  2135. Xinline char *
  2136. Xhardcase2(a,b,c)
  2137. Xchar *a;
  2138. Xint b,c;
  2139. X{
  2140. X    char *s = "foo", c = 'c';
  2141. X    int x = b;
  2142. X
  2143. X    if (a) return(s);
  2144. X    else {
  2145. X        if (b) return(a+c);
  2146. X    }
  2147. X    return(a+c);
  2148. X}
  2149. X
  2150. Xinline expr1(a,b)
  2151. Xint a,b;
  2152. X{
  2153. X    int x = 0;
  2154. X
  2155. X    if (foo(0,a+b) == 100) return x+2;    /* a+b == 100, ret = 2 */
  2156. X    if (foo(50,50) == 100 && a) return x;    /* a != 0, return = 0 */
  2157. X    if (foo(100,0) == 100 && b) return x+1;    /* a == 0 && b != 0, ret = 1 */
  2158. X    return x+3;                /* ret = 3 */
  2159. X}
  2160. X
  2161. Xinline expr2(a,b)
  2162. Xint a,b;
  2163. X{
  2164. X    register int x = 0, y = 1;
  2165. X
  2166. X    if (a) {
  2167. X        return(x+y);    /* a != 0, return = 1 */
  2168. X    } else {
  2169. X        register int x = 100, y = 101;
  2170. X
  2171. X        if (b) {
  2172. X            return(x+y);    /* a == 0 && b != 0, return = 201 */
  2173. X        } else {
  2174. X            register int x = 200, y = 300;
  2175. X
  2176. X            return(x+y);    /* a == 0 && b == 0, return = 500 */
  2177. X        }
  2178. X    }
  2179. X}
  2180. X
  2181. X
  2182. Xinline labs(i)
  2183. Xint i;
  2184. X{
  2185. X    if (i == 1) goto L1;
  2186. X    if (i == 2) goto L2;
  2187. X    if (i == 3) goto L3;
  2188. X    if (i == 4) goto L4;
  2189. X    goto L5;
  2190. XL6:
  2191. X    return(i);
  2192. X
  2193. XL1:    i++; return(1);
  2194. XL2:    if (i == 2) return(2);
  2195. XL3:    return(3);
  2196. XL4:    {
  2197. X    return(4);
  2198. X    }
  2199. XL5:    goto L6;
  2200. X}
  2201. \Rogue\Monster\
  2202. else
  2203.   echo "will not over write ./test2.c"
  2204. fi
  2205. chmod 444 ./test2.c
  2206. if [ `wc -c ./test2.c | awk '{printf $1}'` -ne 11844 ]
  2207. then
  2208. echo `wc -c ./test2.c | awk '{print "Got " $1 ", Expected " 11844}'`
  2209. fi
  2210. echo "Finished archive 1 of 3"
  2211. # if you want to concatenate archives, remove anything after this line
  2212. exit
  2213.