Re: [9fans] Undefined Behaviour in C

[Brantley Coile <brantleycoile@me.com>]

[-- Attachment #1: Type: text/plain, Size: 10799 bytes --]

Hi Bakul.  Long time since our Bay Area plan 9 hacking sessions. I've avoided the valley all together for a year and a half now. Not quite long enough yet. 

I thought the same thing, using ~0 for nil, but realized two things. First, that's a valid address on the PDP11 where the convention developed. It's the unibus space. Second, ~0 + member offest is still in page zero. 

By the way, are there any structs more than 4K in Linux? Are there any in plan 9?

Sent from my iPad

> On Nov 26, 2015, at 2:27 AM, Bakul Shah <bakul@bitblocks.com> wrote:
> 
> Using 0xfff...f instead of 0 for a null ptr might've been less "disgusting"! 
> 
>> On Nov 25, 2015, at 6:04 PM, Prof Brucee <prof.brucee@gmail.com> wrote:
>> 
>> gcc is indeed a very sad tome. The mmap of 0 is disgusting. I like kenc. It just works. My behaviour this afternoon will be undefined but not as stupid as that of some programmers.
>> 
>>> On 26/11/2015 5:43 AM, "Brantley Coile" <brantleycoile@me.com> wrote:
>>> Align it to column 7 and it looks like all the code I saw when I started. 
>>> 
>>> iPhone email
>>> 
>>>> On Nov 25, 2015, at 12:13 PM, Ryan Gonzalez <rymg19@gmail.com> wrote:
>>>> 
>>>> Neither! It's what happens when you run sed 's/^\s*//' on your whole code base, yielding results like (from cmd/yacc.c):
>>>> 
>>>> 
>>>> void
>>>> setup(int argc, char *argv[])
>>>> {
>>>> long c, t;
>>>> int i, j, fd, lev, ty, ytab, *p;
>>>> int vflag, dflag, stem;
>>>> char actnm[8], *stemc, *s, dirbuf[128];
>>>> Biobuf *fout;
>>>> 
>>>> ytab = 0;
>>>> vflag = 0;
>>>> dflag = 0;
>>>> stem = 0;
>>>> stemc = "y";
>>>> foutput = 0;
>>>> fdefine = 0;
>>>> fdebug = 0;
>>>> ARGBEGIN{
>>>> case 'v':
>>>> case 'V':
>>>> vflag++;
>>>> break;
>>>> case 'D':
>>>> yydebug = ARGF();
>>>> break;
>>>> case 'a':
>>>> yyarg = 1;
>>>> break;
>>>> case 'd':
>>>> dflag++;
>>>> break;
>>>> case 'l':
>>>> yyline = 0;
>>>> break;
>>>> case 'o':
>>>> ytab++;
>>>> ytabc = ARGF();
>>>> break;
>>>> case 's':
>>>> stem++;
>>>> stemc = ARGF();
>>>> break;
>>>> case 'S':
>>>> parser = PARSERS;
>>>> break;
>>>> default:
>>>> error("illegal option: %c", ARGC());
>>>> }ARGEND
>>>> openup(stemc, dflag, vflag, ytab, ytabc);
>>>> fout = dflag?fdefine:ftable;
>>>> if(yyarg){
>>>> Bprint(ftable, "#define\tYYARG\t1\n\n");
>>>> }
>>>> if((fd = mkstemp(ttempname)) >= 0){
>>>> tempname = ttempname;
>>>> ftemp = Bfdopen(fd, OWRITE);
>>>> }
>>>> if((fd = mkstemp(tactname)) >= 0){
>>>> actname = tactname;
>>>> faction = Bfdopen(fd, OWRITE);
>>>> }
>>>> if(ftemp == 0 || faction == 0)
>>>> error("cannot open temp file");
>>>> if(argc < 1)
>>>> error("no input file");
>>>> infile = argv[0];
>>>> if(infile[0] != '/' && getwd(dirbuf, sizeof dirbuf)!=nil){
>>>> i = strlen(infile)+1+strlen(dirbuf)+1+10;
>>>> s = malloc(i);
>>>> if(s != nil){
>>>> snprint(s, i, "%s/%s", dirbuf, infile);
>>>> cleanname(s);
>>>> infile = s;
>>>> }
>>>> }
>>>> finput = Bopen(infile, OREAD);
>>>> if(finput == 0)
>>>> error("cannot open '%s'", argv[0]);
>>>> cnamp = cnames;
>>>> 
>>>> defin(0, "$end");
>>>> extval = PRIVATE;	/* tokens start in unicode 'private use' */
>>>> defin(0, "error");
>>>> defin(1, "$accept");
>>>> defin(0, "$unk");
>>>> mem = mem0;
>>>> i = 0;
>>>> 
>>>> for(t = gettok(); t != MARK && t != ENDFILE;)
>>>> switch(t) {
>>>> case ';':
>>>> t = gettok();
>>>> break;
>>>> 
>>>> case START:
>>>> if(gettok() != IDENTIFIER)
>>>> error("bad %%start construction");
>>>> start = chfind(1, tokname);
>>>> t = gettok();
>>>> continue;
>>>> 
>>>> case TYPEDEF:
>>>> if(gettok() != TYPENAME)
>>>> error("bad syntax in %%type");
>>>> ty = numbval;
>>>> for(;;) {
>>>> t = gettok();
>>>> switch(t) {
>>>> case IDENTIFIER:
>>>> if((t=chfind(1, tokname)) < NTBASE) {
>>>> j = TYPE(toklev[t]);
>>>> if(j != 0 && j != ty)
>>>> error("type redeclaration of token %s",
>>>> tokset[t].name);
>>>> else
>>>> SETTYPE(toklev[t], ty);
>>>> } else {
>>>> j = nontrst[t-NTBASE].value;
>>>> if(j != 0 && j != ty)
>>>> error("type redeclaration of nonterminal %s",
>>>> nontrst[t-NTBASE].name );
>>>> else
>>>> nontrst[t-NTBASE].value = ty;
>>>> }
>>>> case ',':
>>>> continue;
>>>> case ';':
>>>> t = gettok();
>>>> default:
>>>> break;
>>>> }
>>>> break;
>>>> }
>>>> continue;
>>>> 
>>>> case UNION:
>>>> /* copy the union declaration to the output */
>>>> cpyunion();
>>>> t = gettok();
>>>> continue;
>>>> 
>>>> case LEFT:
>>>> case BINARY:
>>>> case RIGHT:
>>>> i++;
>>>> 
>>>> case TERM:
>>>> /* nonzero means new prec. and assoc. */
>>>> lev = t-TERM;
>>>> ty = 0;
>>>> 
>>>> /* get identifiers so defined */
>>>> t = gettok();
>>>> 
>>>> /* there is a type defined */
>>>> if(t == TYPENAME) {
>>>> ty = numbval;
>>>> t = gettok();
>>>> }
>>>> for(;;) {
>>>> switch(t) {
>>>> case ',':
>>>> t = gettok();
>>>> continue;
>>>> 
>>>> case ';':
>>>> break;
>>>> 
>>>> case IDENTIFIER:
>>>> j = chfind(0, tokname);
>>>> if(j >= NTBASE)
>>>> error("%s defined earlier as nonterminal", tokname);
>>>> if(lev) {
>>>> if(ASSOC(toklev[j]))
>>>> error("redeclaration of precedence of %s", tokname);
>>>> SETASC(toklev[j], lev);
>>>> SETPLEV(toklev[j], i);
>>>> }
>>>> if(ty) {
>>>> if(TYPE(toklev[j]))
>>>> error("redeclaration of type of %s", tokname);
>>>> SETTYPE(toklev[j],ty);
>>>> }
>>>> t = gettok();
>>>> if(t == NUMBER) {
>>>> tokset[j].value = numbval;
>>>> if(j < ndefout && j > 3)
>>>> error("please define type number of %s earlier",
>>>> tokset[j].name);
>>>> t = gettok();
>>>> }
>>>> continue;
>>>> }
>>>> break;
>>>> }
>>>> continue;
>>>> 
>>>> case LCURLY:
>>>> defout(0);
>>>> cpycode();
>>>> t = gettok();
>>>> continue;
>>>> 
>>>> default:
>>>> error("syntax error");
>>>> }
>>>> if(t == ENDFILE)
>>>> error("unexpected EOF before %%");
>>>> 
>>>> /* t is MARK */
>>>> if(!yyarg)
>>>> Bprint(ftable, "extern	int	yyerrflag;\n");
>>>> Bprint(ftable, "#ifndef	YYMAXDEPTH\n");
>>>> Bprint(ftable, "#define	YYMAXDEPTH	150\n");
>>>> Bprint(ftable, "#endif\n" );
>>>> if(!ntypes) {
>>>> Bprint(ftable, "#ifndef	YYSTYPE\n");
>>>> Bprint(ftable, "#define	YYSTYPE	int\n");
>>>> Bprint(ftable, "#endif\n");
>>>> }
>>>> if(!yyarg){
>>>> Bprint(ftable, "YYSTYPE	yylval;\n");
>>>> Bprint(ftable, "YYSTYPE	yyval;\n");
>>>> }else{
>>>> if(dflag)
>>>> Bprint(ftable, "#include \"%s.%s\"\n\n", stemc, FILED);
>>>> Bprint(fout, "struct Yyarg {\n");
>>>> Bprint(fout, "\tint\tyynerrs;\n");
>>>> Bprint(fout, "\tint\tyyerrflag;\n");
>>>> Bprint(fout, "\tvoid*\targ;\n");
>>>> Bprint(fout, "\tYYSTYPE\tyyval;\n");
>>>> Bprint(fout, "\tYYSTYPE\tyylval;\n");
>>>> Bprint(fout, "};\n\n");
>>>> }
>>>> prdptr[0] = mem;
>>>> 
>>>> /* added production */
>>>> *mem++ = NTBASE;
>>>> 
>>>> /* if start is 0, we will overwrite with the lhs of the first rule */
>>>> *mem++ = start;
>>>> *mem++ = 1;
>>>> *mem++ = 0;
>>>> prdptr[1] = mem;
>>>> while((t=gettok()) == LCURLY)
>>>> cpycode();
>>>> if(t != IDENTCOLON)
>>>> error("bad syntax on first rule");
>>>> 
>>>> if(!start)
>>>> prdptr[0][1] = chfind(1, tokname);
>>>> 
>>>> /* read rules */
>>>> while(t != MARK && t != ENDFILE) {
>>>> /* process a rule */
>>>> rlines[nprod] = lineno;
>>>> if(t == '|')
>>>> *mem++ = *prdptr[nprod-1];
>>>> else
>>>> if(t == IDENTCOLON) {
>>>> *mem = chfind(1, tokname);
>>>> if(*mem < NTBASE)
>>>> error("token illegal on LHS of grammar rule");
>>>> mem++;
>>>> } else
>>>> error("illegal rule: missing semicolon or | ?");
>>>> /* read rule body */
>>>> t = gettok();
>>>> 
>>>> more_rule:
>>>> while(t == IDENTIFIER) {
>>>> *mem = chfind(1, tokname);
>>>> if(*mem < NTBASE)
>>>> levprd[nprod] = toklev[*mem];
>>>> mem++;
>>>> t = gettok();
>>>> }
>>>> if(t == PREC) {
>>>> if(gettok() != IDENTIFIER)
>>>> error("illegal %%prec syntax");
>>>> j = chfind(2, tokname);
>>>> if(j >= NTBASE)
>>>> error("nonterminal %s illegal after %%prec",
>>>> nontrst[j-NTBASE].name);
>>>> levprd[nprod] = toklev[j];
>>>> t = gettok();
>>>> }
>>>> if(t == '=') {
>>>> levprd[nprod] |= ACTFLAG;
>>>> Bprint(faction, "\ncase %d:", nprod);
>>>> cpyact(mem-prdptr[nprod]-1);
>>>> Bprint(faction, " break;");
>>>> if((t=gettok()) == IDENTIFIER) {
>>>> 
>>>> /* action within rule... */
>>>> sprint(actnm, "$$%d", nprod);
>>>> 
>>>> /* make it a nonterminal */
>>>> j = chfind(1, actnm);
>>>> 
>>>> /*
>>>> * the current rule will become rule number nprod+1
>>>> * move the contents down, and make room for the null
>>>> */
>>>> for(p = mem; p >= prdptr[nprod]; --p)
>>>> p[2] = *p;
>>>> mem += 2;
>>>> 
>>>> /* enter null production for action */
>>>> p = prdptr[nprod];
>>>> *p++ = j;
>>>> *p++ = -nprod;
>>>> 
>>>> /* update the production information */
>>>> levprd[nprod+1] = levprd[nprod] & ~ACTFLAG;
>>>> levprd[nprod] = ACTFLAG;
>>>> if(++nprod >= NPROD)
>>>> error("more than %d rules", NPROD);
>>>> prdptr[nprod] = p;
>>>> 
>>>> /* make the action appear in the original rule */
>>>> *mem++ = j;
>>>> 
>>>> /* get some more of the rule */
>>>> goto more_rule;
>>>> }
>>>> }
>>>> 
>>>> while(t == ';')
>>>> t = gettok();
>>>> *mem++ = -nprod;
>>>> 
>>>> /* check that default action is reasonable */
>>>> if(ntypes && !(levprd[nprod]&ACTFLAG) && nontrst[*prdptr[nprod]-NTBASE].value) {
>>>> 
>>>> /* no explicit action, LHS has value */
>>>> int tempty;
>>>> 
>>>> tempty = prdptr[nprod][1];
>>>> if(tempty < 0)
>>>> error("must return a value, since LHS has a type");
>>>> else
>>>> if(tempty >= NTBASE)
>>>> tempty = nontrst[tempty-NTBASE].value;
>>>> else
>>>> tempty = TYPE(toklev[tempty]);
>>>> if(tempty != nontrst[*prdptr[nprod]-NTBASE].value)
>>>> error("default action causes potential type clash");
>>>> }
>>>> nprod++;
>>>> if(nprod >= NPROD)
>>>> error("more than %d rules", NPROD);
>>>> prdptr[nprod] = mem;
>>>> levprd[nprod] = 0;
>>>> }
>>>> 
>>>> /* end of all rules */
>>>> defout(1);
>>>> 
>>>> finact();
>>>> if(t == MARK) {
>>>> Bprint(ftable, "\n");
>>>> if(yyline)
>>>> Bprint(ftable, "#line\t%d\t\"%s\"\n", lineno, infile);
>>>> while((c=Bgetrune(finput)) != Beof)
>>>> Bputrune(ftable, c);
>>>> }
>>>> Bterm(finput);
>>>> }
>>>> 
>>>> 
>>>>> On Wed, Nov 25, 2015 at 10:03 AM, <plannine@sigint.cs.purdue.edu> wrote:
>>>>> On Wed, Nov 25, 2015 at 09:25:55AM -0500, Brantley Coile wrote:
>>>>> > unindented consequences
>>>>> 
>>>>> Is that a class of Python bugs or an awesome name for a Nerdcore band?
>>>> 
>>>> 
>>>> 
>>>> -- 
>>>> Ryan
>>>> [ERROR]: Your autotools build scripts are 200 lines longer than your program. Something’s wrong.
>>>> http://kirbyfan64.github.io/

[-- Attachment #2: Type: text/html, Size: 14600 bytes --]