Attachment #214862 for bug #246163

Lines 33-37 Link Here

(-)blocks.c (-1 lines)
33		33
34	extern List *blocks;	34	extern List *blocks;
35	extern void warnFor(Token, char, char*);
36		35
37	Blox pushBlock(Token cmd, int infl, int lvl, int cond)	36	Blox pushBlock(Token cmd, int infl, int lvl, int cond)

Lines 34-38 Link Here

(-)blocks.h (-1 / +1 lines)
34	extern void delBlock(Blox *);	34	extern void delBlock(Blox *);
35	extern void popBlock(int);	35	extern void popBlock(int);
36	extern int isUnreachable();	36	extern int isUnreachable(void);
37	extern void setUnreachable(int);	37	extern void setUnreachable(int);
38		38




#endif

extern Token *tokenPop(Token **);
extern void freeToken(Token *);
extern void streamMore(Input *);

List *config = noList;

static struct {
	const char	*name;
	ParamType	code;
} pvals[] ={

};

static void dumpPdata(ParamData *pt, FILE *op)
{
    int i;
    const char *pad;
    List *lp;


}

void dumpConf(const ConfigData *cp, FILE *op)
{
    List *plp;

}

static void pcode(ParamData *ppt, const char *str)
{
    int i;

    SeqnData *sd;
    void *dp;
 
    
    ppt = newpdata();
    switch (tp->type)

}

static int confighandle(Token *line)
{
    ConfigData *cpt;

}

