vrtc / pjass (public) (License: BSD) (since 2023-08-03) (hash sha1)
pjass is a free Jass scripting language parser. This repository is a fork of lep/pjass. The goal is to add Debian packaging. As of the time of this writing, it works for current stable, that is Debian 12 (bookworm).
Clone URLs: https://rocketgit.com/user/vrtc/pjass ssh://rocketgit@ssh.rocketgit.com/user/vrtc/pjass git://git.rocketgit.com/user/vrtc/pjass
master upstream
List of commits:
Subject Hash Author Date (UTC)
Added +nosyntaxerror and +nosemanticerror e755e12b3cab1d5069574e34d22633dd420bb230 lep 2016-05-07 13:42:57
Added +shadow description to -h 6a62b1ecf773175992a2a430a178fffb5532e467 lep 2016-03-13 19:35:20
Reduced duplicate code from variable decleration. 01d6f01ebf7c2df9f58aea1bba61bae8a270b520 lep 2016-03-13 19:03:34
Added optional variable shadowing warning. 2a0b36f50d2850c4c2ff09f503e6ffad6abf58d9 lep 2016-03-13 14:30:36
Removed the +s and +e<n> flags. 4ab97e853531f2767136602d88c6a86897089eea lep 2016-03-13 10:52:37
Added help target to Makefile a713b03be873950d11e62a7b9e4f2d9a8d2e0945 lep 2016-03-03 16:02:34
Removed strict downcasting check. 5f6ffd725b2ac9d24eff5917d96ceeeaaf748e5f lep 2016-03-03 16:00:49
Added filterreturnsbool check which can be enabled via //# filter 6828cb5e726e7f57cad0ec3f794209c2012c7908 lep 2016-03-03 15:58:59
Moved code into seperate files. 047c531a1c3affb43f53d102c94e765d772ecff3 lep 2016-02-17 20:57:30
Also pack testfiles into the release zip. e2d8ca45c7175b4f0192ddb6202ae71059369495 lep 2016-02-01 15:15:03
Fixed all Warnings. 981e0b8b51eebb4904a42c58c825fa10185f5d23 lep 2016-02-01 15:12:38
Added a test which checks if the utf8-bom can be used as whitespace. cb0ebe275982a65a2ebbd4aca831da4e31739eba lep 2016-01-31 15:04:12
Added utf8 bom as another whitespace token. ea1572ceaa7743fcdff89f206e24540df6358e7b lep 2016-01-31 13:23:27
Added tests to the git repo. 6aca6f760084ee65f8cdd469b18ad5cb37c42ee3 lep 2016-01-17 10:44:56
FreeBsd patches. 6c3acc1dff6ecd5fa486506fabed077be5347afc lep 2016-01-17 10:23:48
Cleaned up string and comment handling in the lexer ebec6e67e248bef82bf92416733b394399c4e1d4 lep 2016-01-17 09:51:44
Added \r, \n (\x10, \x13) as invalid escape characters. 85d0c7e4453c1879bcbc4db8be28527c5ce9f4f7 lep 2016-01-06 13:16:49
Fixed another rare crash. b6edcc3cfd5c1c837318b0efa5ded6f16e86b403 lep 2015-12-21 19:02:41
Fixed various warnings. 6027429ad1895baef4796ac4ae43952ed51f6174 lep 2015-10-28 09:27:40
Added prof target to makefile 9c4b383d3f7416a30a8bde79c735097edaf8d84a lep 2015-10-27 19:14:20
Commit e755e12b3cab1d5069574e34d22633dd420bb230 - Added +nosyntaxerror and +nosemanticerror
These are quite the sledgehammers -- +nosyntaxerror even more so -- but
it is useful when trying to exploit errors in warcrafts jass parser.

Also added +filter to the help message.
Author: lep
Author date (UTC): 2016-05-07 13:42
Committer name: lep
Committer date (UTC): 2016-05-07 13:42
Parent(s): 6a62b1ecf773175992a2a430a178fffb5532e467
Signer:
Signing key:
Signing status: N
Tree: 3b761c815baa4c18c7ba576320eee3ca3c0f3c13
File Lines added Lines deleted
Makefile 1 1
grammar.y 53 53
main.c 16 8
misc.c 42 41
misc.h 4 2
tests/should-fail/filter-annotation.j 15 0
token.l 22 22
File Makefile changed (mode: 100644) (index f7552ff..71e9a86)
1 CFLAGS = -O3 -Wall -Wextra -std=c11 -MMD -Weverything
1 CFLAGS = -O3 -Wall -Wextra -MMD -Weverything
2 2 VERSION := $(shell git rev-parse --short HEAD) VERSION := $(shell git rev-parse --short HEAD)
3 3
4 4 # when testing and releasing, we can't run both in parallel # when testing and releasing, we can't run both in parallel
File grammar.y changed (mode: 100644) (index 7d1cfd1..bfa2fb6)
... ... funcdefns: /* empty */
107 107
108 108 globdefs: /* empty */ globdefs: /* empty */
109 109 | GLOBALS newline vardecls ENDGLOBALS endglobalsmarker | GLOBALS newline vardecls ENDGLOBALS endglobalsmarker
110 | GLOBALS vardecls ENDGLOBALS endglobalsmarker {yyerrorline(0, lineno - 1, "Missing linebreak before global declaration");}
110 | GLOBALS vardecls ENDGLOBALS endglobalsmarker {yyerrorline(syntaxerror, lineno - 1, "Missing linebreak before global declaration");}
111 111 ; ;
112 112
113 113 endglobalsmarker: /* empty */ {afterendglobals = 1;} endglobalsmarker: /* empty */ {afterendglobals = 1;}
 
