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)
Handle wrong shadowing. 0500a60ef11f39c4f33044e26c29798f6d8445b5 lep 2017-02-19 14:37:21
Added checks for natives which behave bad in a globals block. 3e6ac270dda9ad695723d3bc2aac4d69a2fdf87a lep 2017-02-19 10:57:33
Update readme.md 2c9177dd5482ed8c4c1464a4ade37c301205fe6b lep 2017-02-01 17:42:49
Public git release. 2da78f3665ac4f53f5833c6a48ebbeaabea0cd49 lep 2017-02-01 16:42:21
Better ifdef-handling for aligned malloc. d95ebafa7204e49d84a9fed8cdeb01713dd0bc82 lep 2017-02-01 16:41:07
Makefile changes. 0458bb26764aad1caec71ccf721e84a28c699ee0 lep 2017-02-01 15:48:25
Can now compile on freebsd and linux from one branch. 0772c4bd17dcfc389ca0e887b4bbceda8e46fa8e lep 2017-01-07 21:05:10
More descriptive check for assignment. 474462b44fe20e958e8c6a3b51ba2da9c4a46451 lep 2016-11-24 16:47:15
Actually add all the sources to the release zipball 151ae88aac4c3ac8aae432a4a240239f652fa8f4 lep 2016-11-10 15:30:38
Don't treat ``.'' as a valid real value. 72e5087e22af66de0765c6d4f9ceae154725e2c2 lep 2016-10-24 14:55:02
Also split on \r in flag parser. 519d685ab24864716e3a1ecfd797790a327868ca lep 2016-08-28 12:41:08
Improved errors for function-calls. 5a50178a03c5aa3d153e8699070942327fde0b7b lep 2016-08-27 18:44:01
A very strange error with newlines and comments. d822cacbd889fe723102102c8a09d578d90f013e lep 2016-08-21 09:15:00
Added +nosyntaxerror and +nosemanticerror e755e12b3cab1d5069574e34d22633dd420bb230 lep 2016-05-07 13:42:57
MinGW fixes. f579fad932039f1bca43e7612154f5b7dc4aea4f lep 2016-03-13 19:29:36
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 1af0f62834728baa465d03b355738e64578d9714 lep 2016-03-03 16:02:34
Commit 0500a60ef11f39c4f33044e26c29798f6d8445b5 - Handle wrong shadowing.
Author: lep
Author date (UTC): 2017-02-19 14:37
Committer name: lep
Committer date (UTC): 2017-02-19 14:44
Parent(s): 3e6ac270dda9ad695723d3bc2aac4d69a2fdf87a
Signer:
Signing key:
Signing status: N
Tree: e2f8ffbf31f3fe3aa2b6438fe7ebb8691d963aa4
File Lines added Lines deleted
grammar.y 13 40
main.c 1 0
misc.c 46 1
misc.h 5 1
tests/should-check/safe-type-changing-shadowing.j 17 0
tests/should-check/shadow-compatible-type.j 21 0
tests/should-fail/use-after-wrong-shadow.j 16 0
File grammar.y changed (mode: 100644) (index 254a1ca..93edad6)
... ... expr: intexpr { $$.ty = gInteger; }
202 202 } }
203 203 | rid { | rid {
204 204 const struct typeandname *tan = getVariable($1.str); const struct typeandname *tan = getVariable($1.str);
205 if (tan->lineno == lineno && tan->fn == fno) {
206 char ebuf[1024];
207 snprintf(ebuf, 1024, "Use of variable %s before its declaration", $1.str);
208 yyerrorex(semanticerror, ebuf);
209 } else if (islinebreak && tan->lineno == lineno - 1 && tan->fn == fno) {
210 char ebuf[1024];
211 snprintf(ebuf, 1024, "Use of variable %s before its declaration", $1.str);
212 yyerrorline(semanticerror, lineno - 1, ebuf);
213 } else if (tan->isarray) {
205 if (tan->isarray) {
214 206 char ebuf[1024]; char ebuf[1024];
215 207 snprintf(ebuf, 1024, "Index missing for array variable %s", $1.str); snprintf(ebuf, 1024, "Index missing for array variable %s", $1.str);
216 208 yyerrorex(semanticerror, ebuf); yyerrorex(semanticerror, ebuf);
217 209 } }
210 checkwrongshadowing(tan, 0);
218 211 if(infunction && ht_lookup(curtab, $1.str) && !ht_lookup(&initialized, $1.str) ){ if(infunction && ht_lookup(curtab, $1.str) && !ht_lookup(&initialized, $1.str) ){
219 212 char ebuf[1024]; char ebuf[1024];
220 213 snprintf(ebuf, 1024, "Variable %s is uninitialized", $1.str); snprintf(ebuf, 1024, "Variable %s is uninitialized", $1.str);
221 //yyerrorex(3, ebuf);
222 214 yyerrorline(semanticerror, lineno - 1, ebuf); yyerrorline(semanticerror, lineno - 1, ebuf);
223 215 } }
224 216 $$.ty = tan->ty; $$.ty = tan->ty;
 
... ... statement: newline { $$.ty = gEmpty; }
376 368 $$.ty = combinetype($5.ty, combinetype($6.ty, $7.ty)); $$.ty = combinetype($5.ty, combinetype($6.ty, $7.ty));
377 369 } }
378 370 | SET rid EQUALS expr newline { | SET rid EQUALS expr newline {
379 if (getVariable($2.str)->isarray) {
371 const struct typeandname *tan = getVariable($2.str);
372 checkwrongshadowing(tan, -1);
373 if (tan->isarray) {
380 374 char ebuf[1024]; char ebuf[1024];
381 375 snprintf(ebuf, 1024, "Index missing for array variable %s", $2.str); snprintf(ebuf, 1024, "Index missing for array variable %s", $2.str);
382 376 yyerrorline(semanticerror, lineno - 1, ebuf); yyerrorline(semanticerror, lineno - 1, ebuf);
383 377 } }
384 canconvert($4.ty, getVariable($2.str)->ty, -1);
378 canconvert($4.ty, tan->ty, -1);
385 379 $$.ty = gAny; $$.ty = gAny;
386 if (getVariable($2.str)->isconst) {
380 if (tan->isconst) {
387 381 char ebuf[1024]; char ebuf[1024];
388 382 snprintf(ebuf, 1024, "Cannot assign to constant %s", $2.str); snprintf(ebuf, 1024, "Cannot assign to constant %s", $2.str);
389 383 yyerrorline(semanticerror, lineno - 1, ebuf); yyerrorline(semanticerror, lineno - 1, ebuf);
 
... ... rid: ID
502 496
503 497 vartypedecl: type rid { vartypedecl: type rid {
504 498 struct typeandname *tan = newtypeandname($1.ty, $2.str); struct typeandname *tan = newtypeandname($1.ty, $2.str);
505 $$ = checkvardecl(tan);
499 tan->lineno = lineno;
500 $$ = checkvartypedecl(tan);
506 501 } }
507 502 | CONSTANT type rid { | CONSTANT type rid {
508 503 if (infunction) { if (infunction) {
 
... ... vartypedecl: type rid {
510 505 } }
511 506 struct typeandname *tan = newtypeandname($2.ty, $3.str); struct typeandname *tan = newtypeandname($2.ty, $3.str);
512 507 tan->isconst = 1; tan->isconst = 1;
513 $$ = checkvardecl(tan);
508 $$ = checkvartypedecl(tan);
514 509 } }
515 510 | type ARRAY rid { | type ARRAY rid {
516 511 struct typeandname *tan = newtypeandname($1.ty, $3.str); struct typeandname *tan = newtypeandname($1.ty, $3.str);
 
... ... vartypedecl: type rid {
523 518 | type TYPE { | type TYPE {
524 519 yyerrorex(syntaxerror, "Invalid variable name \"type\""); yyerrorex(syntaxerror, "Invalid variable name \"type\"");
525 520 struct typeandname *tan = newtypeandname($1.ty, "type"); struct typeandname *tan = newtypeandname($1.ty, "type");
526 $$ = checkvardecl(tan);
521 $$ = checkvartypedecl(tan);
527 522 } }
528 523
529 524 | CONSTANT type TYPE { | CONSTANT type TYPE {
 
... ... vartypedecl: type rid {
533 528 yyerrorex(syntaxerror, "Invalid variable name \"type\""); yyerrorex(syntaxerror, "Invalid variable name \"type\"");
534 529 struct typeandname *tan = newtypeandname($2.ty, "type"); struct typeandname *tan = newtypeandname($2.ty, "type");
535 530 tan->isconst = 1; tan->isconst = 1;
536 $$ = checkvardecl(tan);
531 $$ = checkvartypedecl(tan);
537 532 } }
538 533 | type ARRAY TYPE { | type ARRAY TYPE {
539 534 yyerrorex(syntaxerror, "Invalid variable name \"type\""); yyerrorex(syntaxerror, "Invalid variable name \"type\"");
 
... ... lvardecl: LOCAL vardecl { }
560 555 vardecl: vartypedecl newline { vardecl: vartypedecl newline {
561 556 const struct typeandname *tan = getVariable($1.str); const struct typeandname *tan = getVariable($1.str);
562 557 if (tan->isconst) { if (tan->isconst) {
563 yyerrorline(syntaxerror, lineno - 1, "Constants must be initialized");
564 }
565 if(infunction && flagenabled(flag_shadowing) ){
566 if( ht_lookup(&globals, tan->name)){
567 char buf[1024];
568 snprintf(buf, 1024, "Local variable %s shadows global variable", tan->name);
569 yyerrorline(semanticerror, lineno -1, buf);
570 } else if( ht_lookup(&params, tan->name)){
571 char buf[1024];
572 snprintf(buf, 1024, "Local variable %s shadows parameter", tan->name);
573 yyerrorline(semanticerror, lineno -1, buf);
574 }
558 yyerrorline(syntaxerror, lineno - 1, "Constants must be initialized");
575 559 } }
576 560 $$.ty = gNothing; $$.ty = gNothing;
577 561 } }
 
... ... vardecl: vartypedecl newline {
583 567 if(infunction && !ht_lookup(&initialized, tan->name)){ if(infunction && !ht_lookup(&initialized, tan->name)){
584 568 put(&initialized, tan->name, (void*)1); put(&initialized, tan->name, (void*)1);
585 569 } }
586 if(infunction && flagenabled(flag_shadowing) ){
587 if( ht_lookup(&globals, tan->name)){
588 char buf[1024];
589 snprintf(buf, 1024, "Local variable %s shadows global variable", tan->name);
590 yyerrorex(semanticerror, buf);
591 } else if( ht_lookup(&params, tan->name)){
592 char buf[1024];
593 snprintf(buf, 1024, "Local variable %s shadows parameter", tan->name);
594 yyerrorex(semanticerror, buf);
595 }
596 }
597 570 canconvert($3.ty, tan->ty, -1); canconvert($3.ty, tan->ty, -1);
598 571 $$.ty = gNothing; $$.ty = gNothing;
599 572 } }
File main.c changed (mode: 100644) (index 40371af..f97aadd)
... ... static void init()
25 25 ht_init(&initialized, 23); ht_init(&initialized, 23);
26 26
27 27 ht_init(&bad_natives_in_globals, 17); ht_init(&bad_natives_in_globals, 17);
28 ht_init(&shadowed_variables, 17);
28 29
29 30 gHandle = addPrimitiveType("handle"); gHandle = addPrimitiveType("handle");
30 31 gInteger = addPrimitiveType("integer"); gInteger = addPrimitiveType("integer");
File misc.c changed (mode: 100644) (index c6d42f3..64411e0)
... ... struct hashtable initialized;
41 41
42 42 struct hashtable bad_natives_in_globals; struct hashtable bad_natives_in_globals;
43 43
44 struct hashtable shadowed_variables;
45
44 46
45 47 struct hashtable *curtab; struct hashtable *curtab;
46 48
 
... ... static void checkvarname(struct typeandname *tan, bool isarray)
658 660 } }
659 661 } }
660 662
661 union node checkvardecl(struct typeandname *tan)
663 void checkallshadowing(struct typeandname *tan){
664 struct typeandname *global = ht_lookup(&globals, tan->name);
665 char buf[1024];
666
667 if( global ){
668
669 // once a variable is shadowed with an incompatible type every usage
670 // of the shadowed variable in the script file (sic) cannot be used
671 // safely anymore. Usages of the shadowed variable in the script
672 // above the shadowing still work fine.
673 tan->lineno = lineno;
674 ht_put(&shadowed_variables, tan->name, tan);
675
676 if(flagenabled(flag_shadowing)){
677 snprintf(buf, 1024, "Local variable %s shadows global variable", tan->name);
678 yyerrorline(semanticerror, lineno, buf);
679 }
680 } else if( flagenabled(flag_shadowing) && ht_lookup(&params, tan->name)){
681 snprintf(buf, 1024, "Local variable %s shadows parameter", tan->name);
682 yyerrorline(semanticerror, lineno, buf);
683 }
684 }
685
686 union node checkvartypedecl(struct typeandname *tan)
662 687 { {
663 688 const char *name = tan->name; const char *name = tan->name;
664 689 union node ret; union node ret;
 
... ... union node checkvardecl(struct typeandname *tan)
667 692 ret.str = name; ret.str = name;
668 693 put(curtab, name, tan); put(curtab, name, tan);
669 694
695
696 if(infunction ){
697 // always an error
698 checkwrongshadowing(tan, 0);
699
700 // flag driven
701 checkallshadowing(tan);
702 }
670 703 return ret; return ret;
671 704 } }
672 705
 
... ... union node checkarraydecl(struct typeandname *tan)
685 718
686 719 return ret; return ret;
687 720 } }
721
722 void checkwrongshadowing(const struct typeandname *tan, int linemod){
723 struct typeandname *global;
724 char buf[1024];
725 if( (global = ht_lookup(&shadowed_variables, tan->name)) ){
726 if(! typeeq(getPrimitiveAncestor(global->ty), getPrimitiveAncestor(tan->ty))){
727 snprintf(buf, 1024, "Global variable %s is used after it was shadowed with an incompatible type in line %d", tan->name, global->lineno);
728 yyerrorline(semanticerror, lineno - linemod, buf);
729 }
730 }
731 }
732
File misc.h changed (mode: 100644) (index 9b4e4a6..7aa19be)
... ... extern const struct typenode *retval;
106 106
107 107 extern struct hashtable available_flags; extern struct hashtable available_flags;
108 108
109 extern struct hashtable shadowed_variables;
110
109 111 union node checkfunctionheader(const char *fnname, struct paramlist *pl, const struct typenode *retty); union node checkfunctionheader(const char *fnname, struct paramlist *pl, const struct typenode *retty);
110 112 union node checkfunccall(const char *fnname, struct paramlist *pl); union node checkfunccall(const char *fnname, struct paramlist *pl);
111 113 union node checkarraydecl(struct typeandname *tan); union node checkarraydecl(struct typeandname *tan);
112 union node checkvardecl(struct typeandname *tan);
114 union node checkvartypedecl(struct typeandname *tan);
115 void checkwrongshadowing(const struct typeandname *tan, int linemod);
116
113 117
114 118 #endif #endif
File tests/should-check/safe-type-changing-shadowing.j added (mode: 100644) (index 0000000..9c1d81b)
1
2
3 globals
4 boolean b
5 endglobals
6
7 function A takes nothing returns nothing
8 set b = false
9 endfunction
10
11 function C takes nothing returns nothing
12 set b = true
13 endfunction
14
15 function B takes nothing returns nothing
16 local real b
17 endfunction
File tests/should-check/shadow-compatible-type.j added (mode: 100644) (index 0000000..1fa0a7b)
1
2 type agent extends handle
3 type widget extends agent
4 type unit extends widget
5 type destructable extends widget
6
7 globals
8 unit b
9 endglobals
10
11 function A takes nothing returns nothing
12 set b = null
13 endfunction
14
15 function B takes nothing returns nothing
16 local destructable b
17 endfunction
18
19 function C takes nothing returns nothing
20 set b = null
21 endfunction
File tests/should-fail/use-after-wrong-shadow.j added (mode: 100644) (index 0000000..7dafe53)
1
2 globals
3 boolean b
4 endglobals
5
6 function A takes nothing returns nothing
7 set b = false
8 endfunction
9
10 function B takes nothing returns nothing
11 local real b
12 endfunction
13
14 function C takes nothing returns nothing
15 set b = true
16 endfunction
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