void readconfig(const char *str)
{
    FILE *fd;
    Input file;

    if ((fd = fopen(str, "r")) == NULL)
    {

 * use the tokenising mechanism we already have to parse the config file
 */
    file.atext = malloc(64*1024);
    file.stream = fd;
    file.tcall = file.texpr = 0;

    file.lineStart = 1;
    streamMore(&file);
    while(confighandle(collect(&file)))
    {
        /* skip */
    }
    free(file.atext);
    fclose(fd);
}

void stringconfig(const char *str)
{
    Input file;

    file.lineNumber = 1;
    file.lineStart = 1;
    while(confighandle(collect(&file)))
    {
        /* skip */

Lines 15-19 Link Here

(-)flagvars.h (-5 / +5 lines)
15		15
16	extern int lineNumber;	16	extern int lineNumber;
17	extern char *currentfile;	17	extern const char *currentfile;
18		18
19	extern int compout;	19	extern int compout;
Lines 64-72 Link Here
64	extern int trystrings;	64	extern int trystrings;
65		65
66	extern char *style;	66	extern const char *style;
67	extern char *pstyle;	67	extern const char *pstyle;
68	extern char *contString;	68	extern const char *contString;
69		69
70	extern char *locale;	70	extern const char *locale;
71	extern FILE *msgfile;	71	extern FILE *msgfile;
72	extern FILE *specfile;	72	extern FILE *specfile;




#include <stdlib.h>
#endif
#include <unistd.h>

int failed	= 0;


int compout	= 0;
static int resvsplit = 0;
int noquotes	= 0;
int spaceout	= 0;

int internat	= 0;

const char *style	= NULL;
const char *pstyle	= NULL;
const char *contString 	= "";

const char *locale	= NULL;
FILE *msgfile		= NULL;
FILE *specfile		= NULL;

int praghold		= 0;

const char *currentfile	= NULL;

List *skiplist = NULL;

#ifndef __FreeBSD__
extern int getopt(int, char*const*, const char*);
#endif

extern int optind;
extern char *optarg;
extern int fclose(FILE*);
extern void readconfig(char *);
extern void stringconfig(char *);
extern void clearState(void);


}

static const char *languages[] =
{
    "aa",	/* Afar	*/

};

static const char *countries[] =
{
    "AF",	/* AFGHANISTAN */

};

static void checkLocale(const char *v)
{
    int l, i, fnd = 0;;

    for (i = 0; languages[i] != NULL; i += 1)
    {
	if (strncmp(v, languages[i], 2) == 0)

}

static void setOption(int flag, const char *value)
{
    int not;

}

static void readrc(const char *file)
{
    const char *opts[50];
    char buff[128], *cp;
    FILE *desc;
    int leng, i;

static void process(FILE *desc)
{
    extern void flushOutput(void);
    extern int handle(Token *line);
    extern void streamMore(Input *);

    Input file;

    file.atext = malloc(64*1024);
    file.stream = desc;
    file.tcall = file.texpr = 0;

    }
    flushOutput();
    free(file.atext);
}

static void initCmds(void)
{
    static const char *cmdspec =
	"set {{var 0x0017} {ctype? 0x0001}}\n"
	"global {{varlist 0x0150}}\n"

{
    FILE  *desc;
    extern void initOutput(void);

    initCmds();




extern List *skiplist;
extern List *blocks;

void dumpConf(const ConfigData *, FILE*);
void readconfig(const char *fileName);
void stringconfig(const char *line);
void initOutput(void);
void setIndent(void);
void outdent(void);
int isVarToken(const Token *);
int isSwitch(const Token *);
int isSingleCall(const Token *, const char *);
int tokEqual(const Token *, const char *);
void flushOutput(void);
void clearState(void);
void warnFor(const Token *token, const char *cmd, const char *txt);




static TokenType olast	= HEAD;

static Token nlToken	= {.type = BLANK, .ckind = CNSTWORD};
static Token startToken	= {.type = START, .ckind = CNSTWORD};
static Token contToken	= {.type = CONT, .ckind = CNSTWORD};
static Token spToken	= {.type = SP, .ckind = CNSTWORD, .text = " ", .length = 1};

void initOutput(void)

}

static void printkn(const char *txt, int length, int keepnl)
{
    char *cp;

}

static void printn(const char *txt, int len)
{
    if (!testonly)

}

static void print(const char *txt)
{
    printn(txt, strlen(txt));
}

static void brace(const char *t)
{
    char *cp, *bp;

}

static Token dollarToken = {.type = DOLLAR, .ckind = CNSTWORD};
static Token endlineToken = {.type = ENDLINE, .ckind = CNSTWORD};
static Token lbrackToken = {.type = LBRACK, .ckind = CNSTWORD};
static Token rbrackToken = {.type = RBRACK, .ckind = CNSTWORD};

void output(Token *token, int compress)




static int inproc = 0;

static Token lbraceToken	= {.type = LBRACE, .ckind = CNSTWORD};
static Token rbraceToken	= {.type = RBRACE, .ckind = CNSTWORD};
static Token xcontToken		= {.type = XCONT, .ckind = CNSTWORD};
static Token ostartToken	= {.type = OSTART, .ckind = CNSTWORD};
static Token startToken		= {.type = START, .ckind = CNSTWORD};
static Token contToken		= {.type = CONT, .ckind = CNSTWORD};
static Token econtToken		= {.type = ECONT, .ckind = CNSTWORD};
static Token emToken		= {.type = EM, .ckind = CNSTWORD};
static Token nospToken		= {.type = NOSP, .ckind = CNSTWORD};
static Token *olsToken		= &emToken;
static Token spToken		= {.type = SP, .ckind = CNSTWORD};
static Token lbrackToken	= {.type = LBRACK, .ckind = CNSTWORD};
static Token rbrackToken	= {.type = RBRACK, .ckind = CNSTWORD};
static Token msgcatToken	= {.type = CONST, .ckind = CNSTWORD, .text = "::msgcat::mc", .length = 12};

static Token dqStart		= {.type = DQSTART, .ckind = CNSTWORD};
static Token dqEnd		= {.type = DQEND, .ckind = CNSTWORD};
static Token thenToken		= {.type = CONST, .ckind = CNSTWORD, .text = "then", .length = 4};
static Token procToken		= {.type = CONST, .ckind = CNSTWORD, .text = "proc", .length = 4};
static Token elseToken		= {.type = CONST, .ckind = CNSTWORD, .text = "else", .length = 4};
static Token elseifToken	= {.type = CONST, .ckind = CNSTWORD, .text = "elseif", .length = 6};
static Token methodToken	= {.type = CONST, .ckind = CNSTWORD, .text = "method", .length = 6};
static Token semiToken		= {.type = SEMI, .ckind = CNSTWORD, .text = ";", .length = 1};
static Token argsToken		= {.type = SEMI, .ckind = CNSTWORD, .text = "args", .length = 4};
static Token argvToken		= {.type = SEMI, .ckind = CNSTWORD, .text = "argv", .length = 4};
static Token argv0Token		= {.type = SEMI, .ckind = CNSTWORD, .text = "argv0", .length = 5};
static Token platfToken		= {.type = SEMI, .ckind = CNSTWORD, .text = "tcl_platform", .length = 12};

List *blocks  = noList;

static CheckIt **noChecks = (CheckIt **) 0;

extern void setIndent(void);
extern void outdent(void);
extern int isVarToken(Token *);
extern int isSwitch(Token *);
extern int isSingleCall(Token *, char *);
extern int tokEqual(Token *, char *);

/*
 * If there are no more tokens, print a useful message to the user and
 * exit.
 */
static void failIfNullToken(const Token *token, const char *part,
    const char *command, int ln)
{
    char msg[1024];

	if (ln == 0)
	{
	    snprintf(msg, sizeof msg, "Missing \"%s\" part in call of %s", part, command);
	}
	else
	{
	    snprintf(msg, sizeof msg, "Missing \"%s\" part in call of %s, starting line %d",
	      part, command, ln);
	}

 * the user.
 */
static void warnIfArgsAfter(const Token *token, const char *part,
    const char *command)
{
    char msg[1024];

	    if (*part != '\0')
	    {
		snprintf(msg, sizeof msg, "Extra arguments after \"%s\" part in call of %s",
		  part, command);
	    }
	    else
	    {
		snprintf(msg, sizeof msg, "Extra arguments in call of `%s'", command);
	    }
	    warn(token, msg);

	      token->next->text[0] != '\0')
	    {
		snprintf(msg, sizeof msg, "Extra token is `%s'", token->next->text);
		warn(token->next, msg);
	    }

}

static void warnExpr(const Token *cmd, const char *txt)
{
    if (doTest(HEXPR) && cmd != noToken && cmd->type != LIST)

}

void warnFor(const Token *token, const char *cmd, const char *txt)
{
    char msg[1024];

    snprintf(msg, sizeof msg, txt, cmd);
    warn(token, msg);
}

static void warnIFor(Token *token, int val, char *txt)
{
    char msg[1024];

    sprintf(msg, txt, val);
    warn(token, msg);
}
/*
 * reset various variables so that multiple file processing doesn't get

}

static int isNumber(const char *cp)
{
    if (*cp == '-' || *cp == '+')

}

static int tokIsLevel(const Token *tp)
{
    const char *cp;
    if (tp == noToken || !(tp->type == CONST || tp->type == LIST) || tp->text == (char *) 0)
    {

}

static int oneLine(const Token *seq, int semis)
{
    while (seq != noToken)

}

static int checkSpecial(const char *val)
{
    char ch;

}

static void checkUnquoted(const Token *str)
{
    char msg[128];
    if (noquotes && str->type == CONST && str->ckind == CNSTWORD && !isNumber(str->text))
    {
        snprintf(msg, sizeof msg, "Unquoted constant - \"%s\"", str->text);
        warn(str, msg);
    }
}

static void checkType(const Token *cmd, int flags)
{
    if (cmd->type == CONST)

}

static int single(const Token * tp)
{
    if (tp != noToken && tp->next == noToken)

}

static int sconstant(const Token *tp)
{
    return (tp != noToken && tp->next == noToken

}

static int constantString(const Token * tp, int any)
{
    Token *sq;

}

static void loopstart(int inf, int cond)
{
    pushBlock(noToken, inf, -1, cond);
}

static void loopend(void)
{
    Blox *bp = lpeek(blocks);

}

static void msgsave(const Token *tp, int any)
{
    char filename[128];

}

static void doUser(Token *hd, Token *cmd, const ConfigData *cpt, int nostart);

static void sptclop(Token *hd)
{
    List *cpt = config;
    extern void doUser(Token *hd, Token *cmd, ConfigData *cpt, int nostart);
    ConfigData *cdp;


} PressFlags;

static void press(Token *v , PressFlags flags)
{
    Input *idx;

		{
		case SEMI :
		    if (flags & SEMIS)
		    {
			output(&semiToken, 1);

}

static void etcetera(Token *cmd, int v)
{
    while (cmd != noToken)

}

static void catbin(Token *tp)
{
    int sem, oln;

    VarData *vp = (VarData *) 0;
    char msg[1024];
    Token *ap = noToken;
    const Token *ac;
    int array = 0;


}

static Token *doswitch(Token *cmd, Token *leadin)
{
    Token *tp, *bod;

}

static Token *doif(Token *cmd, Token *leadin)
{
    Token *tp, *then;

	cfl |= SPACEOUT;
    }
    press(cmd, cfl);
    if (putThen) { output(&thenToken, 0); }
    then = cmd->next;

	failIfNullToken(tp, "condition", "elseif", ln);
        warnExpr(tp, "elseif condition not braced.");
	press(tp, efl | PAREN);
	tp = tp->next;
	failIfNullToken(tp, "body", "elseif", ln);



static int isNSName(const Token *cmd)
{
    const char *cp;
    int cols = 0;


}

static Token *doProc(Token *tag, Token *cmd, Token *leadin)
{
    int ln = leadin->lineNo, inns;

static Token *doproc(Token *cmd, Token *leadin)
{
    return doProc(&procToken, cmd, leadin);
}

static Token *domethod(Token *cmd, Token *leadin)
{
    return doProc(&methodToken, cmd, leadin);
}

static Token *dodestructor(Token *cmd, Token *leadin __attribute__((__unused__)))
{
    if (!nest[0])

}

static Token *doconstructor(Token *cmd, Token *leadin __attribute__((__unused__)))
{
    if (!nest[0])

    {
	failIfNullToken(cmd, "args", "constructor", 0);
	press(cmd, NOBRACE | ADDBRACES);
	cmd = cmd->next;
	failIfNullToken(cmd, "body", "constructor", 0);

}

static Token *doreturn(Token *cmd, Token *leadin)
{
    Blox *pr = (Blox *) lpeek(blocks);

}

static Token *doregexp(Token *cmd, Token *leadin)
{
    int eopt = 0;

}

static Token *doregsub(Token *cmd, Token *leadin)
{
    int eopt = 0;

}

static Token *dobind(Token *cmd, Token *leadin __attribute__((__unused__)))
{
    Token *np;

}

static Token *doitcl_class(Token *cmd, Token *leadin __attribute__((__unused__)))
{
    failIfNullToken(cmd, "className", "itcl_class", 0);

}

static Token *docvar(Token *cmd, Token *prt)
{
    if (!nest[0])

	if ((cmd = cmd->next) != noToken)
	{
	    press(cmd, NOBRACE | ADDBRACES);
	    warnIfArgsAfter(cmd, "init", prt->text);
	}

}

static Token *dopublic(Token *cmd, Token *leadin __attribute__((__unused__)))
{
    if (!nest[0])

	if ((cmd = cmd->next) != noToken)
	{
	    press(cmd, NOBRACE | ADDBRACES);
	    if ((cmd = cmd->next) != noToken)
	    {

}

static Token *doprotected(Token *cmd, Token *leadin) { return docvar(cmd, leadin); }

static Token *docommon(Token *cmd, Token *leadin) { return docvar(cmd, leadin); }

static void checkVar(Token *cmd, const char *nm)
{
    List *bp = blocks;

}

static Token *doforeach(Token *cmd, Token *leadin __attribute__((__unused__)))
{
    failIfNullToken(cmd, "varName", "foreach", 0);

	cmd = cmd->next;
	failIfNullToken(cmd, "list", "foreach", 0);
	press(cmd, NOBRACE);
	cmd = cmd->next;
    }

}

static Token *doloop(Token *cmd, Token *leadin __attribute__((__unused__)))
{
    Token *tp;

    {
	failIfNullToken(cmd, "var", "loop", 0);
	press(cmd, NOBRACE | ADDBRACES);	/* var */
	tp = cmd->next;
	failIfNullToken(tp, "first", "loop", 0);
	warnExpr(cmd, "Unbracketed loop \"first\"");
	press(tp, ADDBRACES);			/* first */
	tp = tp->next;
	failIfNullToken(tp, "limit", "loop", 0);
	warnExpr(cmd, "Unbracketed loop \"limit\"");
	press(tp, ADDBRACES);			/* limit */

	tp = tp->next;

	{
	    warnExpr(cmd, "Unbracketed loop \"incr\"");
	    press(tp, NOBRACE | ADDBRACES);		/* incr */
	    tp = tp->next;
	}

} 

static Token *doexpr(Token *cmd, Token *leadin __attribute__((__unused__)))
{
    if (!doExpr)

	{
	    warnExpr(cmd, "expr body not braced.");
	    press(cmd, ADDBRACES | PAREN); /* */
	}
	else

}

static Token *dounset(Token *cmd, Token *leadin)
{
    int pCount = 1;

}

static Token *doupvar(Token *cmd, Token *leadin)
{
    int paramCount = 0;

}

static Token *dovariable(Token *cmd, Token *leadin)
{
    int paramCount = 1;

}

static void doBasic(const ConfigData *cpt, Token *hd, Token *cmd)
{
    List *sp, *llp, *lp;

	    else
	    {
		press(cmd, NOBRACE | ADDBRACES | SEMIS); /* */
	    }
	    break;

	    {
		warnExpr(cmd, "Unbracketed expression");
		press(cmd, ptpar); /* */
	    }
	    break;

		    ptpar |= SPACEOUT;
		}
		press(cmd, ptpar);
		loopstart(infloop, 1);
	    }

}

static void doUser(Token *hd, Token *cmd,
    const ConfigData *cpt, int nostart)
{
    if (isUnreachable())

Lines 32-37 Link Here

(-)token.c (-60 / +38 lines)
32	#endif	32	#endif
33		33
34	extern char *currentfile;
35
36	typedef struct tbuff_s	34	typedef struct tbuff_s
37	{	35	{
Lines 78-82 Link Here
78	}	76	}
79		77
80	static void catTB(TBuff tp, char str)	78	static void catTB(TBuff tp, const char str)
81	{	79	{
82	while (*str)	80	while (*str)
Lines 87-91 Link Here
87	}	85	}
88		86
89	static char *tokenName[] =	87	static const char *tokenName[] =
90	{	88	{
91	"ENDF",	89	"ENDF",
Lines 137-141 Link Here
137	static Token varToken(Input );	135	static Token varToken(Input );
138		136
139	Token *newToken(TokenType t)	137	static Token *newToken(TokenType t)
140	{	138	{
141	Token *tp = malloc(sizeof(Token));	139	Token *tp = malloc(sizeof(Token));
Lines 150-156 Link Here
150	}	148	}
151		149
152	void dumpToken(Token tk, FILE ops)	150	void dumpToken(const Token tk, FILE ops)
153	{	151	{
154	static char *cval [] =	152	static const char *cval [] =
155	{	153	{
156	"word", "string", "list"	154	"word", "string", "list"
Lines 195-199 Link Here
195	}	193	}
196		194
197	void fail(Token tp, char msg)	195	void fail(const Token tp, const char msg)
198	{	196	{
199	if (!compout)	197	if (!compout)
Lines 325-329 Link Here
325	}	323	}
326		324
327	void warn(Token tp, char msg)	325	void warn(const Token tp, const char msg)
328	{	326	{
329	Blox blp = (Blox ) lpeek(blocks);	327	Blox blp = (Blox ) lpeek(blocks);
Lines 334-338 Link Here
334	fprintf(stderr, "***");	332	fprintf(stderr, "***");
335	}	333	}
336	if (currentfile != (char *) 0)	334	if (currentfile != NULL)
337	{	335	{
338	fprintf(stderr, " %s", currentfile);	336	fprintf(stderr, " %s", currentfile);
Lines 377-381 Link Here
377	}	375	}
378		376
379	static void bwarn(int ln, char *msg)	377	static void bwarn(int ln, const char *msg)
380	{	378	{
381	Token *tp = newToken(SP);	379	Token *tp = newToken(SP);
Lines 391-395 Link Here
391	if (file->stream != NULL)	389	if (file->stream != NULL)
392	{	390	{
393	file->remaining = fread(file->text, 1, 64*1024, file->stream);	391	file->remaining = fread(file->atext, 1, 64*1024, file->stream);
394	}	392	}
395	}	393	}
Lines 400-404 Link Here
400	}	398	}
401		399
402	static char skipblank(char cp)	400	static const char skipblank(const char cp)
403	{	401	{
404	while (isBlank(*cp))	402	while (isBlank(*cp))
Lines 497-503 Link Here
497	if (tp != noToken)	495	if (tp != noToken)
498	{	496	{
499	if (tp->text != (char *) 0 && tp->text != tp->little)	497	if (tp->atext != tp->little)
500	{	498	{
501	free(tp->text);	499	free(tp->atext);
502	}	500	}
503	if (tp->sequence) freeToken(tp->sequence);	501	if (tp->sequence) freeToken(tp->sequence);
Lines 507-511 Link Here
507	}	505	}
508		506
509	static char filterString(Token tp, char *txt)	507	static char filterString(Token tp, const char *txt)
510	{	508	{
511	char cp = malloc(strlen(txt) + 1), pt;	509	char cp = malloc(strlen(txt) + 1), pt;
Lines 556-578 Link Here
556	}	554	}
557		555
558	Input ftokenise(char txt, int length, int lineNo, int expr)
559	{
560	Token tmp = newToken(CONST); / gash token for filterstring */
561	Input file = (Input ) malloc(sizeof(Input));
562	file->remaining = length;
563	file->pushed = 0;
564	file->stream = NULL;
565	file->position = file->text = filterString(tmp, txt);
566	file->tcall = 0;
567	file->texpr = expr;
568	file->lineNumber = lineNo;
569	file->lineStart = 1;
570	freeToken(tmp);
571	return file;
572	}
573
574	void untokenise(Input *file)	556	void untokenise(Input *file)
575	{	557	{
576	free(file->text);	558	free(file->atext);
577	free(file);	559	free(file);
578	}	560	}
Lines 607-615 Link Here
607	}	589	}
608		590
609	static Token createToken(TokenType t, char text, Token *nxt)	591	static Token createToken(TokenType t, const char text, size_t len, Token *nxt)
610	{	592	{
611	Token *tp = newToken(t);	593	Token *tp = newToken(t);
612		594
613	if ((tp->length = strlen(text)) < (sizeof(tp->little) - 1))	595	if ((tp->length = len) < (sizeof(tp->little) - 1))
614	{	596	{
615	tp->text = strcpy(tp->little, text);	597	tp->text = strcpy(tp->little, text);
Lines 617-621 Link Here
617	else	599	else
618	{	600	{
619	tp->text = newString(text);	601	tp->text = strndup(text, len);
620	}	602	}
621	tp->next = nxt;	603	tp->next = nxt;
Lines 720-724 Link Here
720	static Token handleSemi(Input, char);	702	static Token handleSemi(Input, char);
721		703
722	Token stringToken(Input file, char lst, TokenType res, int term)	704	static Token stringToken(Input file, char lst, TokenType res, int term)
723	{	705	{
724	int bufSize = 16*1024;	706	int bufSize = 16*1024;
Lines 837-841 Link Here
837		819
838		820
839	int tokEqual(Token tp, char val)	821	int tokEqual(const Token tp, const char val)
840	{	822	{
841	if (tp != noToken)	823	if (tp != noToken)
Lines 845-849 Link Here
845	case CONST:	827	case CONST:
846	case LIST :	828	case LIST :
847	return (tp->text != (char *) 0 && strcmp(tp->text, val) == 0);	829	return (tp->text != NULL && strcmp(tp->text, val) == 0);
848	default:	830	default:
849	break;	831	break;
Lines 853-857 Link Here
853	}	835	}
854		836
855	int tokNEqual(Token tp, char val, int n)	837	static int tokNEqual(const Token tp, const char val, int n)
856	{	838	{
857	if (tp != noToken)	839	if (tp != noToken)
Lines 871-875 Link Here
871	static int isPragma(TBuff *tp)	853	static int isPragma(TBuff *tp)
872	{	854	{
873	char *cp;	855	const char *cp;
874		856
875	cp = skipblank(tp->buff + 1); /* start after # character */	857	cp = skipblank(tp->buff + 1); /* start after # character */
Lines 1252-1256 Link Here
1252	static struct pragma_s	1234	static struct pragma_s
1253	{	1235	{
1254	char *text;	1236	const char *text;
1255	enum Pragmas value;	1237	enum Pragmas value;
1256	int nextmode;	1238	int nextmode;
Lines 1264-1272 Link Here
1264	{ "unused", 0, 3},	1246	{ "unused", 0, 3},
1265	{ "array", 0, 4},	1247	{ "array", 0, 4},
1266	{ (char *) 0, 0, 1},	1248	{ NULL, 0, 1},
1267	};	1249	};
1268	struct pragma_s *prp;	1250	struct pragma_s *prp;
1269	int label, mode = 1;	1251	int label, mode = 1;
1270	char *cp;	1252	const char *cp;
1271	Token token, chars = newToken(CONST);	1253	Token token, chars = newToken(CONST);
1272	Input *pfile;	1254	Input *pfile;
Lines 1348-1354 Link Here
1348	Token *hd;	1330	Token *hd;
1349		1331
1350	extern int tclop(Token, Token);
1351	extern void comment(Token *);
1352
1353	if (line == noToken)	1332	if (line == noToken)
1354	{	1333	{
Lines 1576-1580 Link Here
1576	}	1555	}
1577		1556
1578	Token accumulate(Input file, int nl)	1557	static Token accumulate(Input file, int nl)
1579	{	1558	{
1580	Token line = noToken, hd = noToken;	1559	Token line = noToken, hd = noToken;
Lines 1653-1657 Link Here
1653	}	1632	}
1654		1633
1655	static int chkVarToken(Token *token)	1634	static int chkVarToken(const Token *token)
1656	{	1635	{
1657	return (token != noToken &&	1636	return (token != noToken &&
Lines 1660-1666 Link Here
1660	}	1639	}
1661		1640
1662	int isVarToken(Token *token)	1641	int isVarToken(const Token *token)
1663	{	1642	{
1664	char *cp;	1643	const char *cp;
1665	TBuff *tb;	1644	TBuff *tb;
1666		1645
Lines 1695-1699 Link Here
1695	}	1674	}
1696		1675
1697	int isSingleCall(Token token, char proc)	1676	int isSingleCall(const Token token, const char proc)
1698	{	1677	{
1699	if (token != noToken)	1678	if (token != noToken)
Lines 1716-1720 Link Here
1716	}	1695	}
1717		1696
1718	int isSwitch(Token *token)	1697	int isSwitch(const Token *token)
1719	{	1698	{
1720	if (token != noToken)	1699	if (token != noToken)
Lines 1740-1751 Link Here
1740	}	1719	}
1741		1720
1742	Token isArray(Token tp)	1721	Token isArray(const Token tp)
1743	{	1722	{
1744	Token *res = noToken;	1723	Token *res = noToken;
1745	TBuff tbp = (TBuff ) 0;	1724	TBuff tbp = (TBuff ) 0;
1746	char txt, cp, ch;	1725	const char txt, cp;
		1726	char ch;
1747	int len;	1727	int len;
1748		1728
1749	if (tp != noToken && (tp->text != (char *) 0 \|\| tp->type == CONC))	1729	if (tp != noToken && (tp->text != NULL \|\| tp->type == CONC))
1750	{	1730	{
1751	switch (tp->type)	1731	switch (tp->type)
Lines 1777-1783 Link Here
1777	if (ch == '(')	1757	if (ch == '(')
1778	{	1758	{
1779	*cp = '\0';	1759	res = createToken(CONST, txt, cp - txt, noToken);
1780	res = createToken(CONST, txt, noToken);
1781	*cp = '(';
1782	break;	1760	break;
1783	}	1761	}
Lines 1791-1795 Link Here
1791	}	1769	}
1792		1770
1793	int constant(Token *tp)	1771	int constant(const Token *tp)
1794	{	1772	{
1795	return (tp != noToken && (tp->type == CONST \|\| tp->type == LIST));	1773	return (tp != noToken && (tp->type == CONST \|\| tp->type == LIST));

Lines 19-27 Link Here

(-)token.h (-8 / +23 lines)
19	typedef struct input_s	19	typedef struct input_s
20	{	20	{
21	char *position;	21	const char *position;
22	int remaining;	22	int remaining;
23	int pushed;	23	int pushed;
24	char back[16];	24	char back[16];
25	char *text;	25	union {
		26	const char text; / Use const in most cases */
		27	char *atext;
		28	};
26	FILE *stream;	29	FILE *stream;
27	int tcall;	30	int tcall;
Lines 49-54 Link Here
49	ConstType ckind;	52	ConstType ckind;
50	int isconc;	53	int isconc;
51	char *text;	54	union {
52	int length;	55	const char *text;
		56	char *atext;
		57	};
		58	size_t length;
53	struct token_s *sequence;	59	struct token_s *sequence;
54	struct token_s *next;	60	struct token_s *next;
Lines 70-80 Link Here
70	extern void makeCall(Token, Token);	76	extern void makeCall(Token, Token);
71	extern void body(Token *, int, int);	77	extern void body(Token *, int, int);
		78	extern void comment(Token *);
72		79
73	extern void output(Token *, int);	80	extern void output(Token *, int);
74	extern void blank(void);	81	extern void blank(void);
75	extern void warn(Token , char );	82	extern void warn(const Token , const char );
76	extern void fail(Token , char );	83	extern void fail(const Token , const char );
		84
		85	extern Token isArray(const Token );
		86	extern int constant(const Token *tp);
		87	extern int tclop(Token hd, Token line);
		88	extern void streamMore(Input *file);
		89	extern int handle(Token *line);
		90	extern void sprocess(Token *lst, int nls);
		91	extern void dumpToken(const Token tk, FILE ops);
		92	extern Token tokenPop(Token *);
		93	extern void freeToken(Token *);
77		94
78	extern Token isArray(Token );
79	extern int constant(Token *tp);
80	#endif	95	#endif




#endif

extern void warnFor(Token*, char*, char*);

void checkName(Token *cmd, int dynm)
{
    static const char *badNames[] =
    {
	".",

        (char *) 0
    };
    const char **bnp = badNames;
    char msgb[256];

    if (cmd != noToken)

}

static VarData *newVar(const char *name, enum VarType type)
{
    VarData *blp = (VarData *) malloc(sizeof(VarData));

}

static VarData *addVar(const char *name, enum VarType type, int array)
{
    VarData *vp = newVar(name, type);

}

VarData *varKnown(const char *name)
{
    List *blp = blocks;

}

VarData *declareVar(const Token *nm, enum VarType type, int array)
{
    VarData *vp = varKnown(nm->text);

}

VarData *useVar(const Token *nm, enum VarType type, int array)
{
    VarData *vp;

}

VarData *setVar(const Token *nm, enum VarType type, int array)
{
    VarData *vp;

Lines 12-16 Link Here

(-)vars.h (-5 / +5 lines)
12	*/	12	*/
13		13
14	#ifndef FRINK_VARS_h	14	#ifndef FRINK_VARS_H
15	#define FRINK_VARS_H	15	#define FRINK_VARS_H
16		16
Lines 47-54 Link Here
47		47
48	extern void checkName(Token *, int);	48	extern void checkName(Token *, int);
49	extern VarData varKnown(char );	49	extern VarData varKnown(const char );
50	extern VarData declareVar(Token , enum VarType, int);	50	extern VarData declareVar(const Token , enum VarType, int);
51	extern VarData useVar(Token , enum VarType, int);	51	extern VarData useVar(const Token , enum VarType, int);
52	extern VarData setVar(Token , enum VarType, int);	52	extern VarData setVar(const Token , enum VarType, int);
53		53
54	#endif	54	#endif

Return to bug 246163

Lines 100-101 Link Here

(-)frink.h (+14 lines)
100	extern List *skiplist;	100	extern List *skiplist;
101	extern List *blocks;	101	extern List *blocks;
		102
		103	void dumpConf(const ConfigData , FILE);
		104	void readconfig(const char *fileName);
		105	void stringconfig(const char *line);
		106	void initOutput(void);
		107	void setIndent(void);
		108	void outdent(void);
		109	int isVarToken(const Token *);
		110	int isSwitch(const Token *);
		111	int isSingleCall(const Token , const char );
		112	int tokEqual(const Token , const char );
		113	void flushOutput(void);
		114	void clearState(void);
		115	void warnFor(const Token token, const char cmd, const char *txt);

Lines 30-41 Link Here

(-)config.c (-19 / +14 lines)
30	#endif	30	#endif
31		31
32	extern Token tokenPop(Token *);
33	extern void freeToken(Token *);
34	extern void streamMore(Input *);
35
36	List *config = noList;	32	List *config = noList;
37		33
38	static struct {	34	static struct {
39	char *name;	35	const char *name;
40	ParamType code;	36	ParamType code;
41	} pvals[] ={	37	} pvals[] ={
Lines 72-79 Link Here
72	};	68	};
73		69
74	void dumpPdata(ParamData pt, FILE op)	70	static void dumpPdata(ParamData pt, FILE op)
75	{	71	{
76	int i;	72	int i;
77	char *pad;	73	const char *pad;
78	List *lp;	74	List *lp;
79		75
Lines 105-109 Link Here
105	}	101	}
106		102
107	void dumpConf(ConfigData cp, FILE op)	103	void dumpConf(const ConfigData cp, FILE op)
108	{	104	{
109	List *plp;	105	List *plp;
Lines 119-123 Link Here
119	}	115	}
120		116
121	static void pcode(ParamData ppt, char str)	117	static void pcode(ParamData ppt, const char str)
122	{	118	{
123	int i;	119	int i;
Lines 172-177 Link Here
172	SeqnData *sd;	168	SeqnData *sd;
173	void *dp;	169	void *dp;
174	extern void dumpToken(Token , FILE );	170
175
176	ppt = newpdata();	171	ppt = newpdata();
177	switch (tp->type)	172	switch (tp->type)
Lines 253-257 Link Here
253	}	248	}
254		249
255	static int handle(Token *line)	250	static int confighandle(Token *line)
256	{	251	{
257	ConfigData *cpt;	252	ConfigData *cpt;
Lines 307-315 Link Here
307	}	302	}
308		303
309	void readconfig(char *str)	304	void readconfig(const char *str)
310	{	305	{
311	FILE *fd;	306	FILE *fd;
312	Input file;	307	Input file;
313		308
314	if ((fd = fopen(str, "r")) == NULL)	309	if ((fd = fopen(str, "r")) == NULL)
315	{	310	{
Lines 320-324 Link Here
320	* use the tokenising mechanism we already have to parse the config file	315	* use the tokenising mechanism we already have to parse the config file
321	*/	316	*/
322	file.text = (char ) malloc(641024);	317	file.atext = malloc(64*1024);
323	file.stream = fd;	318	file.stream = fd;
324	file.tcall = file.texpr = 0;	319	file.tcall = file.texpr = 0;
Lines 326-338 Link Here
326	file.lineStart = 1;	321	file.lineStart = 1;
327	streamMore(&file);	322	streamMore(&file);
328	while(handle(collect(&file)))	323	while(confighandle(collect(&file)))
329	{	324	{
330	/* skip */	325	/* skip */
331	}	326	}
332	free(file.text);	327	free(file.atext);
333	fclose(fd);	328	fclose(fd);
334	}	329	}
335		330
336	void stringconfig(char *str)	331	void stringconfig(const char *str)
337	{	332	{
338	Input file;	333	Input file;
Lines 347-351 Link Here
347	file.lineNumber = 1;	342	file.lineNumber = 1;
348	file.lineStart = 1;	343	file.lineStart = 1;
349	while(handle(collect(&file)))	344	while(confighandle(collect(&file)))
350	{	345	{
351	/* skip */	346	/* skip */

Lines 29-32 Link Here

(-)frink.c (-31 / +19 lines)
29	#include <stdlib.h>	29	#include <stdlib.h>
30	#endif	30	#endif
		31	#include <unistd.h>
31		32
32	int failed = 0;	33	int failed = 0;
Lines 40-44 Link Here
40		41
41	int compout = 0;	42	int compout = 0;
42	int resvsplit = 0;	43	static int resvsplit = 0;
43	int noquotes = 0;	44	int noquotes = 0;
44	int spaceout = 0;	45	int spaceout = 0;
Lines 81-89 Link Here
81	int internat = 0;	82	int internat = 0;
82		83
83	char style = (char ) 0;	84	const char *style = NULL;
84	char pstyle = (char ) 0;	85	const char *pstyle = NULL;
85	char *contString = "";	86	const char *contString = "";
86		87
87	char locale = (char ) 0;	88	const char *locale = NULL;
88	FILE *msgfile = NULL;	89	FILE *msgfile = NULL;
89	FILE *specfile = NULL;	90	FILE *specfile = NULL;
Lines 92-108 Link Here
92	int praghold = 0;	93	int praghold = 0;
93		94
94	char currentfile = (char ) 0;	95	const char *currentfile = NULL;
95		96
96	List skiplist = (List ) 0;	97	List *skiplist = NULL;
97		98
98	#ifndef __FreeBSD__
99	extern int getopt(int, charconst, const char*);
100	#endif
101
102	extern int optind;
103	extern char *optarg;
104	extern int fclose(FILE*);
105	extern void readconfig(char *);
106	extern void stringconfig(char *);
107	extern void clearState(void);	99	extern void clearState(void);
108		100
Lines 113-117 Link Here
113	}	105	}
114		106
115	static char *languages[] =	107	static const char *languages[] =
116	{	108	{
117	"aa", /* Afar */	109	"aa", /* Afar */
Lines 257-261 Link Here
257	};	249	};
258		250
259	static char *countries[] =	251	static const char *countries[] =
260	{	252	{
261	"AF", /* AFGHANISTAN */	253	"AF", /* AFGHANISTAN */
Lines 501-509 Link Here
501	};	493	};
502		494
503	static void checkLocale(char *v)	495	static void checkLocale(const char *v)
504	{	496	{
505	int l, i, fnd = 0;;	497	int l, i, fnd = 0;;
506		498
507	for (i = 0; languages[i] != (char *) 0; i += 1)	499	for (i = 0; languages[i] != NULL; i += 1)
508	{	500	{
509	if (strncmp(v, languages[i], 2) == 0)	501	if (strncmp(v, languages[i], 2) == 0)
Lines 625-629 Link Here
625	}	617	}
626		618
627	void setOption(int flag, char *value)	619	static void setOption(int flag, const char *value)
628	{	620	{
629	int not;	621	int not;
Lines 750-756 Link Here
750	}	742	}
751		743
752	static void readrc(char *file)	744	static void readrc(const char *file)
753	{	745	{
754	char opts[50], buff[128], cp;	746	const char *opts[50];
		747	char buff[128], *cp;
755	FILE *desc;	748	FILE *desc;
756	int leng, i;	749	int leng, i;
Lines 794-804 Link Here
794	static void process(FILE *desc)	787	static void process(FILE *desc)
795	{	788	{
796	extern void flushOutput(void);
797	extern int handle(Token *line);
798	extern void streamMore(Input *);
799
800	Input file;	789	Input file;
801		790
802	file.text = (char ) malloc(641024);	791	file.atext = malloc(64*1024);
803	file.stream = desc;	792	file.stream = desc;
804	file.tcall = file.texpr = 0;	793	file.tcall = file.texpr = 0;
Lines 810-819 Link Here
810	}	799	}
811	flushOutput();	800	flushOutput();
812	free(file.text);	801	free(file.atext);
813	}	802	}
814		803
815	static void initCmds(void)	804	static void initCmds(void)
816	{	805	{
817	static char *cmdspec =	806	static const char *cmdspec =
818	"set {{var 0x0017} {ctype? 0x0001}}\n"	807	"set {{var 0x0017} {ctype? 0x0001}}\n"
819	"global {{varlist 0x0150}}\n"	808	"global {{varlist 0x0150}}\n"
Lines 970-974 Link Here
970	{	959	{
971	FILE *desc;	960	FILE *desc;
972	extern void initOutput(void);
973		961
974	initCmds();	962	initCmds();

Lines 44-51 Link Here

(-)output.c (-12 / +12 lines)
44	static TokenType olast = HEAD;	44	static TokenType olast = HEAD;
45		45
46	static Token nlToken = {BLANK, CNSTWORD, 0, (char ) 0, 0, (Token ) 0, (Token *) 0};	46	static Token nlToken = {.type = BLANK, .ckind = CNSTWORD};
47	static Token startToken = {START, CNSTWORD, 0, (char ) 0, 0, (Token ) 0, (Token *) 0};	47	static Token startToken = {.type = START, .ckind = CNSTWORD};
48	static Token contToken = {CONT, CNSTWORD, 0, (char ) 0, 0, (Token ) 0, (Token *) 0};	48	static Token contToken = {.type = CONT, .ckind = CNSTWORD};
49	static Token spToken = {SP, CNSTWORD, 0, " ", 1, (Token ) 0, (Token ) 0};	49	static Token spToken = {.type = SP, .ckind = CNSTWORD, .text = " ", .length = 1};
50		50
51	void initOutput(void)	51	void initOutput(void)
Lines 227-231 Link Here
227	}	227	}
228		228
229	static void printkn(char *txt, int length, int keepnl)	229	static void printkn(const char *txt, int length, int keepnl)
230	{	230	{
231	char *cp;	231	char *cp;
Lines 252-256 Link Here
252	}	252	}
253		253
254	static void printn(char *txt, int len)	254	static void printn(const char *txt, int len)
255	{	255	{
256	if (!testonly)	256	if (!testonly)
Lines 260-269 Link Here
260	}	260	}
261		261
262	static void print(char *txt)	262	static void print(const char *txt)
263	{	263	{
264	printn(txt, strlen(txt));	264	printn(txt, strlen(txt));
265	}	265	}
266		266
267	static void brace(char *t)	267	static void brace(const char *t)
268	{	268	{
269	char cp, bp;	269	char cp, bp;
Lines 378-385 Link Here
378	}	378	}
379		379
380	static Token dollarToken = {DOLLAR, CNSTWORD, 0, (char ) 0, 0, (Token ) 0, (Token *) 0};	380	static Token dollarToken = {.type = DOLLAR, .ckind = CNSTWORD};
381	static Token endlineToken = {ENDLINE, CNSTWORD, 0, (char ) 0, 0, (Token ) 0, (Token *) 0};	381	static Token endlineToken = {.type = ENDLINE, .ckind = CNSTWORD};
382	static Token lbrackToken = {LBRACK, CNSTWORD, 0, (char ) 0, 0, (Token ) 0, (Token *) 0};	382	static Token lbrackToken = {.type = LBRACK, .ckind = CNSTWORD};
383	static Token rbrackToken = {RBRACK, CNSTWORD, 0, (char ) 0, 0, (Token ) 0, (Token *) 0};	383	static Token rbrackToken = {.type = RBRACK, .ckind = CNSTWORD};
384		384
385	void output(Token *token, int compress)	385	void output(Token *token, int compress)

Lines 33-41 Link Here

(-)vars.c (-10 / +9 lines)
33	#endif	33	#endif
34		34
35	extern void warnFor(Token, char, char*);
36
37	void checkName(Token *cmd, int dynm)	35	void checkName(Token *cmd, int dynm)
38	{	36	{
39	static char *badNames[] =	37	static const char *badNames[] =
40	{	38	{
41	".",	39	".",
Lines 159-163 Link Here
159	(char *) 0	157	(char *) 0
160	};	158	};
161	char **bnp = badNames, msgb[256];	159	const char **bnp = badNames;
		160	char msgb[256];
162		161
163	if (cmd != noToken)	162	if (cmd != noToken)
Lines 199-203 Link Here
199	}	198	}
200		199
201	static VarData newVar(char name, enum VarType type)	200	static VarData newVar(const char name, enum VarType type)
202	{	201	{
203	VarData blp = (VarData ) malloc(sizeof(VarData));	202	VarData blp = (VarData ) malloc(sizeof(VarData));
Lines 212-216 Link Here
212	}	211	}
213		212
214	static VarData addVar(char name, enum VarType type, int array)	213	static VarData addVar(const char name, enum VarType type, int array)
215	{	214	{
216	VarData *vp = newVar(name, type);	215	VarData *vp = newVar(name, type);
Lines 221-225 Link Here
221	}	220	}
222		221
223	VarData varKnown(char name)	222	VarData varKnown(const char name)
224	{	223	{
225	List *blp = blocks;	224	List *blp = blocks;
Lines 246-250 Link Here
246	}	245	}
247		246
248	VarData declareVar(Token nm, enum VarType type, int array)	247	VarData declareVar(const Token nm, enum VarType type, int array)
249	{	248	{
250	VarData *vp = varKnown(nm->text);	249	VarData *vp = varKnown(nm->text);
Lines 269-273 Link Here
269	}	268	}
270		269
271	VarData useVar(Token nm, enum VarType type, int array)	270	VarData useVar(const Token nm, enum VarType type, int array)
272	{	271	{
273	VarData *vp;	272	VarData *vp;
Lines 299-303 Link Here
299	}	298	}
300		299
301	VarData setVar(Token nm, enum VarType type, int array)	300	VarData setVar(const Token nm, enum VarType type, int array)
302	{	301	{
303	VarData *vp;	302	VarData *vp;