... ... expr: intexpr { $$.ty = gInteger; }
147 147 char ebuf[1024]; char ebuf[1024];
148 148 snprintf(ebuf, 1024, "Undefined function %s", $2.str); snprintf(ebuf, 1024, "Undefined function %s", $2.str);
149 149 getsuggestions($2.str, ebuf, 1024, 1, &functions); getsuggestions($2.str, ebuf, 1024, 1, &functions);
150 yyerrorex(3, ebuf);
150 yyerrorex(semanticerror, ebuf);
151 151 $$.ty = gCode; $$.ty = gCode;
152 152 } else { } else {
153 153 if (fd->p->head != NULL) { if (fd->p->head != NULL) {
154 154 char ebuf[1024]; char ebuf[1024];
155 155 snprintf(ebuf, 1024, "Function %s must not take any arguments when used as code", $2.str); snprintf(ebuf, 1024, "Function %s must not take any arguments when used as code", $2.str);
156 yyerrorex(3, ebuf);
156 yyerrorex(semanticerror, ebuf);
157 157 } }
158 158 if( fd->ret == gBoolean) { if( fd->ret == gBoolean) {
159 159 $$.ty = gCodeReturnsBoolean; $$.ty = gCodeReturnsBoolean;
 
... ... expr: intexpr { $$.ty = gInteger; }
189 189 if (!tan->isarray) { if (!tan->isarray) {
190 190 char ebuf[1024]; char ebuf[1024];
191 191 snprintf(ebuf, 1024, "%s not an array", $1.str); snprintf(ebuf, 1024, "%s not an array", $1.str);
192 yyerrorex(3, ebuf);
192 yyerrorex(semanticerror, ebuf);
193 193 } }
194 194 else { else {
195 195 canconvert($3.ty, gInteger, 0); canconvert($3.ty, gInteger, 0);
 
... ... expr: intexpr { $$.ty = gInteger; }
202 202 if (tan->lineno == lineno && tan->fn == fno) { if (tan->lineno == lineno && tan->fn == fno) {
203 203 char ebuf[1024]; char ebuf[1024];
204 204 snprintf(ebuf, 1024, "Use of variable %s before its declaration", $1.str); snprintf(ebuf, 1024, "Use of variable %s before its declaration", $1.str);
205 yyerrorex(3, ebuf);
205 yyerrorex(semanticerror, ebuf);
206 206 } else if (islinebreak && tan->lineno == lineno - 1 && tan->fn == fno) { } else if (islinebreak && tan->lineno == lineno - 1 && tan->fn == fno) {
207 207 char ebuf[1024]; char ebuf[1024];
208 208 snprintf(ebuf, 1024, "Use of variable %s before its declaration", $1.str); snprintf(ebuf, 1024, "Use of variable %s before its declaration", $1.str);
209 yyerrorline(3, lineno - 1, ebuf);
209 yyerrorline(semanticerror, lineno - 1, ebuf);
210 210 } else if (tan->isarray) { } else if (tan->isarray) {
211 211 char ebuf[1024]; char ebuf[1024];
212 212 snprintf(ebuf, 1024, "Index missing for array variable %s", $1.str); snprintf(ebuf, 1024, "Index missing for array variable %s", $1.str);
213 yyerrorex(3, ebuf);
213 yyerrorex(semanticerror, ebuf);
214 214 } }
215 215 if(infunction && ht_lookup(curtab, $1.str) && !ht_lookup(&initialized, $1.str) ){ if(infunction && ht_lookup(curtab, $1.str) && !ht_lookup(&initialized, $1.str) ){
216 216 char ebuf[1024]; char ebuf[1024];
217 217 snprintf(ebuf, 1024, "Variable %s is uninitialized", $1.str); snprintf(ebuf, 1024, "Variable %s is uninitialized", $1.str);
218 218 //yyerrorex(3, ebuf); //yyerrorex(3, ebuf);
219 yyerrorline(3, lineno - 1, ebuf);
219 yyerrorline(semanticerror, lineno - 1, ebuf);
220 220 } }
221 221 $$.ty = tan->ty; $$.ty = tan->ty;
222 222 } }
223 | expr EQUALS expr {yyerrorex(0, "Single = in expression, should probably be =="); checkeqtest($1.ty, $3.ty); $$.ty = gBoolean;}
224 | LPAREN expr {yyerrorex(0, "Mssing ')'"); $$.ty = $2.ty;}
223 | expr EQUALS expr {yyerrorex(syntaxerror, "Single = in expression, should probably be =="); checkeqtest($1.ty, $3.ty); $$.ty = gBoolean;}
224 | LPAREN expr {yyerrorex(syntaxerror, "Mssing ')'"); $$.ty = $2.ty;}
225 225
226 226 // incomplete expressions // incomplete expressions
227 | expr LEQ { checkcomparisonsimple($1.ty); yyerrorex(3, "Missing expression for comparison"); $$.ty = gBoolean; }
228 | expr GEQ { checkcomparisonsimple($1.ty); yyerrorex(3, "Missing expression for comparison"); $$.ty = gBoolean; }
229 | expr LESS { checkcomparisonsimple($1.ty); yyerrorex(3, "Missing expression for comparison"); $$.ty = gBoolean; }
230 | expr GREATER { checkcomparisonsimple($1.ty); yyerrorex(3, "Missing expression for comparison"); $$.ty = gBoolean; }
231 | expr EQCOMP { yyerrorex(3, "Missing expression for comparison"); $$.ty = gBoolean; }
232 | expr NEQ { yyerrorex(3, "Missing expression for comparison"); $$.ty = gBoolean; }
233 | expr AND { canconvert($1.ty, gBoolean, 0); yyerrorex(3, "Missing expression for logical and"); $$.ty = gBoolean; }
234 | expr OR { canconvert($1.ty, gBoolean, 0); yyerrorex(3, "Missing expression for logical or"); $$.ty = gBoolean; }
235 | NOT { yyerrorex(3, "Missing expression for logical negation"); $$.ty = gBoolean; }
227 | expr LEQ { checkcomparisonsimple($1.ty); yyerrorex(syntaxerror, "Missing expression for comparison"); $$.ty = gBoolean; }
228 | expr GEQ { checkcomparisonsimple($1.ty); yyerrorex(syntaxerror, "Missing expression for comparison"); $$.ty = gBoolean; }
229 | expr LESS { checkcomparisonsimple($1.ty); yyerrorex(syntaxerror, "Missing expression for comparison"); $$.ty = gBoolean; }
230 | expr GREATER { checkcomparisonsimple($1.ty); yyerrorex(syntaxerror, "Missing expression for comparison"); $$.ty = gBoolean; }
231 | expr EQCOMP { yyerrorex(syntaxerror, "Missing expression for comparison"); $$.ty = gBoolean; }
232 | expr NEQ { yyerrorex(syntaxerror, "Missing expression for comparison"); $$.ty = gBoolean; }
233 | expr AND { canconvert($1.ty, gBoolean, 0); yyerrorex(syntaxerror, "Missing expression for logical and"); $$.ty = gBoolean; }
234 | expr OR { canconvert($1.ty, gBoolean, 0); yyerrorex(syntaxerror, "Missing expression for logical or"); $$.ty = gBoolean; }
235 | NOT { yyerrorex(syntaxerror, "Missing expression for logical negation"); $$.ty = gBoolean; }
236 236 ; ;
237 237
238 238 funccall: rid LPAREN exprlistcompl RPAREN { funccall: rid LPAREN exprlistcompl RPAREN {
239 239 $$ = checkfunccall($1.str, $3.pl); $$ = checkfunccall($1.str, $3.pl);
240 240 } }
241 241 | rid LPAREN exprlistcompl newline { | rid LPAREN exprlistcompl newline {
242 yyerrorex(0, "Missing ')'");
242 yyerrorex(syntaxerror, "Missing ')'");
243 243 $$ = checkfunccall($1.str, $3.pl); $$ = checkfunccall($1.str, $3.pl);
244 244 } }
245 245 ; ;
 
... ... nativefuncdecl: NATIVE rid TAKES optparam_list RETURNS opttype
281 281 if (ht_lookup(&locals, $2.str) || ht_lookup(&params, $2.str) || ht_lookup(&globals, $2.str)) { if (ht_lookup(&locals, $2.str) || ht_lookup(&params, $2.str) || ht_lookup(&globals, $2.str)) {
282 282 char buf[1024]; char buf[1024];
283 283 snprintf(buf, 1024, "%s already defined as variable", $2.str); snprintf(buf, 1024, "%s already defined as variable", $2.str);
284 yyerrorex(3, buf);
284 yyerrorex(semanticerror, buf);
285 285 } else if (ht_lookup(&types, $2.str)) { } else if (ht_lookup(&types, $2.str)) {
286 286 char buf[1024]; char buf[1024];
287 287 snprintf(buf, 1024, "%s already defined as type", $2.str); snprintf(buf, 1024, "%s already defined as type", $2.str);
288 yyerrorex(3, buf);
288 yyerrorex(semanticerror, buf);
289 289 } }
290 290 $$.fd = newfuncdecl(); $$.fd = newfuncdecl();
291 291 $$.fd->name = strdup($2.str); $$.fd->name = strdup($2.str);
 
... ... nativefuncdecl: NATIVE rid TAKES optparam_list RETURNS opttype
306 306
307 307 funcdefn: newline funcdefn: newline
308 308 | funcdefncore | funcdefncore
309 | statement { yyerrorex(0, "Statement outside of function"); }
309 | statement { yyerrorex(syntaxerror, "Statement outside of function"); }
310 310 ; ;
311 311
312 312 funcdefncore: funcbegin localblock codeblock funcend { funcdefncore: funcbegin localblock codeblock funcend {
313 313 if(retval != gNothing) { if(retval != gNothing) {
314 314 if(!getTypeTag($3.ty)) if(!getTypeTag($3.ty))
315 yyerrorline(1, lineno - 1, "Missing return");
315 yyerrorline(semanticerror, lineno - 1, "Missing return");
316 316 else if ( flagenabled(flag_rb) ) else if ( flagenabled(flag_rb) )
317 317 canconvertreturn($3.ty, retval, -1); canconvertreturn($3.ty, retval, -1);
318 318 } }
319 319 fnannotations = 0; fnannotations = 0;
320 320 } }
321 | funcbegin localblock codeblock {yyerrorex(0, "Missing endfunction"); ht_clear(&params); ht_clear(&locals); ht_clear(&initialized); curtab = &globals; fnannotations = 0;}
321 | funcbegin localblock codeblock {yyerrorex(syntaxerror, "Missing endfunction"); ht_clear(&params); ht_clear(&locals); ht_clear(&initialized); curtab = &globals; fnannotations = 0;}
322 322 ; ;
323 323
324 324 funcend: ENDFUNCTION { ht_clear(&params); ht_clear(&locals); ht_clear(&initialized); curtab = &globals; inblock = 0; inconstant = 0; infunction = 0; } funcend: ENDFUNCTION { ht_clear(&params); ht_clear(&locals); ht_clear(&initialized); curtab = &globals; inblock = 0; inconstant = 0; infunction = 0; }
325 325 ; ;
326 326
327 327 returnorreturns: RETURNS returnorreturns: RETURNS
328 | RETURN {yyerrorex(3,"Expected \"returns\" instead of \"return\"");}
328 | RETURN {yyerrorex(syntaxerror,"Expected \"returns\" instead of \"return\"");}
329 329 ; ;
330 330
331 331 funcbegin: FUNCTION rid TAKES optparam_list returnorreturns opttype { funcbegin: FUNCTION rid TAKES optparam_list returnorreturns opttype {
 
... ... statement: newline { $$.ty = gEmpty; }
361 361 | SET rid EQUALS expr newline { if (getVariable($2.str)->isarray) { | SET rid EQUALS expr newline { if (getVariable($2.str)->isarray) {
362 362 char ebuf[1024]; char ebuf[1024];
363 363 snprintf(ebuf, 1024, "Index missing for array variable %s", $2.str); snprintf(ebuf, 1024, "Index missing for array variable %s", $2.str);
364 yyerrorline(3, lineno - 1, ebuf);
364 yyerrorline(semanticerror, lineno - 1, ebuf);
365 365 } }
366 366 canconvert($4.ty, getVariable($2.str)->ty, -1); canconvert($4.ty, getVariable($2.str)->ty, -1);
367 367 $$.ty = gAny; $$.ty = gAny;
368 368 if (getVariable($2.str)->isconst) { if (getVariable($2.str)->isconst) {
369 369 char ebuf[1024]; char ebuf[1024];
370 370 snprintf(ebuf, 1024, "Cannot assign to constant %s", $2.str); snprintf(ebuf, 1024, "Cannot assign to constant %s", $2.str);
371 yyerrorline(3, lineno - 1, ebuf);
371 yyerrorline(semanticerror, lineno - 1, ebuf);
372 372 } }
373 373 if (inconstant) if (inconstant)
374 374 validateGlobalAssignment($2.str); validateGlobalAssignment($2.str);
 
... ... statement: newline { $$.ty = gEmpty; }
384 384 if (!tan->isarray) { if (!tan->isarray) {
385 385 char ebuf[1024]; char ebuf[1024];
386 386 snprintf(ebuf, 1024, "%s is not an array", $2.str); snprintf(ebuf, 1024, "%s is not an array", $2.str);
387 yyerrorline(3, lineno - 1, ebuf);
387 yyerrorline(semanticerror, lineno - 1, ebuf);
388 388 } }
389 389 canconvert($7.ty, tan->ty, -1); canconvert($7.ty, tan->ty, -1);
390 390 if (inconstant) if (inconstant)
 
... ... statement: newline { $$.ty = gEmpty; }
392 392 } }
393 393 } }
394 394 | loopstart newline codeblock loopend newline {$$.ty = $3.ty;} | loopstart newline codeblock loopend newline {$$.ty = $3.ty;}
395 | loopstart newline codeblock {$$.ty = $3.ty; yyerrorex(0, "Missing endloop");}
396 | EXITWHEN expr newline { canconvert($2.ty, gBoolean, -1); if (!inloop) yyerrorline(0, lineno - 1, "Exitwhen outside of loop"); $$.ty = gAny;}
395 | loopstart newline codeblock {$$.ty = $3.ty; yyerrorex(syntaxerror, "Missing endloop");}
396 | EXITWHEN expr newline { canconvert($2.ty, gBoolean, -1); if (!inloop) yyerrorline(syntaxerror, lineno - 1, "Exitwhen outside of loop"); $$.ty = gAny;}
397 397 | RETURN expr newline { | RETURN expr newline {
398 398 $$.ty = mkretty($2.ty, 1); $$.ty = mkretty($2.ty, 1);
399 399 if(retval == gNothing) if(retval == gNothing)
400 yyerrorline(1, lineno - 1, "Cannot return value from function that returns nothing");
400 yyerrorline(semanticerror, lineno - 1, "Cannot return value from function that returns nothing");
401 401 else if (! flagenabled(flag_rb) ) else if (! flagenabled(flag_rb) )
402 402 canconvertreturn($2.ty, retval, 0); canconvertreturn($2.ty, retval, 0);
403 403 } }
404 404 | RETURN newline { | RETURN newline {
405 405 if (retval != gNothing) if (retval != gNothing)
406 yyerrorline(1, lineno - 1, "Return nothing in function that should return value");
406 yyerrorline(semanticerror, lineno - 1, "Return nothing in function that should return value");
407 407 $$.ty = mkretty(gAny, 1); $$.ty = mkretty(gAny, 1);
408 408 } }
409 409 | DEBUG statement {$$.ty = gAny;} | DEBUG statement {$$.ty = gAny;}
 
... ... statement: newline { $$.ty = gEmpty; }
411 411 | IF expr THEN newline codeblock elsifseq elseseq { | IF expr THEN newline codeblock elsifseq elseseq {
412 412 canconvert($2.ty, gBoolean, -1); canconvert($2.ty, gBoolean, -1);
413 413 $$.ty = combinetype($5.ty, combinetype($6.ty, $7.ty)); $$.ty = combinetype($5.ty, combinetype($6.ty, $7.ty));
414 yyerrorex(0, "Missing endif");
414 yyerrorex(syntaxerror, "Missing endif");
415 415 } }
416 416 | IF expr newline { | IF expr newline {
417 417 canconvert($2.ty, gBoolean, -1); canconvert($2.ty, gBoolean, -1);
418 418 $$.ty = gAny; $$.ty = gAny;
419 yyerrorex(0, "Missing then or non valid expression");
419 yyerrorex(syntaxerror, "Missing then or non valid expression");
420 420 } }
421 | SET funccall newline{ $$.ty = gAny; yyerrorline(0, lineno - 1, "Call expected instead of set");}
421 | SET funccall newline{ $$.ty = gAny; yyerrorline(semanticerror, lineno - 1, "Call expected instead of set");}
422 422 | lvardecl { | lvardecl {
423 423 $$.ty = gAny; $$.ty = gAny;
424 yyerrorex(0, "Local declaration after first statement");
424 yyerrorex(semanticerror, "Local declaration after first statement");
425 425 } }
426 426 | error {$$.ty = gAny; } | error {$$.ty = gAny; }
427 427 ; ;
 
... ... vartypedecl: type rid {
477 477 } }
478 478 | CONSTANT type rid { | CONSTANT type rid {
479 479 if (infunction) { if (infunction) {
480 yyerrorex(3, "Local constants are not allowed");
480 yyerrorex(semanticerror, "Local constants are not allowed");
481 481 } }
482 482 struct typeandname *tan = newtypeandname($2.ty, $3.str); struct typeandname *tan = newtypeandname($2.ty, $3.str);
483 483 tan->isconst = 1; tan->isconst = 1;
 
... ... vartypedecl: type rid {
492 492
493 493 // using "type" as variable name // using "type" as variable name
494 494 | type TYPE { | type TYPE {
495 yyerrorex(3, "Invalid variable name \"type\"");
495 yyerrorex(syntaxerror, "Invalid variable name \"type\"");
496 496 struct typeandname *tan = newtypeandname($1.ty, "type"); struct typeandname *tan = newtypeandname($1.ty, "type");
497 497 $$ = checkvardecl(tan); $$ = checkvardecl(tan);
498 498 } }
499 499
500 500 | CONSTANT type TYPE { | CONSTANT type TYPE {
501 501 if (infunction) { if (infunction) {
502 yyerrorex(3, "Local constants are not allowed");
502 yyerrorex(semanticerror, "Local constants are not allowed");
503 503 } }
504 yyerrorex(3, "Invalid variable name \"type\"");
504 yyerrorex(syntaxerror, "Invalid variable name \"type\"");
505 505 struct typeandname *tan = newtypeandname($2.ty, "type"); struct typeandname *tan = newtypeandname($2.ty, "type");
506 506 tan->isconst = 1; tan->isconst = 1;
507 507 $$ = checkvardecl(tan); $$ = checkvardecl(tan);
508 508 } }
509 509 | type ARRAY TYPE { | type ARRAY TYPE {
510 yyerrorex(3, "Invalid variable name \"type\"");
510 yyerrorex(syntaxerror, "Invalid variable name \"type\"");
511 511 struct typeandname *tan = newtypeandname($1.ty, "type"); struct typeandname *tan = newtypeandname($1.ty, "type");
512 512 tan->isarray = 1; tan->isarray = 1;
513 513 $$ = checkarraydecl(tan); $$ = checkarraydecl(tan);
 
... ... endlocalsmarker: /* empty */ { fCurrent = 0; }
524 524 ; ;
525 525
526 526 lvardecl: LOCAL vardecl { } lvardecl: LOCAL vardecl { }
527 | CONSTANT LOCAL vardecl { yyerrorex(3, "Local variables can not be declared constant"); }
528 | typedef { yyerrorex(3,"Types can not be extended inside functions"); }
527 | CONSTANT LOCAL vardecl { yyerrorex(syntaxerror, "Local variables can not be declared constant"); }
528 | typedef { yyerrorex(syntaxerror,"Types can not be extended inside functions"); }
529 529 ; ;
530 530
531 531 vardecl: vartypedecl newline { vardecl: vartypedecl newline {
532 532 const struct typeandname *tan = getVariable($1.str); const struct typeandname *tan = getVariable($1.str);
533 533 if (tan->isconst) { if (tan->isconst) {
534 yyerrorline(3, lineno - 1, "Constants must be initialized");
534 yyerrorline(syntaxerror, lineno - 1, "Constants must be initialized");
535 535 } }
536 536 if(infunction && flagenabled(flag_shadowing) ){ if(infunction && flagenabled(flag_shadowing) ){
537 537 if( ht_lookup(&globals, tan->name)){ if( ht_lookup(&globals, tan->name)){
538 538 char buf[1024]; char buf[1024];
539 539 snprintf(buf, 1024, "Local variable %s shadows global variable", tan->name); snprintf(buf, 1024, "Local variable %s shadows global variable", tan->name);
540 yyerrorline(3, lineno -1, buf);
540 yyerrorline(semanticerror, lineno -1, buf);
541 541 } else if( ht_lookup(&params, tan->name)){ } else if( ht_lookup(&params, tan->name)){
542 542 char buf[1024]; char buf[1024];
543 543 snprintf(buf, 1024, "Local variable %s shadows parameter", tan->name); snprintf(buf, 1024, "Local variable %s shadows parameter", tan->name);
544 yyerrorline(3, lineno -1, buf);
544 yyerrorline(semanticerror, lineno -1, buf);
545 545 } }
546 546 } }
547 547 $$.ty = gNothing; $$.ty = gNothing;
 
... ... vardecl: vartypedecl newline {
549 549 | vartypedecl EQUALS expr newline { | vartypedecl EQUALS expr newline {
550 550 const struct typeandname *tan = getVariable($1.str); const struct typeandname *tan = getVariable($1.str);
551 551 if (tan->isarray) { if (tan->isarray) {
552 yyerrorex(3, "Arrays cannot be directly initialized");
552 yyerrorex(syntaxerror, "Arrays cannot be directly initialized");
553 553 } }
554 554 if(infunction && !ht_lookup(&initialized, tan->name)){ if(infunction && !ht_lookup(&initialized, tan->name)){
555 555 put(&initialized, tan->name, (void*)1); put(&initialized, tan->name, (void*)1);
 
... ... vardecl: vartypedecl newline {
558 558 if( ht_lookup(&globals, tan->name)){ if( ht_lookup(&globals, tan->name)){
559 559 char buf[1024]; char buf[1024];
560 560 snprintf(buf, 1024, "Local variable %s shadows global variable", tan->name); snprintf(buf, 1024, "Local variable %s shadows global variable", tan->name);
561 yyerror(buf);
561 yyerrorex(semanticerror, buf);
562 562 } else if( ht_lookup(&params, tan->name)){ } else if( ht_lookup(&params, tan->name)){
563 563 char buf[1024]; char buf[1024];
564 564 snprintf(buf, 1024, "Local variable %s shadows parameter", tan->name); snprintf(buf, 1024, "Local variable %s shadows parameter", tan->name);
565 yyerror(buf);
565 yyerrorex(semanticerror, buf);
566 566 } }
567 567 } }
568 568 canconvert($3.ty, tan->ty, -1); canconvert($3.ty, tan->ty, -1);
 
... ... typedef: TYPE rid EXTENDS type {
575 575 if (ht_lookup(&types, $2.str)) { if (ht_lookup(&types, $2.str)) {
576 576 char buf[1024]; char buf[1024];
577 577 snprintf(buf, 1024, "Multiply defined type %s", $2.str); snprintf(buf, 1024, "Multiply defined type %s", $2.str);
578 yyerrorex(3, buf);
578 yyerrorex(semanticerror, buf);
579 579 } else if (ht_lookup(&functions, $2.str)) { } else if (ht_lookup(&functions, $2.str)) {
580 580 char buf[1024]; char buf[1024];
581 581 snprintf(buf, 1024, "%s already defined as function", $2.str); snprintf(buf, 1024, "%s already defined as function", $2.str);
582 yyerrorex(3, buf);
582 yyerrorex(semanticerror, buf);
583 583 } }
584 584 else else
585 585 put(&types, $2.str, newtypenode($2.str, $4.ty)); put(&types, $2.str, newtypenode($2.str, $4.ty));
 
... ... type: primtype { $$.ty = $1.ty; }
595 595 char buf[1024]; char buf[1024];
596 596 snprintf(buf, 1024, "Undefined type %s", $1.str); snprintf(buf, 1024, "Undefined type %s", $1.str);
597 597 getsuggestions($1.str, buf, 1024, 1, &types); getsuggestions($1.str, buf, 1024, 1, &types);
598 yyerrorex(3, buf);
598 yyerrorex(semanticerror, buf);
599 599 $$.ty = gAny; $$.ty = gAny;
600 600 } }
601 601 else else
File main.c changed (mode: 100644) (index 628ac44..05c7568)
... ... static void init()
66 66 ht_put(&available_flags, "rb", (void*)flag_rb); ht_put(&available_flags, "rb", (void*)flag_rb);
67 67 ht_put(&available_flags, "shadow", (void*)flag_shadowing); ht_put(&available_flags, "shadow", (void*)flag_shadowing);
68 68 ht_put(&available_flags, "filter", (void*)flag_filter); ht_put(&available_flags, "filter", (void*)flag_filter);
69 ht_put(&available_flags, "nosyntaxerror", (void*)flag_syntaxerror);
70 ht_put(&available_flags, "nosemanticerror", (void*)flag_semanticerror);
69 71 } }
70 72
71 73 static void dofile(FILE *fp, const char *name) static void dofile(FILE *fp, const char *name)
 
... ... printf(
115 117 "To test this program, go into your Scripts directory, and type:\n" "To test this program, go into your Scripts directory, and type:\n"
116 118 "pjass common.j common.ai Blizzard.j\n" "pjass common.j common.ai Blizzard.j\n"
117 119 "pjass accepts some options:\n" "pjass accepts some options:\n"
118 "pjass -h Display this help\n"
119 "pjass -v Display version information and exit\n"
120 "pjass +rb Enable returnbug\n"
121 "pjass -rb Disable returnbug\n"
122 "pjass +shadow Enable error on variable shadowing\n"
123 "pjass -shadow Disable error on variable shadowing\n"
120 "pjass -h Display this help\n"
121 "pjass -v Display version information and exit\n"
122 "pjass +rb Enable returnbug\n"
123 "pjass -rb Disable returnbug\n"
124 "pjass +shadow Enable error on variable shadowing\n"
125 "pjass -shadow Disable error on variable shadowing\n"
126 "pjass +filter Enable error on inappropriate code usage for Filter\n"
127 "pjass -filter Disable error on inappropriate code usage for Filter\n"
128 "pjass +nosyntaxerror Disable all syntax errors\n"
129 "pjass -nosyntaxerror Enable syntax error reporting\n"
130 "pjass +nosemanticerror Disable all semantic errors\n"
131 "pjass -nosemanticerror Enable semantic error reporting\n"
124 132 "pjass - Read from standard input (may appear in a list)\n" "pjass - Read from standard input (may appear in a list)\n"
125 133 ); );
126 134 exit(0); exit(0);
 
... ... int main(int argc, char **argv)
159 167 if (!haderrors && didparse) { if (!haderrors && didparse) {
160 168 printf("Parse successful: %8d lines: %s\n", totlines, "<total>"); printf("Parse successful: %8d lines: %s\n", totlines, "<total>");
161 169 if (ignorederrors) { if (ignorederrors) {
162 printf("%d errors ignored", ignorederrors);
170 printf("%d errors ignored\n", ignorederrors);
163 171 } }
164 172
165 173 return 0; return 0;
 
... ... int main(int argc, char **argv)
170 178 printf("Parse failed\n"); printf("Parse failed\n");
171 179 } }
172 180 if (ignorederrors) { if (ignorederrors) {
173 printf("%d errors ignored", ignorederrors);
181 printf("%d errors ignored\n", ignorederrors);
174 182 } }
175 183 return 1; return 1;
176 184 } }
File misc.c changed (mode: 100644) (index 0b7c060..dd7921c)
... ... struct funcdecl *fFilter, *fCondition;
53 53
54 54 struct hashtable available_flags; struct hashtable available_flags;
55 55
56 void yyerrorline (int errorlevel, int line, const char *s)
56 void yyerrorline (enum errortype type, int line, const char *s)
57 57 { {
58 //if (showerrorlevel[errorlevel]) {
58 if(flagenabled(flag_syntaxerror) && type == syntaxerror){
59 ignorederrors++;
60 return;
61 }
62
63 if(flagenabled(flag_semanticerror) && type == semanticerror){
64 ignorederrors++;
65 return;
66 }
67
59 68 haderrors++; haderrors++;
60 69 printf ("%s:%d: %s\n", curfile, line, s); printf ("%s:%d: %s\n", curfile, line, s);
61 //}
62 //else
63 // ignorederrors++;
64 70 } }
65 71
66 void yyerrorex (int errorlevel, const char *s)
72 void yyerrorex (enum errortype type, const char *s)
67 73 { {
68 //if (showerrorlevel[errorlevel]) {
69 haderrors++;
70 printf ("%s:%d: %s\n", curfile, lineno, s);
71 //}
72 //else
73 // ignorederrors++;
74 yyerrorline(type, lineno, s);
74 75 } }
75 76
76 77 void yyerror (const char *s) /* Called by yyparse on error */ void yyerror (const char *s) /* Called by yyparse on error */
77 78 { {
78 yyerrorex(0, s);
79 yyerrorex(syntaxerror, s);
79 80 } }
80 81
81 82 void put(struct hashtable *h, const char *name, void *val){ void put(struct hashtable *h, const char *name, void *val){
82 83 if( !ht_put(h, name, val) ){ if( !ht_put(h, name, val) ){
83 84 char ebuf[1024]; char ebuf[1024];
84 85 snprintf(ebuf, 1024, "Symbol %s multiply defined", name); snprintf(ebuf, 1024, "Symbol %s multiply defined", name);
85 yyerrorline(3, islinebreak ? lineno - 1 : lineno, ebuf);
86 yyerrorline(semanticerror, islinebreak ? lineno - 1 : lineno, ebuf);
86 87 } }
87 88 } }
88 89
 
... ... const struct typeandname *getVariable(const char *varname)
239 240
240 241 snprintf(ebuf, 1024, "Undeclared variable %s", varname); snprintf(ebuf, 1024, "Undeclared variable %s", varname);
241 242 getsuggestions(varname, ebuf, 1024, 3, &locals, &params, &globals); getsuggestions(varname, ebuf, 1024, 3, &locals, &params, &globals);
242 yyerrorline(2, islinebreak ? lineno - 1 : lineno, ebuf);
243 yyerrorline(semanticerror, islinebreak ? lineno - 1 : lineno, ebuf);
243 244
244 245 // Store it as unidentified variable // Store it as unidentified variable
245 246 const struct typeandname *newtan = newtypeandname(gAny, varname); const struct typeandname *newtan = newtypeandname(gAny, varname);
 
... ... void validateGlobalAssignment(const char *varname)
257 258 result = ht_lookup(&globals, varname); result = ht_lookup(&globals, varname);
258 259 if (result) { if (result) {
259 260 snprintf(ebuf, 1024, "Assignment to global variable %s in constant function", varname); snprintf(ebuf, 1024, "Assignment to global variable %s in constant function", varname);
260 yyerrorline(2, lineno - 1, ebuf);
261 yyerrorline(semanticerror, lineno - 1, ebuf);
261 262 } }
262 263 } }
263 264
 
... ... void checkParameters(const struct paramlist *func, const struct paramlist *inp,
270 271 if (fi == NULL && pi == NULL) if (fi == NULL && pi == NULL)
271 272 return; return;
272 273 if (fi == NULL && pi != NULL) { if (fi == NULL && pi != NULL) {
273 yyerrorex(3, "Too many arguments passed to function");
274 yyerrorex(semanticerror, "Too many arguments passed to function");
274 275 return; return;
275 276 } }
276 277 if (fi != NULL && pi == NULL) { if (fi != NULL && pi == NULL) {
277 yyerrorex(3, "Not enough arguments passed to function");
278 yyerrorex(semanticerror, "Not enough arguments passed to function");
278 279 return; return;
279 280 } }
280 281 canconvert(pi->ty, fi->ty, 0); canconvert(pi->ty, fi->ty, 0);
 
... ... const struct typenode *binop(const struct typenode *a, const struct typenode *b)
297 298 if (typeeq(b, gAny)) if (typeeq(b, gAny))
298 299 return a; return a;
299 300 if ((!typeeq(a, gInteger) && !typeeq(a, gReal)) || (!typeeq(b, gInteger) && !typeeq(b, gReal))) { if ((!typeeq(a, gInteger) && !typeeq(a, gReal)) || (!typeeq(b, gInteger) && !typeeq(b, gReal))) {
300 yyerrorline(3, islinebreak ? lineno - 1 : lineno, "Bad types for binary operator");
301 yyerrorline(semanticerror, islinebreak ? lineno - 1 : lineno, "Bad types for binary operator");
301 302 } }
302 303 return gReal; return gReal;
303 304 } }
 
... ... void canconvert(const struct typenode *ufrom, const struct typenode *uto, const
355 356 return; return;
356 357
357 358 snprintf(ebuf, 1024, "Cannot convert %s to %s", ufrom->typename, uto->typename); snprintf(ebuf, 1024, "Cannot convert %s to %s", ufrom->typename, uto->typename);
358 yyerrorline(3, lineno + linemod, ebuf);
359 yyerrorline(semanticerror, lineno + linemod, ebuf);
359 360 return; return;
360 361 } }
361 362
 
... ... void canconvertreturn(const struct typenode *ufrom, const struct typenode *uto,
385 386 if ((typeeq(to, gReal)) && (typeeq(from, gInteger))) { if ((typeeq(to, gReal)) && (typeeq(from, gInteger))) {
386 387 // can't return integer when it expects a real (added 9.5.2005) // can't return integer when it expects a real (added 9.5.2005)
387 388 snprintf(ebuf, 1024, "Cannot convert returned value from %s to %s", getTypePtr(from)->typename, getTypePtr(to)->typename); snprintf(ebuf, 1024, "Cannot convert returned value from %s to %s", getTypePtr(from)->typename, getTypePtr(to)->typename);
388 yyerrorline(1, lineno + linemod, ebuf);
389 yyerrorline(semanticerror, lineno + linemod, ebuf);
389 390 return; return;
390 391 } }
391 392
 
... ... void canconvertreturn(const struct typenode *ufrom, const struct typenode *uto,
397 398 } }
398 399
399 400 snprintf(ebuf, 1024, "Cannot convert returned value from %s to %s", getTypePtr(ufrom)->typename, getTypePtr(uto)->typename); snprintf(ebuf, 1024, "Cannot convert returned value from %s to %s", getTypePtr(ufrom)->typename, getTypePtr(uto)->typename);
400 yyerrorline(1, lineno + linemod, ebuf);
401 yyerrorline(semanticerror, lineno + linemod, ebuf);
401 402 return; return;
402 403 } }
403 404
 
... ... void isnumeric(const struct typenode *ty)
405 406 { {
406 407 ty = getPrimitiveAncestor(ty); ty = getPrimitiveAncestor(ty);
407 408 if (!(ty == gInteger || ty == gReal || ty == gAny)) if (!(ty == gInteger || ty == gReal || ty == gAny))
408 yyerrorline(3, islinebreak ? lineno - 1 : lineno, "Cannot be converted to numeric type");
409 yyerrorline(semanticerror, islinebreak ? lineno - 1 : lineno, "Cannot be converted to numeric type");
409 410 } }
410 411
411 412 void checkcomparisonsimple(const struct typenode *a) void checkcomparisonsimple(const struct typenode *a)
 
... ... void checkcomparisonsimple(const struct typenode *a)
413 414 const struct typenode *pa; const struct typenode *pa;
414 415 pa = getPrimitiveAncestor(a); pa = getPrimitiveAncestor(a);
415 416 if (typeeq(pa, gString) || typeeq(pa, gHandle) || typeeq(pa, gCode) || typeeq(pa, gBoolean)) { if (typeeq(pa, gString) || typeeq(pa, gHandle) || typeeq(pa, gCode) || typeeq(pa, gBoolean)) {
416 yyerrorex(3, "Comparing the order/size of 2 variables only works on reals and integers");
417 yyerrorex(semanticerror, "Comparing the order/size of 2 variables only works on reals and integers");
417 418 return; return;
418 419 } }
419 420 if (typeeq(pa, gNull)) if (typeeq(pa, gNull))
420 yyerrorex(3, "Comparing null is not allowed");
421 yyerrorex(semanticerror, "Comparing null is not allowed");
421 422 } }
422 423
423 424 void checkcomparison(const struct typenode *a, const struct typenode *b) void checkcomparison(const struct typenode *a, const struct typenode *b)
 
... ... void checkcomparison(const struct typenode *a, const struct typenode *b)
426 427 pa = getPrimitiveAncestor(a); pa = getPrimitiveAncestor(a);
427 428 pb = getPrimitiveAncestor(b); pb = getPrimitiveAncestor(b);
428 429 if (typeeq(pa, gString) || typeeq(pa, gHandle) || typeeq(pa, gCode) || typeeq(pa, gBoolean) || typeeq(pb, gString) || typeeq(pb, gCode) || typeeq(pb, gHandle) || typeeq(pb, gBoolean)) { if (typeeq(pa, gString) || typeeq(pa, gHandle) || typeeq(pa, gCode) || typeeq(pa, gBoolean) || typeeq(pb, gString) || typeeq(pb, gCode) || typeeq(pb, gHandle) || typeeq(pb, gBoolean)) {
429 yyerrorex(3, "Comparing the order/size of 2 variables only works on reals and integers");
430 yyerrorex(semanticerror, "Comparing the order/size of 2 variables only works on reals and integers");
430 431 return; return;
431 432 } }
432 433 if (typeeq(pa, gNull) && typeeq(pb, gNull)) if (typeeq(pa, gNull) && typeeq(pb, gNull))
433 yyerrorex(3, "Comparing null is not allowed");
434 yyerrorex(semanticerror, "Comparing null is not allowed");
434 435 } }
435 436
436 437 void checkeqtest(const struct typenode *a, const struct typenode *b) void checkeqtest(const struct typenode *a, const struct typenode *b)
 
... ... void checkeqtest(const struct typenode *a, const struct typenode *b)
443 444 if (typeeq(pa, gNull) || typeeq(pb, gNull)) if (typeeq(pa, gNull) || typeeq(pb, gNull))
444 445 return; return;
445 446 if (!typeeq(pa, pb)) { if (!typeeq(pa, pb)) {
446 yyerrorex(3, "Comparing two variables of different primitive types (except real and integer) is not allowed");
447 yyerrorex(semanticerror, "Comparing two variables of different primitive types (except real and integer) is not allowed");
447 448 return; return;
448 449 } }
449 450 } }
 
... ... union node checkfunctionheader(const char *fnname, struct paramlist *pl, const s
489 490 if (ht_lookup(&locals, fnname) || ht_lookup(&params, fnname) || ht_lookup(&globals, fnname)) { if (ht_lookup(&locals, fnname) || ht_lookup(&params, fnname) || ht_lookup(&globals, fnname)) {
490 491 char buf[1024]; char buf[1024];
491 492 snprintf(buf, 1024, "%s already defined as variable", fnname); snprintf(buf, 1024, "%s already defined as variable", fnname);
492 yyerrorex(3, buf);
493 yyerrorex(semanticerror, buf);
493 494 } else if (ht_lookup(&types, fnname)) { } else if (ht_lookup(&types, fnname)) {
494 495 char buf[1024]; char buf[1024];
495 496 snprintf(buf, 1024, "%s already defined as type", fnname); snprintf(buf, 1024, "%s already defined as type", fnname);
496 yyerrorex(3, buf);
497 yyerrorex(semanticerror, buf);
497 498 } }
498 499
499 500 curtab = &locals; curtab = &locals;
 
... ... union node checkfunctionheader(const char *fnname, struct paramlist *pl, const s
515 516 if (ht_lookup(&functions, tan->name)) { if (ht_lookup(&functions, tan->name)) {
516 517 char buf[1024]; char buf[1024];
517 518 snprintf(buf, 1024, "%s already defined as function", tan->name); snprintf(buf, 1024, "%s already defined as function", tan->name);
518 yyerrorex(3, buf);
519 yyerrorex(semanticerror, buf);
519 520 } else if (ht_lookup(&types, tan->name)) { } else if (ht_lookup(&types, tan->name)) {
520 521 char buf[1024]; char buf[1024];
521 522 snprintf(buf, 1024, "%s already defined as type", tan->name); snprintf(buf, 1024, "%s already defined as type", tan->name);
522 yyerrorex(3, buf);
523 yyerrorex(semanticerror, buf);
523 524 } }
524 525
525 526 if( flagenabled(flag_shadowing) ){ if( flagenabled(flag_shadowing) ){
526 527 if( ht_lookup(&globals, tan->name) ){ if( ht_lookup(&globals, tan->name) ){
527 528 char buf[1024]; char buf[1024];
528 529 snprintf(buf, 1024, "Parmeter %s shadows global variable", tan->name); snprintf(buf, 1024, "Parmeter %s shadows global variable", tan->name);
529 yyerrorex(3, buf);
530 yyerrorex(semanticerror, buf);
530 531 } }
531 532 } }
532 533
 
... ... union node checkfunccall(const char *fnname, struct paramlist *pl)
546 547 char ebuf[1024]; char ebuf[1024];
547 548 snprintf(ebuf, 1024, "Undeclared function %s", fnname); snprintf(ebuf, 1024, "Undeclared function %s", fnname);
548 549 getsuggestions(fnname, ebuf, 1024, 1, &functions); getsuggestions(fnname, ebuf, 1024, 1, &functions);
549 yyerrorex(3, ebuf);
550 yyerrorex(semanticerror, ebuf);
550 551 ret.ty = gAny; ret.ty = gAny;
551 552 } else { } else {
552 553 if (inconstant && !(fd->isconst)) { if (inconstant && !(fd->isconst)) {
553 554 char ebuf[1024]; char ebuf[1024];
554 555 snprintf(ebuf, 1024, "Call to non-constant function %s in constant function", fnname); snprintf(ebuf, 1024, "Call to non-constant function %s in constant function", fnname);
555 yyerrorex(3, ebuf);
556 yyerrorex(semanticerror, ebuf);
556 557 } }
557 558 if (fd == fCurrent && fCurrent) if (fd == fCurrent && fCurrent)
558 yyerrorex(3, "Recursive function calls are not permitted in local declarations");
559 yyerrorex(semanticerror, "Recursive function calls are not permitted in local declarations");
559 560 checkParameters(fd->p, pl, fd == fFilter || fd == fCondition); checkParameters(fd->p, pl, fd == fFilter || fd == fCondition);
560 561 ret.ty = fd->ret; ret.ty = fd->ret;
561 562 } }
 
... ... static void checkvarname(struct typeandname *tan, bool isarray)
568 569 if (ht_lookup(&functions, name)) { if (ht_lookup(&functions, name)) {
569 570 char buf[1024]; char buf[1024];
570 571 snprintf(buf, 1024, "Symbol %s already defined as function", name); snprintf(buf, 1024, "Symbol %s already defined as function", name);
571 yyerrorex(3, buf);
572 yyerrorex(semanticerror, buf);
572 573 } else if (ht_lookup(&types, name)) { } else if (ht_lookup(&types, name)) {
573 574 char buf[1024]; char buf[1024];
574 575 snprintf(buf, 1024, "Symbol %s already defined as type", name); snprintf(buf, 1024, "Symbol %s already defined as type", name);
575 yyerrorex(3, buf);
576 yyerrorex(semanticerror, buf);
576 577 } }
577 578
578 579 struct typeandname *existing = ht_lookup(&locals, name); struct typeandname *existing = ht_lookup(&locals, name);
 
... ... static void checkvarname(struct typeandname *tan, bool isarray)
582 583 existing = ht_lookup(&params, name); existing = ht_lookup(&params, name);
583 584 if ( isarray && infunction && existing) { if ( isarray && infunction && existing) {
584 585 snprintf(buf, 1024, "Symbol %s already defined as function parameter", name); snprintf(buf, 1024, "Symbol %s already defined as function parameter", name);
585 yyerrorex(3, buf);
586 yyerrorex(semanticerror, buf);
586 587 } }
587 588 if (!existing) { if (!existing) {
588 589 existing = ht_lookup(&globals, name); existing = ht_lookup(&globals, name);
589 590 if ( isarray && infunction && existing) { if ( isarray && infunction && existing) {
590 591 snprintf(buf, 1024, "Symbol %s already defined as global variable", name); snprintf(buf, 1024, "Symbol %s already defined as global variable", name);
591 yyerrorex(3, buf);
592 yyerrorex(semanticerror, buf);
592 593 } }
593 594 } }
594 595 } }
 
... ... union node checkarraydecl(struct typeandname *tan)
619 620 union node ret; union node ret;
620 621
621 622 if (getPrimitiveAncestor(tan->ty) == gCode) if (getPrimitiveAncestor(tan->ty) == gCode)
622 yyerrorex(3, "Code arrays are not allowed");
623 yyerrorex(semanticerror, "Code arrays are not allowed");
623 624
624 625 checkvarname(tan, true); checkvarname(tan, true);
625 626
File misc.h changed (mode: 100644) (index 6056c6e..83d6ad4)
... ... enum {
39 39 flag_rb = 1 << 0, flag_rb = 1 << 0,
40 40 flag_filter = 1 << 1, flag_filter = 1 << 1,
41 41 flag_shadowing = 1 << 2, flag_shadowing = 1 << 2,
42 flag_syntaxerror = 1 << 3,
43 flag_semanticerror = 1 << 4,
42 44 }; };
43 45
44 46
45 void yyerrorline (int errorlevel, int line, const char *s);
46 void yyerrorex (int errorlevel, const char *s);
47 void yyerrorline (enum errortype type, int line, const char *s);
48 void yyerrorex (enum errortype type, const char *s);
47 49 void yyerror (const char *s); void yyerror (const char *s);
48 50
49 51 void put(struct hashtable *h, const char *name, void *val); void put(struct hashtable *h, const char *name, void *val);
File tests/should-fail/filter-annotation.j added (mode: 100644) (index 0000000..ea727c4)
1 type agent extends handle
2 type boolexpr extends agent
3 type conditionfunc extends boolexpr
4 type filterfunc extends conditionfunc
5
6 native Filter takes code c returns filterfunc
7
8 function returnsnoboolean takes nothing returns nothing
9 endfunction
10
11 //# +filter
12 function foo takes nothing returns nothing
13 call Filter(function returnsnoboolean)
14 endfunction
15
File token.l changed (mode: 100644) (index dd84558..d06b8d1)
... ... TABS [\x01-\x09\x0B\x0C\x0E-\x1F]
55 55
56 56 [']\\[btrnf\\]['] { return UNITTYPEINT; } [']\\[btrnf\\]['] { return UNITTYPEINT; }
57 57 [']\\(.|[\r\n])['] { [']\\(.|[\r\n])['] {
58 yyerrorline(3, lineno, "Invalid escape character sequence");
58 yyerrorline(syntaxerror, lineno, "Invalid escape character sequence");
59 59 return UNITTYPEINT; return UNITTYPEINT;
60 60 } }
61 61
 
... ... TABS [\x01-\x09\x0B\x0C\x0E-\x1F]
66 66 } }
67 67 <RAWCODE>['] { <RAWCODE>['] {
68 68 if(rawcodelen != 4 && rawcodelen != 1){ if(rawcodelen != 4 && rawcodelen != 1){
69 yyerrorline(3, rawcodestartline, "Rawcodes must consist of 1 or 4 characters");
69 yyerrorline(syntaxerror, rawcodestartline, "Rawcodes must consist of 1 or 4 characters");
70 70 } }
71 71 BEGIN(INITIAL); BEGIN(INITIAL);
72 72 return UNITTYPEINT; return UNITTYPEINT;
 
... ... TABS [\x01-\x09\x0B\x0C\x0E-\x1F]
74 74
75 75 <RAWCODE>\\[btrnf"\\] { <RAWCODE>\\[btrnf"\\] {
76 76 rawcodelen++; rawcodelen++;
77 yyerrorline(3, rawcodestartline, "Escaped chars are only allowed if they are the only char in the rawcode.");
77 yyerrorline(syntaxerror, rawcodestartline, "Escaped chars are only allowed if they are the only char in the rawcode.");
78 78 } }
79 79 <RAWCODE>\\(.|[\r\n]) { <RAWCODE>\\(.|[\r\n]) {
80 yyerrorline(3, lineno, "Invalid escape character sequence");
80 yyerrorline(syntaxerror, lineno, "Invalid escape character sequence");
81 81 rawcodelen++; rawcodelen++;
82 82 } }
83 83
 
... ... TABS [\x01-\x09\x0B\x0C\x0E-\x1F]
88 88 ["] { BEGIN(INSTRING); } ["] { BEGIN(INSTRING); }
89 89 <INSTRING>["] { BEGIN(INITIAL); return STRINGLIT; } <INSTRING>["] { BEGIN(INITIAL); return STRINGLIT; }
90 90 <INSTRING>\\[btrnf"\\] { } <INSTRING>\\[btrnf"\\] { }
91 <INSTRING>\\(.|[\r\n]) { yyerrorline(3, lineno, "Invalid escape character sequence"); }
91 <INSTRING>\\(.|[\r\n]) { yyerrorline(syntaxerror, lineno, "Invalid escape character sequence"); }
92 92
93 93 <INSTRING>\r?\n { lineno++; isconstant = 0; } <INSTRING>\r?\n { lineno++; isconstant = 0; }
94 94 <INSTRING>\r { lineno++; isconstant = 0; } <INSTRING>\r { lineno++; isconstant = 0; }
 
... ... TABS [\x01-\x09\x0B\x0C\x0E-\x1F]
98 98 {NEWLINE} lineno++; islinebreak=1; isconstant=0; return NEWLINE; {NEWLINE} lineno++; islinebreak=1; isconstant=0; return NEWLINE;
99 99
100 100 {DIGIT}*"."{DIGIT}* return REALLIT; {DIGIT}*"."{DIGIT}* return REALLIT;
101 "0"({OCTDIGIT}*("8"|"9"){OCTDIGIT}*)+ yyerrorline(3, lineno, "Invalid digit in octal integer notation"); return INTLIT;
101 "0"({OCTDIGIT}*("8"|"9"){OCTDIGIT}*)+ yyerrorline(syntaxerror, lineno, "Invalid digit in octal integer notation"); return INTLIT;
102 102 ({DIGIT}+)|(("0x"|"$"){HEXDIGIT}+) return INTLIT; ({DIGIT}+)|(("0x"|"$"){HEXDIGIT}+) return INTLIT;
103 103
104 "if" if (!islinebreak) yyerrorline(3, lineno, "Missing linebreak before if"); islinebreak=0; return IF;
104 "if" if (!islinebreak) yyerrorline(syntaxerror, lineno, "Missing linebreak before if"); islinebreak=0; return IF;
105 105 "not" return NOT; "not" return NOT;
106 106 "then" return THEN; "then" return THEN;
107 "type" if (!islinebreak) { char ebuf[1024]; sprintf(ebuf, "Missing linebreak before type declaration"); yyerrorline(3, lineno, ebuf); } islinebreak=0; return TYPE;
107 "type" if (!islinebreak) { char ebuf[1024]; sprintf(ebuf, "Missing linebreak before type declaration"); yyerrorline(syntaxerror, lineno, ebuf); } islinebreak=0; return TYPE;
108 108 "extends" return EXTENDS; "extends" return EXTENDS;
109 109 "handle" islinebreak=0; return HANDLE; "handle" islinebreak=0; return HANDLE;
110 "globals" if (!islinebreak) { char ebuf[1024]; sprintf(ebuf, "Missing linebreak before globals block"); yyerrorline(3, lineno, ebuf); } islinebreak=0; inblock=1; return GLOBALS;
110 "globals" if (!islinebreak) { char ebuf[1024]; sprintf(ebuf, "Missing linebreak before globals block"); yyerrorline(syntaxerror, lineno, ebuf); } islinebreak=0; inblock=1; return GLOBALS;
111 111 "endglobals" islinebreak=0; inblock=0; return ENDGLOBALS; "endglobals" islinebreak=0; inblock=0; return ENDGLOBALS;
112 112 "constant" isconstant = islinebreak; islinebreak=0; return CONSTANT; "constant" isconstant = islinebreak; islinebreak=0; return CONSTANT;
113 "native" if (!islinebreak && !isconstant) { char ebuf[1024]; sprintf(ebuf, "Missing linebreak before native declaration"); yyerrorline(3, lineno, ebuf); } islinebreak=0; return NATIVE;
113 "native" if (!islinebreak && !isconstant) { char ebuf[1024]; sprintf(ebuf, "Missing linebreak before native declaration"); yyerrorline(syntaxerror, lineno, ebuf); } islinebreak=0; return NATIVE;
114 114 "takes" return TAKES; "takes" return TAKES;
115 115 "returns" return RETURNS; "returns" return RETURNS;
116 "function" if (!islinebreak && !isconstant && !inblock) { char ebuf[1024]; sprintf(ebuf, "Missing linebreak before function declaration"); yyerrorline(3, lineno, ebuf); } islinebreak=0; return FUNCTION;
116 "function" if (!islinebreak && !isconstant && !inblock) { char ebuf[1024]; sprintf(ebuf, "Missing linebreak before function declaration"); yyerrorline(syntaxerror, lineno, ebuf); } islinebreak=0; return FUNCTION;
117 117 "endfunction" islinebreak=0; return ENDFUNCTION; "endfunction" islinebreak=0; return ENDFUNCTION;
118 "local" if (!islinebreak) { char ebuf[1024]; sprintf(ebuf, "Missing linebreak before local declaration"); yyerrorline(3, lineno, ebuf); } islinebreak=0; return LOCAL;
118 "local" if (!islinebreak) { char ebuf[1024]; sprintf(ebuf, "Missing linebreak before local declaration"); yyerrorline(syntaxerror, lineno, ebuf); } islinebreak=0; return LOCAL;
119 119 "array" return ARRAY; "array" return ARRAY;
120 "set" if (!islinebreak) yyerrorline(3, lineno, "Missing linebreak before assignment"); islinebreak=0; return SET;
121 "call" if (!islinebreak) yyerrorline(3, lineno, "Missing linebreak before function call"); islinebreak=0; return CALL;
122 "else" if (!islinebreak) yyerrorline(3, lineno, "Missing linebreak before else"); islinebreak=0; return ELSE;
123 "elseif" if (!islinebreak) yyerrorline(3, lineno, "Missing linebreak before elseif"); islinebreak=0; return ELSEIF;
124 "endif" if (!islinebreak) yyerrorline(3, lineno, "Missing linebreak before endif"); islinebreak=0; return ENDIF;
125 "loop" if (!islinebreak) yyerrorline(3, lineno, "Missing linebreak before loop"); islinebreak=0; return LOOP;
126 "exitwhen" if (!islinebreak) yyerrorline(3, lineno, "Missing linebreak before exitwhen"); islinebreak=0; return EXITWHEN;
127 "return" if (!islinebreak) yyerrorline(3, lineno, "Missing linebreak before return"); islinebreak=0; return RETURN;
120 "set" if (!islinebreak) yyerrorline(syntaxerror, lineno, "Missing linebreak before assignment"); islinebreak=0; return SET;
121 "call" if (!islinebreak) yyerrorline(syntaxerror, lineno, "Missing linebreak before function call"); islinebreak=0; return CALL;
122 "else" if (!islinebreak) yyerrorline(syntaxerror, lineno, "Missing linebreak before else"); islinebreak=0; return ELSE;
123 "elseif" if (!islinebreak) yyerrorline(syntaxerror, lineno, "Missing linebreak before elseif"); islinebreak=0; return ELSEIF;
124 "endif" if (!islinebreak) yyerrorline(syntaxerror, lineno, "Missing linebreak before endif"); islinebreak=0; return ENDIF;
125 "loop" if (!islinebreak) yyerrorline(syntaxerror, lineno, "Missing linebreak before loop"); islinebreak=0; return LOOP;
126 "exitwhen" if (!islinebreak) yyerrorline(syntaxerror, lineno, "Missing linebreak before exitwhen"); islinebreak=0; return EXITWHEN;
127 "return" if (!islinebreak) yyerrorline(syntaxerror, lineno, "Missing linebreak before return"); islinebreak=0; return RETURN;
128 128 "debug" return DEBUG; "debug" return DEBUG;
129 "endloop" if (!islinebreak) yyerrorline(3, lineno, "Missing linebreak before endloop"); islinebreak=0; return ENDLOOP;
129 "endloop" if (!islinebreak) yyerrorline(syntaxerror, lineno, "Missing linebreak before endloop"); islinebreak=0; return ENDLOOP;
130 130 "null" return TNULL; "null" return TNULL;
131 131 "true" return TTRUE; "true" return TTRUE;
132 132 "false" return TFALSE; "false" return TFALSE;
 
... ... TABS [\x01-\x09\x0B\x0C\x0E-\x1F]
164 164 \xEF\xBB\xBF /* utf8 bom */ \xEF\xBB\xBF /* utf8 bom */
165 165 [\x01-\x09\x0B\x0C\x0E-\x1F]+ /* eat up tabs */ [\x01-\x09\x0B\x0C\x0E-\x1F]+ /* eat up tabs */
166 166
167 . { char ebuf[1024]; sprintf(ebuf, "Unrecognized character %s (ASCII %u)", yytext, (unsigned char)yytext[0] ); yyerrorline(3, lineno, ebuf); }
167 . { char ebuf[1024]; sprintf(ebuf, "Unrecognized character %s (ASCII %u)", yytext, (unsigned char)yytext[0] ); yyerrorline(syntaxerror, lineno, ebuf); }
168 168
169 169 %% %%
170 170
Hints:
Before first commit, do not forget to setup your git environment:
git config --global user.name "your_name_here"
git config --global user.email "your@email_here"

Clone this repository using HTTP(S):
git clone https://rocketgit.com/user/vrtc/pjass

Clone this repository using ssh (do not forget to upload a key first):
git clone ssh://rocketgit@ssh.rocketgit.com/user/vrtc/pjass

Clone this repository using git:
git clone git://git.rocketgit.com/user/vrtc/pjass

You are allowed to anonymously push to this repository.
This means that your pushed commits will automatically be transformed into a merge request:
... clone the repository ...
... make some changes and some commits ...
git push origin main