Many hyperlinks are disabled.
Use anonymous login
to enable hyperlinks.
Changes In Branch tkt-5613c718c2-cwarnings Excluding Merge-Ins
This is equivalent to a diff from 2cd687d6e6 to 4e2b979bcb
2015-05-30
| ||
00:01 | rest - Tkt [87e374b7e4] - Updated/reworked documentation to be properly doctools. check-in: 2af315d3c6 user: andreask tags: trunk | |
2015-05-28
| ||
05:59 | Ticket [5613c718c2]. Applied patch for review, and editing. Leaf check-in: 4e2b979bcb user: aku tags: tkt-5613c718c2-cwarnings | |
05:40 | Applied patch from ticket. New branch. Not in a state suitable for merging. See comments in the ticket, i.e. [785d2954d4]. check-in: 9aff74cefd user: aku tags: tkt-785d2954d4-jsonc | |
2015-05-27
| ||
21:33 | Adding a new module to implement SCGI server and application functions. check-in: 693c2ee06f user: hypnotoad tags: scgi | |
00:46 | Start fixing up the documentation of package "rest". check-in: f7c45d905d user: andreask tags: aku-87e374b7e4-rest-docs | |
2015-05-26
| ||
23:41 | Keep up to date with trunk check-in: ca4c2acc78 user: andreask tags: huddle-a753cade83 | |
23:06 | fileutil, fileutil::traverse - Ticket [9b52204fea] - Added testcases showing the O(n**2) set of paths based on the doc example structure. Fixed that example and regenerated embedded docs. check-in: 2cd687d6e6 user: andreask tags: trunk | |
22:28 | fileutil, fileutil::traverse - Ticket [9b52204fea] - Documented the O(n**2) issue with traversing pathologically cross-linked directory hierarchies like /sys. Updated embedded documentation. check-in: 4ae879c0ea user: andreask tags: trunk | |
Changes to modules/md5/md5.c.
︙ | |||
111 112 113 114 115 116 117 | 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 | - + | } /* The routine MD5Update updates the message-digest context to account for the presence of each of the characters inBuf[0..inLen-1] in the message whose digest is being computed. */ void MD5Update (mdContext, inBuf, inLen) |
︙ |
Changes to modules/md5/md5.h.
︙ | |||
55 56 57 58 59 60 61 | 55 56 57 58 59 60 61 62 63 64 65 66 | - + | typedef struct { UINT4 buf[4]; /* scratch buffer */ UINT4 i[2]; /* number of _bits_ handled mod 2^64 */ unsigned char in[64]; /* input buffer */ } MD5_CTX; void MD5Init (MD5_CTX *mdContext); |
Changes to modules/md5crypt/md5cryptc.tcl.
︙ | |||
53 54 55 56 57 58 59 | 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 | - - + + + | putchar('\n'); } static char * md5crypt(const char *pw, const char *salt, const char *magic) { |
︙ | |||
109 110 111 112 113 114 115 | 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 | - + | if(i&1) MD5Update(&ctx, final, 1); else MD5Update(&ctx, (unsigned char *)pw, 1); } /* Now make the output string */ |
︙ | |||
139 140 141 142 143 144 145 | 140 141 142 143 144 145 146 147 148 149 150 151 152 153 | - - | if(i & 1) MD5Update(&ctx1,final,16); else MD5Update(&ctx1,(unsigned char *)pw,strlen(pw)); MD5Final(final,&ctx1); } |
︙ |
Changes to modules/pt/pt_cparam_config_critcl.tcl.
︙ | |||
110 111 112 113 114 115 116 117 118 119 120 121 122 123 | 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 | + + | # of pt::rde. Only the low-level engine is imported, the # Tcl interface layer is ignored. This generated parser # provides its own layer for that. critcl::ccode { /* -*- c -*- */ #include <stdint.h> #include <stdlib.h> #include <string.h> #define SCOPE static @@RUNTIME@@ } # # ## ### ###### ######## ############# |
︙ |
Changes to modules/pt/pt_cparam_config_tea.tcl.
︙ | |||
90 91 92 93 94 95 96 97 98 99 100 101 102 103 | 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 | + | ** ** Generated from file @file@ ** for user @user@ ** * * ** *** ***** ******** ************* *********************/ #include <string.h> #include <tcl.h> #include <stdint.h> #include <stdlib.h> #include <ctype.h> #define SCOPE static @@RUNTIME@@ @code@ /* -*- c -*- */ |
︙ |
Changes to modules/pt/pt_parse_peg_c.tcl.
︙ | |||
41 42 43 44 45 46 47 48 49 50 51 52 53 54 | 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 | + + | # of pt::rde. Only the low-level engine is imported, the # Tcl interface layer is ignored. This generated parser # provides its own layer for that. critcl::ccode { /* -*- c -*- */ #include <stdint.h> #include <stdlib.h> #include <string.h> #define SCOPE static #line 1 "rde_critcl/util.h" #ifndef _RDE_UTIL_H #define _RDE_UTIL_H 1 |
︙ | |||
728 729 730 731 732 733 734 | 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 | - + - + | rde_stack_get (p->ES, ec, (void***) ev); } SCOPE void rde_param_query_ls (RDE_PARAM p, long int* lc, void*** lv) { rde_stack_get (p->LS, lc, lv); } |
︙ | |||
892 893 894 895 896 897 898 | 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 | - + | { error_state_free (p->ER); p->ER = ALLOC (ERROR_STATE); p->ER->refCount = 1; p->ER->loc = p->CL; p->ER->msg = rde_stack_new (NULL); ASSERT_BOUNDS(s,p->numstr); |
︙ | |||
982 983 984 985 986 987 988 | 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 | - + - + - + - + | NC_STATE* scs; Tcl_HashEntry* hPtr; Tcl_HashTable* tablePtr; hPtr = Tcl_FindHashEntry (&p->NC, (char*) p->CL); if (!hPtr) { return 0; } tablePtr = (Tcl_HashTable*) Tcl_GetHashValue (hPtr); |
︙ | |||
1165 1166 1167 1168 1169 1170 1171 | 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 | - + + + - + | UniCharIsAscii (int character) { return (character >= 0) && (character < 0x80); } static int UniCharIsHexDigit (int character) { |
︙ | |||
4723 4724 4725 4726 4727 4728 4729 | 4727 4728 4729 4730 4731 4732 4733 4734 4735 4736 4737 4738 4739 4740 4741 | - + | # # ## ### ###### ######## ############# ## Global PARSER management, per interp critcl::ccode { /* -*- c -*- */ typedef struct PARSERg { |
︙ | |||
4751 4752 4753 4754 4755 4756 4757 | 4755 4756 4757 4758 4759 4760 4761 4762 4763 4764 4765 4766 4767 4768 4769 | - + | parserg->counter = 0; Tcl_SetAssocData (interp, KEY, proc, (ClientData) parserg); } parserg->counter ++; |
︙ |
Changes to modules/pt/pt_rdengine_c.tcl.
︙ | |||
44 45 46 47 48 49 50 | 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 | - + | #include <ms.h> /* Instance command */ /* .................................................. */ /* Global PARAM management, per interp */ typedef struct PARAMg { |
︙ | |||
72 73 74 75 76 77 78 | 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 | - + | paramg->counter = 0; Tcl_SetAssocData (interp, KEY, proc, (ClientData) paramg); } paramg->counter ++; |
︙ |
Changes to modules/pt/rde_critcl/p.c.
1 2 3 4 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 | - - + + + | /* pt::rde::critcl - critcl - layer 1 definitions * (c) PARAM functions */ |
︙ | |||
128 129 130 131 132 133 134 | 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 | - + | res = (long int) Tcl_GetHashValue (hPtr); RETURN("CACHED %d",res); } hPtr = Tcl_CreateHashEntry(&p->str, literal, &isnew); ASSERT (isnew, "Should have found entry"); |
︙ |
Changes to modules/pt/rde_critcl/param.c.
1 2 3 4 5 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 | + + + - - - - + + + + - | /* * = = == === ===== ======== ============= ===================== * == pt::rde (critcl) - Data Structures - PARAM architectural state. */ #include <stdint.h> #include <stdlib.h> #include <string.h> |
︙ | |||
416 417 418 419 420 421 422 | 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 | - + - + | SCOPE void rde_param_query_ls (RDE_PARAM p, long int* lc, void*** lv) { rde_stack_get (p->LS, lc, lv); } |
︙ | |||
666 667 668 669 670 671 672 | 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 | - + | p->ER = ALLOC (ERROR_STATE); p->ER->refCount = 1; p->ER->loc = p->CL; p->ER->msg = rde_stack_new (NULL); ASSERT_BOUNDS(s,p->numstr); |
︙ | |||
816 817 818 819 820 821 822 | 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 | - + | * 2-level hash table keyed by location, and symbol ... */ hPtr = Tcl_FindHashEntry (&p->NC, (char*) p->CL); if (!hPtr) { return 0; } tablePtr = (Tcl_HashTable*) Tcl_GetHashValue (hPtr); |
︙ | |||
857 858 859 860 861 862 863 | 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 | - + - + | TRACE (("RDE_PARAM %p",p)); TRACE (("INT %d",s)); /* * 2-level hash table keyed by location, and symbol ... */ |
︙ | |||
1067 1068 1069 1070 1071 1072 1073 | 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 | - + + + - + | { return (character >= 0) && (character < 0x80); } static int UniCharIsHexDigit (int character) { |
︙ |
Changes to modules/pt/rde_critcl/param.h.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 | + | /* * = = == === ===== ======== ============= ===================== * == pt::rde (critcl) - Data Structures - PARAM architectural state. */ #ifndef _RDE_DS_PARAM_H #define _RDE_DS_PARAM_H 1 #include "tcl.h" #include <util.h> /* Scoping */ #include <stack.h> /* Stack handling */ #include <stdint.h> /* intptr_t */ /* * The state structure is opaque, its internals are known only to the * functions declared here. */ typedef struct RDE_PARAM_* RDE_PARAM; |
︙ | |||
50 51 52 53 54 55 56 | 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 | - + | SCOPE const char* rde_param_query_in (RDE_PARAM p); SCOPE const char* rde_param_query_cc (RDE_PARAM p, long int* len); SCOPE int rde_param_query_cl (RDE_PARAM p); SCOPE const ERROR_STATE* rde_param_query_er (RDE_PARAM p); SCOPE Tcl_Obj* rde_param_query_er_tcl (RDE_PARAM p, const ERROR_STATE* er); SCOPE void rde_param_query_es (RDE_PARAM p, long int* ec, ERROR_STATE*** ev); SCOPE void rde_param_query_ls (RDE_PARAM p, long int* lc, void*** lv); |
︙ |
Changes to modules/pt/tests/data/ok/peg_cparam-critcl/0_basic_arithmetic.
︙ | |||
41 42 43 44 45 46 47 48 49 50 51 52 53 54 | 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 | + + | # of pt::rde. Only the low-level engine is imported, the # Tcl interface layer is ignored. This generated parser # provides its own layer for that. critcl::ccode { /* -*- c -*- */ #include <stdint.h> #include <stdlib.h> #include <string.h> #define SCOPE static #line 1 "rde_critcl/util.h" #ifndef _RDE_UTIL_H #define _RDE_UTIL_H 1 |
︙ | |||
728 729 730 731 732 733 734 | 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 | - + - + | rde_stack_get (p->ES, ec, (void***) ev); } SCOPE void rde_param_query_ls (RDE_PARAM p, long int* lc, void*** lv) { rde_stack_get (p->LS, lc, lv); } |
︙ | |||
892 893 894 895 896 897 898 | 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 | - + | { error_state_free (p->ER); p->ER = ALLOC (ERROR_STATE); p->ER->refCount = 1; p->ER->loc = p->CL; p->ER->msg = rde_stack_new (NULL); ASSERT_BOUNDS(s,p->numstr); |
︙ | |||
982 983 984 985 986 987 988 | 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 | - + | NC_STATE* scs; Tcl_HashEntry* hPtr; Tcl_HashTable* tablePtr; hPtr = Tcl_FindHashEntry (&p->NC, (char*) p->CL); if (!hPtr) { return 0; } tablePtr = (Tcl_HashTable*) Tcl_GetHashValue (hPtr); |
︙ | |||
1007 1008 1009 1010 1011 1012 1013 | 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 | - + - + | Tcl_HashEntry* hPtr; Tcl_HashTable* tablePtr; int isnew; ENTER ("rde_param_i_symbol_save"); TRACE (("RDE_PARAM %p",p)); TRACE (("INT %d",s)); |
︙ | |||
1165 1166 1167 1168 1169 1170 1171 | 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 | - + + + - + | UniCharIsAscii (int character) { return (character >= 0) && (character < 0x80); } static int UniCharIsHexDigit (int character) { |
︙ |
Changes to modules/pt/tests/data/ok/peg_cparam-critcl/10_notahead.
︙ | |||
41 42 43 44 45 46 47 48 49 50 51 52 53 54 | 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 | + + | # of pt::rde. Only the low-level engine is imported, the # Tcl interface layer is ignored. This generated parser # provides its own layer for that. critcl::ccode { /* -*- c -*- */ #include <stdint.h> #include <stdlib.h> #include <string.h> #define SCOPE static #line 1 "rde_critcl/util.h" #ifndef _RDE_UTIL_H #define _RDE_UTIL_H 1 |
︙ | |||
728 729 730 731 732 733 734 | 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 | - + - + | rde_stack_get (p->ES, ec, (void***) ev); } SCOPE void rde_param_query_ls (RDE_PARAM p, long int* lc, void*** lv) { rde_stack_get (p->LS, lc, lv); } |
︙ | |||
892 893 894 895 896 897 898 | 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 | - + | { error_state_free (p->ER); p->ER = ALLOC (ERROR_STATE); p->ER->refCount = 1; p->ER->loc = p->CL; p->ER->msg = rde_stack_new (NULL); ASSERT_BOUNDS(s,p->numstr); |
︙ | |||
982 983 984 985 986 987 988 | 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 | - + | NC_STATE* scs; Tcl_HashEntry* hPtr; Tcl_HashTable* tablePtr; hPtr = Tcl_FindHashEntry (&p->NC, (char*) p->CL); if (!hPtr) { return 0; } tablePtr = (Tcl_HashTable*) Tcl_GetHashValue (hPtr); |
︙ | |||
1007 1008 1009 1010 1011 1012 1013 | 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 | - + - + | Tcl_HashEntry* hPtr; Tcl_HashTable* tablePtr; int isnew; ENTER ("rde_param_i_symbol_save"); TRACE (("RDE_PARAM %p",p)); TRACE (("INT %d",s)); |
︙ | |||
1165 1166 1167 1168 1169 1170 1171 | 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 | - + + + - + | UniCharIsAscii (int character) { return (character >= 0) && (character < 0x80); } static int UniCharIsHexDigit (int character) { |
︙ |
Changes to modules/pt/tests/data/ok/peg_cparam-critcl/11_epsilon.
︙ | |||
41 42 43 44 45 46 47 48 49 50 51 52 53 54 | 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 | + + | # of pt::rde. Only the low-level engine is imported, the # Tcl interface layer is ignored. This generated parser # provides its own layer for that. critcl::ccode { /* -*- c -*- */ #include <stdint.h> #include <stdlib.h> #include <string.h> #define SCOPE static #line 1 "rde_critcl/util.h" #ifndef _RDE_UTIL_H #define _RDE_UTIL_H 1 |
︙ | |||
728 729 730 731 732 733 734 | 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 | - + - + | rde_stack_get (p->ES, ec, (void***) ev); } SCOPE void rde_param_query_ls (RDE_PARAM p, long int* lc, void*** lv) { rde_stack_get (p->LS, lc, lv); } |
︙ | |||
892 893 894 895 896 897 898 | 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 | - + | { error_state_free (p->ER); p->ER = ALLOC (ERROR_STATE); p->ER->refCount = 1; p->ER->loc = p->CL; p->ER->msg = rde_stack_new (NULL); ASSERT_BOUNDS(s,p->numstr); |
︙ | |||
982 983 984 985 986 987 988 | 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 | - + | NC_STATE* scs; Tcl_HashEntry* hPtr; Tcl_HashTable* tablePtr; hPtr = Tcl_FindHashEntry (&p->NC, (char*) p->CL); if (!hPtr) { return 0; } tablePtr = (Tcl_HashTable*) Tcl_GetHashValue (hPtr); |
︙ | |||
1007 1008 1009 1010 1011 1012 1013 | 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 | - + - + | Tcl_HashEntry* hPtr; Tcl_HashTable* tablePtr; int isnew; ENTER ("rde_param_i_symbol_save"); TRACE (("RDE_PARAM %p",p)); TRACE (("INT %d",s)); |
︙ | |||
1165 1166 1167 1168 1169 1170 1171 | 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 | - + + + - + | UniCharIsAscii (int character) { return (character >= 0) && (character < 0x80); } static int UniCharIsHexDigit (int character) { |
︙ |
Changes to modules/pt/tests/data/ok/peg_cparam-critcl/1_functions.
︙ | |||
41 42 43 44 45 46 47 48 49 50 51 52 53 54 | 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 | + + | # of pt::rde. Only the low-level engine is imported, the # Tcl interface layer is ignored. This generated parser # provides its own layer for that. critcl::ccode { /* -*- c -*- */ #include <stdint.h> #include <stdlib.h> #include <string.h> #define SCOPE static #line 1 "rde_critcl/util.h" #ifndef _RDE_UTIL_H #define _RDE_UTIL_H 1 |
︙ | |||
728 729 730 731 732 733 734 | 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 | - + - + | rde_stack_get (p->ES, ec, (void***) ev); } SCOPE void rde_param_query_ls (RDE_PARAM p, long int* lc, void*** lv) { rde_stack_get (p->LS, lc, lv); } |
︙ | |||
892 893 894 895 896 897 898 | 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 | - + | { error_state_free (p->ER); p->ER = ALLOC (ERROR_STATE); p->ER->refCount = 1; p->ER->loc = p->CL; p->ER->msg = rde_stack_new (NULL); ASSERT_BOUNDS(s,p->numstr); |
︙ | |||
982 983 984 985 986 987 988 | 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 | - + | NC_STATE* scs; Tcl_HashEntry* hPtr; Tcl_HashTable* tablePtr; hPtr = Tcl_FindHashEntry (&p->NC, (char*) p->CL); if (!hPtr) { return 0; } tablePtr = (Tcl_HashTable*) Tcl_GetHashValue (hPtr); |
︙ | |||
1007 1008 1009 1010 1011 1012 1013 | 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 | - + - + | Tcl_HashEntry* hPtr; Tcl_HashTable* tablePtr; int isnew; ENTER ("rde_param_i_symbol_save"); TRACE (("RDE_PARAM %p",p)); TRACE (("INT %d",s)); |
︙ | |||
1165 1166 1167 1168 1169 1170 1171 | 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 | - + + + - + | UniCharIsAscii (int character) { return (character >= 0) && (character < 0x80); } static int UniCharIsHexDigit (int character) { |
︙ |
Changes to modules/pt/tests/data/ok/peg_cparam-critcl/2_fun_arithmetic.
︙ | |||
41 42 43 44 45 46 47 48 49 50 51 52 53 54 | 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 | + + | # of pt::rde. Only the low-level engine is imported, the # Tcl interface layer is ignored. This generated parser # provides its own layer for that. critcl::ccode { /* -*- c -*- */ #include <stdint.h> #include <stdlib.h> #include <string.h> #define SCOPE static #line 1 "rde_critcl/util.h" #ifndef _RDE_UTIL_H #define _RDE_UTIL_H 1 |
︙ | |||
728 729 730 731 732 733 734 | 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 | - + - + | rde_stack_get (p->ES, ec, (void***) ev); } SCOPE void rde_param_query_ls (RDE_PARAM p, long int* lc, void*** lv) { rde_stack_get (p->LS, lc, lv); } |
︙ | |||
892 893 894 895 896 897 898 | 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 | - + | { error_state_free (p->ER); p->ER = ALLOC (ERROR_STATE); p->ER->refCount = 1; p->ER->loc = p->CL; p->ER->msg = rde_stack_new (NULL); ASSERT_BOUNDS(s,p->numstr); |
︙ | |||
982 983 984 985 986 987 988 | 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 | - + | NC_STATE* scs; Tcl_HashEntry* hPtr; Tcl_HashTable* tablePtr; hPtr = Tcl_FindHashEntry (&p->NC, (char*) p->CL); if (!hPtr) { return 0; } tablePtr = (Tcl_HashTable*) Tcl_GetHashValue (hPtr); |
︙ | |||
1007 1008 1009 1010 1011 1012 1013 | 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 | - + - + | Tcl_HashEntry* hPtr; Tcl_HashTable* tablePtr; int isnew; ENTER ("rde_param_i_symbol_save"); TRACE (("RDE_PARAM %p",p)); TRACE (("INT %d",s)); |
︙ | |||
1165 1166 1167 1168 1169 1170 1171 | 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 | - + + + - + | UniCharIsAscii (int character) { return (character >= 0) && (character < 0x80); } static int UniCharIsHexDigit (int character) { |
︙ |
Changes to modules/pt/tests/data/ok/peg_cparam-critcl/3_peg_itself.
︙ | |||
41 42 43 44 45 46 47 48 49 50 51 52 53 54 | 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 | + + | # of pt::rde. Only the low-level engine is imported, the # Tcl interface layer is ignored. This generated parser # provides its own layer for that. critcl::ccode { /* -*- c -*- */ #include <stdint.h> #include <stdlib.h> #include <string.h> #define SCOPE static #line 1 "rde_critcl/util.h" #ifndef _RDE_UTIL_H #define _RDE_UTIL_H 1 |
︙ | |||
728 729 730 731 732 733 734 | 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 | - + - + | rde_stack_get (p->ES, ec, (void***) ev); } SCOPE void rde_param_query_ls (RDE_PARAM p, long int* lc, void*** lv) { rde_stack_get (p->LS, lc, lv); } |
︙ | |||
892 893 894 895 896 897 898 | 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 | - + | { error_state_free (p->ER); p->ER = ALLOC (ERROR_STATE); p->ER->refCount = 1; p->ER->loc = p->CL; p->ER->msg = rde_stack_new (NULL); ASSERT_BOUNDS(s,p->numstr); |
︙ | |||
982 983 984 985 986 987 988 | 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 | - + | NC_STATE* scs; Tcl_HashEntry* hPtr; Tcl_HashTable* tablePtr; hPtr = Tcl_FindHashEntry (&p->NC, (char*) p->CL); if (!hPtr) { return 0; } tablePtr = (Tcl_HashTable*) Tcl_GetHashValue (hPtr); |
︙ | |||
1007 1008 1009 1010 1011 1012 1013 | 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 | - + - + | Tcl_HashEntry* hPtr; Tcl_HashTable* tablePtr; int isnew; ENTER ("rde_param_i_symbol_save"); TRACE (("RDE_PARAM %p",p)); TRACE (("INT %d",s)); |
︙ | |||
1165 1166 1167 1168 1169 1170 1171 | 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 | - + + + - + | UniCharIsAscii (int character) { return (character >= 0) && (character < 0x80); } static int UniCharIsHexDigit (int character) { |
︙ |
Changes to modules/pt/tests/data/ok/peg_cparam-critcl/4_choice.
︙ | |||
41 42 43 44 45 46 47 48 49 50 51 52 53 54 | 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 | + + | # of pt::rde. Only the low-level engine is imported, the # Tcl interface layer is ignored. This generated parser # provides its own layer for that. critcl::ccode { /* -*- c -*- */ #include <stdint.h> #include <stdlib.h> #include <string.h> #define SCOPE static #line 1 "rde_critcl/util.h" #ifndef _RDE_UTIL_H #define _RDE_UTIL_H 1 |
︙ | |||
728 729 730 731 732 733 734 | 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 | - + - + | rde_stack_get (p->ES, ec, (void***) ev); } SCOPE void rde_param_query_ls (RDE_PARAM p, long int* lc, void*** lv) { rde_stack_get (p->LS, lc, lv); } |
︙ | |||
892 893 894 895 896 897 898 | 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 | - + | { error_state_free (p->ER); p->ER = ALLOC (ERROR_STATE); p->ER->refCount = 1; p->ER->loc = p->CL; p->ER->msg = rde_stack_new (NULL); ASSERT_BOUNDS(s,p->numstr); |
︙ | |||
982 983 984 985 986 987 988 | 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 | - + | NC_STATE* scs; Tcl_HashEntry* hPtr; Tcl_HashTable* tablePtr; hPtr = Tcl_FindHashEntry (&p->NC, (char*) p->CL); if (!hPtr) { return 0; } tablePtr = (Tcl_HashTable*) Tcl_GetHashValue (hPtr); |
︙ | |||
1007 1008 1009 1010 1011 1012 1013 | 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 | - + - + | Tcl_HashEntry* hPtr; Tcl_HashTable* tablePtr; int isnew; ENTER ("rde_param_i_symbol_save"); TRACE (("RDE_PARAM %p",p)); TRACE (("INT %d",s)); |
︙ | |||
1165 1166 1167 1168 1169 1170 1171 | 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 | - + + + - + | UniCharIsAscii (int character) { return (character >= 0) && (character < 0x80); } static int UniCharIsHexDigit (int character) { |
︙ |
Changes to modules/pt/tests/data/ok/peg_cparam-critcl/5_sequence.
︙ | |||
41 42 43 44 45 46 47 48 49 50 51 52 53 54 | 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 | + + | # of pt::rde. Only the low-level engine is imported, the # Tcl interface layer is ignored. This generated parser # provides its own layer for that. critcl::ccode { /* -*- c -*- */ #include <stdint.h> #include <stdlib.h> #include <string.h> #define SCOPE static #line 1 "rde_critcl/util.h" #ifndef _RDE_UTIL_H #define _RDE_UTIL_H 1 |
︙ | |||
728 729 730 731 732 733 734 | 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 | - + - + | rde_stack_get (p->ES, ec, (void***) ev); } SCOPE void rde_param_query_ls (RDE_PARAM p, long int* lc, void*** lv) { rde_stack_get (p->LS, lc, lv); } |
︙ | |||
892 893 894 895 896 897 898 | 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 | - + | { error_state_free (p->ER); p->ER = ALLOC (ERROR_STATE); p->ER->refCount = 1; p->ER->loc = p->CL; p->ER->msg = rde_stack_new (NULL); ASSERT_BOUNDS(s,p->numstr); |
︙ | |||
982 983 984 985 986 987 988 | 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 | - + | NC_STATE* scs; Tcl_HashEntry* hPtr; Tcl_HashTable* tablePtr; hPtr = Tcl_FindHashEntry (&p->NC, (char*) p->CL); if (!hPtr) { return 0; } tablePtr = (Tcl_HashTable*) Tcl_GetHashValue (hPtr); |
︙ | |||
1007 1008 1009 1010 1011 1012 1013 | 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 | - + - + | Tcl_HashEntry* hPtr; Tcl_HashTable* tablePtr; int isnew; ENTER ("rde_param_i_symbol_save"); TRACE (("RDE_PARAM %p",p)); TRACE (("INT %d",s)); |
︙ | |||
1165 1166 1167 1168 1169 1170 1171 | 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 | - + + + - + | UniCharIsAscii (int character) { return (character >= 0) && (character < 0x80); } static int UniCharIsHexDigit (int character) { |
︙ |
Changes to modules/pt/tests/data/ok/peg_cparam-critcl/6_optional.
︙ | |||
41 42 43 44 45 46 47 48 49 50 51 52 53 54 | 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 | + + | # of pt::rde. Only the low-level engine is imported, the # Tcl interface layer is ignored. This generated parser # provides its own layer for that. critcl::ccode { /* -*- c -*- */ #include <stdint.h> #include <stdlib.h> #include <string.h> #define SCOPE static #line 1 "rde_critcl/util.h" #ifndef _RDE_UTIL_H #define _RDE_UTIL_H 1 |
︙ | |||
728 729 730 731 732 733 734 | 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 | - + - + | rde_stack_get (p->ES, ec, (void***) ev); } SCOPE void rde_param_query_ls (RDE_PARAM p, long int* lc, void*** lv) { rde_stack_get (p->LS, lc, lv); } |
︙ | |||
892 893 894 895 896 897 898 | 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 | - + | { error_state_free (p->ER); p->ER = ALLOC (ERROR_STATE); p->ER->refCount = 1; p->ER->loc = p->CL; p->ER->msg = rde_stack_new (NULL); ASSERT_BOUNDS(s,p->numstr); |
︙ | |||
982 983 984 985 986 987 988 | 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 | - + | NC_STATE* scs; Tcl_HashEntry* hPtr; Tcl_HashTable* tablePtr; hPtr = Tcl_FindHashEntry (&p->NC, (char*) p->CL); if (!hPtr) { return 0; } tablePtr = (Tcl_HashTable*) Tcl_GetHashValue (hPtr); |
︙ | |||
1007 1008 1009 1010 1011 1012 1013 | 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 | - + - + | Tcl_HashEntry* hPtr; Tcl_HashTable* tablePtr; int isnew; ENTER ("rde_param_i_symbol_save"); TRACE (("RDE_PARAM %p",p)); TRACE (("INT %d",s)); |
︙ | |||
1165 1166 1167 1168 1169 1170 1171 | 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 | - + + + - + | UniCharIsAscii (int character) { return (character >= 0) && (character < 0x80); } static int UniCharIsHexDigit (int character) { |
︙ |
Changes to modules/pt/tests/data/ok/peg_cparam-critcl/7_kleene.
︙ | |||
41 42 43 44 45 46 47 48 49 50 51 52 53 54 | 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 | + + | # of pt::rde. Only the low-level engine is imported, the # Tcl interface layer is ignored. This generated parser # provides its own layer for that. critcl::ccode { /* -*- c -*- */ #include <stdint.h> #include <stdlib.h> #include <string.h> #define SCOPE static #line 1 "rde_critcl/util.h" #ifndef _RDE_UTIL_H #define _RDE_UTIL_H 1 |
︙ | |||
728 729 730 731 732 733 734 | 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 | - + - + | rde_stack_get (p->ES, ec, (void***) ev); } SCOPE void rde_param_query_ls (RDE_PARAM p, long int* lc, void*** lv) { rde_stack_get (p->LS, lc, lv); } |
︙ | |||
892 893 894 895 896 897 898 | 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 | - + | { error_state_free (p->ER); p->ER = ALLOC (ERROR_STATE); p->ER->refCount = 1; p->ER->loc = p->CL; p->ER->msg = rde_stack_new (NULL); ASSERT_BOUNDS(s,p->numstr); |
︙ | |||
982 983 984 985 986 987 988 | 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 | - + | NC_STATE* scs; Tcl_HashEntry* hPtr; Tcl_HashTable* tablePtr; hPtr = Tcl_FindHashEntry (&p->NC, (char*) p->CL); if (!hPtr) { return 0; } tablePtr = (Tcl_HashTable*) Tcl_GetHashValue (hPtr); |
︙ | |||
1007 1008 1009 1010 1011 1012 1013 | 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 | - + - + | Tcl_HashEntry* hPtr; Tcl_HashTable* tablePtr; int isnew; ENTER ("rde_param_i_symbol_save"); TRACE (("RDE_PARAM %p",p)); TRACE (("INT %d",s)); |
︙ | |||
1165 1166 1167 1168 1169 1170 1171 | 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 | - + + + - + | UniCharIsAscii (int character) { return (character >= 0) && (character < 0x80); } static int UniCharIsHexDigit (int character) { |
︙ |
Changes to modules/pt/tests/data/ok/peg_cparam-critcl/8_pkleene.
︙ | |||
41 42 43 44 45 46 47 48 49 50 51 52 53 54 | 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 | + + | # of pt::rde. Only the low-level engine is imported, the # Tcl interface layer is ignored. This generated parser # provides its own layer for that. critcl::ccode { /* -*- c -*- */ #include <stdint.h> #include <stdlib.h> #include <string.h> #define SCOPE static #line 1 "rde_critcl/util.h" #ifndef _RDE_UTIL_H #define _RDE_UTIL_H 1 |
︙ | |||
728 729 730 731 732 733 734 | 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 | - + - + | rde_stack_get (p->ES, ec, (void***) ev); } SCOPE void rde_param_query_ls (RDE_PARAM p, long int* lc, void*** lv) { rde_stack_get (p->LS, lc, lv); } |
︙ | |||
892 893 894 895 896 897 898 | 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 | - + | { error_state_free (p->ER); p->ER = ALLOC (ERROR_STATE); p->ER->refCount = 1; p->ER->loc = p->CL; p->ER->msg = rde_stack_new (NULL); ASSERT_BOUNDS(s,p->numstr); |
︙ | |||
982 983 984 985 986 987 988 | 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 | - + | NC_STATE* scs; Tcl_HashEntry* hPtr; Tcl_HashTable* tablePtr; hPtr = Tcl_FindHashEntry (&p->NC, (char*) p->CL); if (!hPtr) { return 0; } tablePtr = (Tcl_HashTable*) Tcl_GetHashValue (hPtr); |
︙ | |||
1007 1008 1009 1010 1011 1012 1013 | 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 | - + - + | Tcl_HashEntry* hPtr; Tcl_HashTable* tablePtr; int isnew; ENTER ("rde_param_i_symbol_save"); TRACE (("RDE_PARAM %p",p)); TRACE (("INT %d",s)); |
︙ | |||
1165 1166 1167 1168 1169 1170 1171 | 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 | - + + + - + | UniCharIsAscii (int character) { return (character >= 0) && (character < 0x80); } static int UniCharIsHexDigit (int character) { |
︙ |
Changes to modules/pt/tests/data/ok/peg_cparam-critcl/9_ahead.
︙ | |||
41 42 43 44 45 46 47 48 49 50 51 52 53 54 | 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 | + + | # of pt::rde. Only the low-level engine is imported, the # Tcl interface layer is ignored. This generated parser # provides its own layer for that. critcl::ccode { /* -*- c -*- */ #include <stdint.h> #include <stdlib.h> #include <string.h> #define SCOPE static #line 1 "rde_critcl/util.h" #ifndef _RDE_UTIL_H #define _RDE_UTIL_H 1 |
︙ | |||
728 729 730 731 732 733 734 | 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 | - + - + | rde_stack_get (p->ES, ec, (void***) ev); } SCOPE void rde_param_query_ls (RDE_PARAM p, long int* lc, void*** lv) { rde_stack_get (p->LS, lc, lv); } |
︙ | |||
892 893 894 895 896 897 898 | 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 | - + | { error_state_free (p->ER); p->ER = ALLOC (ERROR_STATE); p->ER->refCount = 1; p->ER->loc = p->CL; p->ER->msg = rde_stack_new (NULL); ASSERT_BOUNDS(s,p->numstr); |
︙ | |||
982 983 984 985 986 987 988 | 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 | - + | NC_STATE* scs; Tcl_HashEntry* hPtr; Tcl_HashTable* tablePtr; hPtr = Tcl_FindHashEntry (&p->NC, (char*) p->CL); if (!hPtr) { return 0; } tablePtr = (Tcl_HashTable*) Tcl_GetHashValue (hPtr); |
︙ | |||
1007 1008 1009 1010 1011 1012 1013 | 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 | - + - + | Tcl_HashEntry* hPtr; Tcl_HashTable* tablePtr; int isnew; ENTER ("rde_param_i_symbol_save"); TRACE (("RDE_PARAM %p",p)); TRACE (("INT %d",s)); |
︙ | |||
1165 1166 1167 1168 1169 1170 1171 | 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 | - + + + - + | UniCharIsAscii (int character) { return (character >= 0) && (character < 0x80); } static int UniCharIsHexDigit (int character) { |
︙ |
Changes to modules/pt/tests/data/ok/peg_cparam-tea/0_basic_arithmetic.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 | + | /************************************************************ ** ** TEA-based C/PARAM implementation of the parsing ** expression grammar ** ** TEMPLATE ** ** Generated from file TEST ** for user unknown ** * * ** *** ***** ******** ************* *********************/ #include <string.h> #include <tcl.h> #include <stdint.h> #include <stdlib.h> #include <ctype.h> #define SCOPE static #line 1 "rde_critcl/util.h" #ifndef _RDE_UTIL_H |
︙ | |||
695 696 697 698 699 700 701 | 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 | - + - + | rde_stack_get (p->ES, ec, (void***) ev); } SCOPE void rde_param_query_ls (RDE_PARAM p, long int* lc, void*** lv) { rde_stack_get (p->LS, lc, lv); } |
︙ | |||
859 860 861 862 863 864 865 | 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 | - + | { error_state_free (p->ER); p->ER = ALLOC (ERROR_STATE); p->ER->refCount = 1; p->ER->loc = p->CL; p->ER->msg = rde_stack_new (NULL); ASSERT_BOUNDS(s,p->numstr); |
︙ | |||
949 950 951 952 953 954 955 | 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 | - + | NC_STATE* scs; Tcl_HashEntry* hPtr; Tcl_HashTable* tablePtr; hPtr = Tcl_FindHashEntry (&p->NC, (char*) p->CL); if (!hPtr) { return 0; } tablePtr = (Tcl_HashTable*) Tcl_GetHashValue (hPtr); |
︙ | |||
974 975 976 977 978 979 980 | 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 | - + - + | Tcl_HashEntry* hPtr; Tcl_HashTable* tablePtr; int isnew; ENTER ("rde_param_i_symbol_save"); TRACE (("RDE_PARAM %p",p)); TRACE (("INT %d",s)); |
︙ | |||
1132 1133 1134 1135 1136 1137 1138 | 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 | - + + + - + | UniCharIsAscii (int character) { return (character >= 0) && (character < 0x80); } static int UniCharIsHexDigit (int character) { |
︙ |
Changes to modules/pt/tests/data/ok/peg_cparam-tea/10_notahead.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 | + | /************************************************************ ** ** TEA-based C/PARAM implementation of the parsing ** expression grammar ** ** TEMPLATE ** ** Generated from file TEST ** for user unknown ** * * ** *** ***** ******** ************* *********************/ #include <string.h> #include <tcl.h> #include <stdint.h> #include <stdlib.h> #include <ctype.h> #define SCOPE static #line 1 "rde_critcl/util.h" #ifndef _RDE_UTIL_H |
︙ | |||
695 696 697 698 699 700 701 | 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 | - + - + | rde_stack_get (p->ES, ec, (void***) ev); } SCOPE void rde_param_query_ls (RDE_PARAM p, long int* lc, void*** lv) { rde_stack_get (p->LS, lc, lv); } |
︙ | |||
859 860 861 862 863 864 865 | 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 | - + | { error_state_free (p->ER); p->ER = ALLOC (ERROR_STATE); p->ER->refCount = 1; p->ER->loc = p->CL; p->ER->msg = rde_stack_new (NULL); ASSERT_BOUNDS(s,p->numstr); |
︙ | |||
949 950 951 952 953 954 955 | 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 | - + | NC_STATE* scs; Tcl_HashEntry* hPtr; Tcl_HashTable* tablePtr; hPtr = Tcl_FindHashEntry (&p->NC, (char*) p->CL); if (!hPtr) { return 0; } tablePtr = (Tcl_HashTable*) Tcl_GetHashValue (hPtr); |
︙ | |||
974 975 976 977 978 979 980 | 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 | - + - + | Tcl_HashEntry* hPtr; Tcl_HashTable* tablePtr; int isnew; ENTER ("rde_param_i_symbol_save"); TRACE (("RDE_PARAM %p",p)); TRACE (("INT %d",s)); |
︙ | |||
1132 1133 1134 1135 1136 1137 1138 | 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 | - + + + - + | UniCharIsAscii (int character) { return (character >= 0) && (character < 0x80); } static int UniCharIsHexDigit (int character) { |
︙ |
Changes to modules/pt/tests/data/ok/peg_cparam-tea/11_epsilon.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 | + | /************************************************************ ** ** TEA-based C/PARAM implementation of the parsing ** expression grammar ** ** TEMPLATE ** ** Generated from file TEST ** for user unknown ** * * ** *** ***** ******** ************* *********************/ #include <string.h> #include <tcl.h> #include <stdint.h> #include <stdlib.h> #include <ctype.h> #define SCOPE static #line 1 "rde_critcl/util.h" #ifndef _RDE_UTIL_H |
︙ | |||
695 696 697 698 699 700 701 | 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 | - + - + | rde_stack_get (p->ES, ec, (void***) ev); } SCOPE void rde_param_query_ls (RDE_PARAM p, long int* lc, void*** lv) { rde_stack_get (p->LS, lc, lv); } |
︙ | |||
859 860 861 862 863 864 865 | 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 | - + | { error_state_free (p->ER); p->ER = ALLOC (ERROR_STATE); p->ER->refCount = 1; p->ER->loc = p->CL; p->ER->msg = rde_stack_new (NULL); ASSERT_BOUNDS(s,p->numstr); |
︙ | |||
949 950 951 952 953 954 955 | 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 | - + | NC_STATE* scs; Tcl_HashEntry* hPtr; Tcl_HashTable* tablePtr; hPtr = Tcl_FindHashEntry (&p->NC, (char*) p->CL); if (!hPtr) { return 0; } tablePtr = (Tcl_HashTable*) Tcl_GetHashValue (hPtr); |
︙ | |||
974 975 976 977 978 979 980 | 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 | - + - + | Tcl_HashEntry* hPtr; Tcl_HashTable* tablePtr; int isnew; ENTER ("rde_param_i_symbol_save"); TRACE (("RDE_PARAM %p",p)); TRACE (("INT %d",s)); |
︙ | |||
1132 1133 1134 1135 1136 1137 1138 | 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 | - + + + - + | UniCharIsAscii (int character) { return (character >= 0) && (character < 0x80); } static int UniCharIsHexDigit (int character) { |
︙ |
Changes to modules/pt/tests/data/ok/peg_cparam-tea/1_functions.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 | + | /************************************************************ ** ** TEA-based C/PARAM implementation of the parsing ** expression grammar ** ** TEMPLATE ** ** Generated from file TEST ** for user unknown ** * * ** *** ***** ******** ************* *********************/ #include <string.h> #include <tcl.h> #include <stdint.h> #include <stdlib.h> #include <ctype.h> #define SCOPE static #line 1 "rde_critcl/util.h" #ifndef _RDE_UTIL_H |
︙ | |||
695 696 697 698 699 700 701 | 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 | - + - + | rde_stack_get (p->ES, ec, (void***) ev); } SCOPE void rde_param_query_ls (RDE_PARAM p, long int* lc, void*** lv) { rde_stack_get (p->LS, lc, lv); } |
︙ | |||
859 860 861 862 863 864 865 | 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 | - + | { error_state_free (p->ER); p->ER = ALLOC (ERROR_STATE); p->ER->refCount = 1; p->ER->loc = p->CL; p->ER->msg = rde_stack_new (NULL); ASSERT_BOUNDS(s,p->numstr); |
︙ | |||
949 950 951 952 953 954 955 | 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 | - + | NC_STATE* scs; Tcl_HashEntry* hPtr; Tcl_HashTable* tablePtr; hPtr = Tcl_FindHashEntry (&p->NC, (char*) p->CL); if (!hPtr) { return 0; } tablePtr = (Tcl_HashTable*) Tcl_GetHashValue (hPtr); |
︙ | |||
974 975 976 977 978 979 980 | 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 | - + - + | Tcl_HashEntry* hPtr; Tcl_HashTable* tablePtr; int isnew; ENTER ("rde_param_i_symbol_save"); TRACE (("RDE_PARAM %p",p)); TRACE (("INT %d",s)); |
︙ | |||
1132 1133 1134 1135 1136 1137 1138 | 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 | - + + + - + | UniCharIsAscii (int character) { return (character >= 0) && (character < 0x80); } static int UniCharIsHexDigit (int character) { |
︙ |
Changes to modules/pt/tests/data/ok/peg_cparam-tea/2_fun_arithmetic.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 | + | /************************************************************ ** ** TEA-based C/PARAM implementation of the parsing ** expression grammar ** ** TEMPLATE ** ** Generated from file TEST ** for user unknown ** * * ** *** ***** ******** ************* *********************/ #include <string.h> #include <tcl.h> #include <stdint.h> #include <stdlib.h> #include <ctype.h> #define SCOPE static #line 1 "rde_critcl/util.h" #ifndef _RDE_UTIL_H |
︙ | |||
695 696 697 698 699 700 701 | 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 | - + - + | rde_stack_get (p->ES, ec, (void***) ev); } SCOPE void rde_param_query_ls (RDE_PARAM p, long int* lc, void*** lv) { rde_stack_get (p->LS, lc, lv); } |
︙ | |||
859 860 861 862 863 864 865 | 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 | - + | { error_state_free (p->ER); p->ER = ALLOC (ERROR_STATE); p->ER->refCount = 1; p->ER->loc = p->CL; p->ER->msg = rde_stack_new (NULL); ASSERT_BOUNDS(s,p->numstr); |
︙ | |||
949 950 951 952 953 954 955 | 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 | - + | NC_STATE* scs; Tcl_HashEntry* hPtr; Tcl_HashTable* tablePtr; hPtr = Tcl_FindHashEntry (&p->NC, (char*) p->CL); if (!hPtr) { return 0; } tablePtr = (Tcl_HashTable*) Tcl_GetHashValue (hPtr); |
︙ | |||
974 975 976 977 978 979 980 | 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 | - + - + | Tcl_HashEntry* hPtr; Tcl_HashTable* tablePtr; int isnew; ENTER ("rde_param_i_symbol_save"); TRACE (("RDE_PARAM %p",p)); TRACE (("INT %d",s)); |
︙ | |||
1132 1133 1134 1135 1136 1137 1138 | 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 | - + + + - + | UniCharIsAscii (int character) { return (character >= 0) && (character < 0x80); } static int UniCharIsHexDigit (int character) { |
︙ |
Changes to modules/pt/tests/data/ok/peg_cparam-tea/3_peg_itself.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 | + | /************************************************************ ** ** TEA-based C/PARAM implementation of the parsing ** expression grammar ** ** TEMPLATE ** ** Generated from file TEST ** for user unknown ** * * ** *** ***** ******** ************* *********************/ #include <string.h> #include <tcl.h> #include <stdint.h> #include <stdlib.h> #include <ctype.h> #define SCOPE static #line 1 "rde_critcl/util.h" #ifndef _RDE_UTIL_H |
︙ | |||
695 696 697 698 699 700 701 | 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 | - + - + | rde_stack_get (p->ES, ec, (void***) ev); } SCOPE void rde_param_query_ls (RDE_PARAM p, long int* lc, void*** lv) { rde_stack_get (p->LS, lc, lv); } |
︙ | |||
859 860 861 862 863 864 865 | 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 | - + | { error_state_free (p->ER); p->ER = ALLOC (ERROR_STATE); p->ER->refCount = 1; p->ER->loc = p->CL; p->ER->msg = rde_stack_new (NULL); ASSERT_BOUNDS(s,p->numstr); |
︙ | |||
949 950 951 952 953 954 955 | 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 | - + | NC_STATE* scs; Tcl_HashEntry* hPtr; Tcl_HashTable* tablePtr; hPtr = Tcl_FindHashEntry (&p->NC, (char*) p->CL); if (!hPtr) { return 0; } tablePtr = (Tcl_HashTable*) Tcl_GetHashValue (hPtr); |
︙ | |||
974 975 976 977 978 979 980 | 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 | - + - + | Tcl_HashEntry* hPtr; Tcl_HashTable* tablePtr; int isnew; ENTER ("rde_param_i_symbol_save"); TRACE (("RDE_PARAM %p",p)); TRACE (("INT %d",s)); |
︙ | |||
1132 1133 1134 1135 1136 1137 1138 | 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 | - + + + - + | UniCharIsAscii (int character) { return (character >= 0) && (character < 0x80); } static int UniCharIsHexDigit (int character) { |
︙ |
Changes to modules/pt/tests/data/ok/peg_cparam-tea/4_choice.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 | + | /************************************************************ ** ** TEA-based C/PARAM implementation of the parsing ** expression grammar ** ** TEMPLATE ** ** Generated from file TEST ** for user unknown ** * * ** *** ***** ******** ************* *********************/ #include <string.h> #include <tcl.h> #include <stdint.h> #include <stdlib.h> #include <ctype.h> #define SCOPE static #line 1 "rde_critcl/util.h" #ifndef _RDE_UTIL_H |
︙ | |||
695 696 697 698 699 700 701 | 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 | - + - + | rde_stack_get (p->ES, ec, (void***) ev); } SCOPE void rde_param_query_ls (RDE_PARAM p, long int* lc, void*** lv) { rde_stack_get (p->LS, lc, lv); } |
︙ | |||
859 860 861 862 863 864 865 | 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 | - + | { error_state_free (p->ER); p->ER = ALLOC (ERROR_STATE); p->ER->refCount = 1; p->ER->loc = p->CL; p->ER->msg = rde_stack_new (NULL); ASSERT_BOUNDS(s,p->numstr); |
︙ | |||
949 950 951 952 953 954 955 | 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 | - + | NC_STATE* scs; Tcl_HashEntry* hPtr; Tcl_HashTable* tablePtr; hPtr = Tcl_FindHashEntry (&p->NC, (char*) p->CL); if (!hPtr) { return 0; } tablePtr = (Tcl_HashTable*) Tcl_GetHashValue (hPtr); |
︙ | |||
974 975 976 977 978 979 980 | 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 | - + - + | Tcl_HashEntry* hPtr; Tcl_HashTable* tablePtr; int isnew; ENTER ("rde_param_i_symbol_save"); TRACE (("RDE_PARAM %p",p)); TRACE (("INT %d",s)); |
︙ | |||
1132 1133 1134 1135 1136 1137 1138 | 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 | - + + + - + | UniCharIsAscii (int character) { return (character >= 0) && (character < 0x80); } static int UniCharIsHexDigit (int character) { |
︙ |
Changes to modules/pt/tests/data/ok/peg_cparam-tea/5_sequence.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 | + | /************************************************************ ** ** TEA-based C/PARAM implementation of the parsing ** expression grammar ** ** TEMPLATE ** ** Generated from file TEST ** for user unknown ** * * ** *** ***** ******** ************* *********************/ #include <string.h> #include <tcl.h> #include <stdint.h> #include <stdlib.h> #include <ctype.h> #define SCOPE static #line 1 "rde_critcl/util.h" #ifndef _RDE_UTIL_H |
︙ | |||
695 696 697 698 699 700 701 | 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 | - + - + | rde_stack_get (p->ES, ec, (void***) ev); } SCOPE void rde_param_query_ls (RDE_PARAM p, long int* lc, void*** lv) { rde_stack_get (p->LS, lc, lv); } |
︙ | |||
859 860 861 862 863 864 865 | 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 | - + | { error_state_free (p->ER); p->ER = ALLOC (ERROR_STATE); p->ER->refCount = 1; p->ER->loc = p->CL; p->ER->msg = rde_stack_new (NULL); ASSERT_BOUNDS(s,p->numstr); |
︙ | |||
949 950 951 952 953 954 955 | 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 | - + | NC_STATE* scs; Tcl_HashEntry* hPtr; Tcl_HashTable* tablePtr; hPtr = Tcl_FindHashEntry (&p->NC, (char*) p->CL); if (!hPtr) { return 0; } tablePtr = (Tcl_HashTable*) Tcl_GetHashValue (hPtr); |
︙ | |||
974 975 976 977 978 979 980 | 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 | - + - + | Tcl_HashEntry* hPtr; Tcl_HashTable* tablePtr; int isnew; ENTER ("rde_param_i_symbol_save"); TRACE (("RDE_PARAM %p",p)); TRACE (("INT %d",s)); |
︙ | |||
1132 1133 1134 1135 1136 1137 1138 | 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 | - + + + - + | UniCharIsAscii (int character) { return (character >= 0) && (character < 0x80); } static int UniCharIsHexDigit (int character) { |
︙ |
Changes to modules/pt/tests/data/ok/peg_cparam-tea/6_optional.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 | + | /************************************************************ ** ** TEA-based C/PARAM implementation of the parsing ** expression grammar ** ** TEMPLATE ** ** Generated from file TEST ** for user unknown ** * * ** *** ***** ******** ************* *********************/ #include <string.h> #include <tcl.h> #include <stdint.h> #include <stdlib.h> #include <ctype.h> #define SCOPE static #line 1 "rde_critcl/util.h" #ifndef _RDE_UTIL_H |
︙ | |||
695 696 697 698 699 700 701 | 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 | - + - + | rde_stack_get (p->ES, ec, (void***) ev); } SCOPE void rde_param_query_ls (RDE_PARAM p, long int* lc, void*** lv) { rde_stack_get (p->LS, lc, lv); } |
︙ | |||
859 860 861 862 863 864 865 | 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 | - + | { error_state_free (p->ER); p->ER = ALLOC (ERROR_STATE); p->ER->refCount = 1; p->ER->loc = p->CL; p->ER->msg = rde_stack_new (NULL); ASSERT_BOUNDS(s,p->numstr); |
︙ | |||
949 950 951 952 953 954 955 | 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 | - + | NC_STATE* scs; Tcl_HashEntry* hPtr; Tcl_HashTable* tablePtr; hPtr = Tcl_FindHashEntry (&p->NC, (char*) p->CL); if (!hPtr) { return 0; } tablePtr = (Tcl_HashTable*) Tcl_GetHashValue (hPtr); |
︙ | |||
974 975 976 977 978 979 980 | 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 | - + - + | Tcl_HashEntry* hPtr; Tcl_HashTable* tablePtr; int isnew; ENTER ("rde_param_i_symbol_save"); TRACE (("RDE_PARAM %p",p)); TRACE (("INT %d",s)); |
︙ | |||
1132 1133 1134 1135 1136 1137 1138 | 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 | - + + + - + | UniCharIsAscii (int character) { return (character >= 0) && (character < 0x80); } static int UniCharIsHexDigit (int character) { |
︙ |
Changes to modules/pt/tests/data/ok/peg_cparam-tea/7_kleene.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 | + | /************************************************************ ** ** TEA-based C/PARAM implementation of the parsing ** expression grammar ** ** TEMPLATE ** ** Generated from file TEST ** for user unknown ** * * ** *** ***** ******** ************* *********************/ #include <string.h> #include <tcl.h> #include <stdint.h> #include <stdlib.h> #include <ctype.h> #define SCOPE static #line 1 "rde_critcl/util.h" #ifndef _RDE_UTIL_H |
︙ | |||
695 696 697 698 699 700 701 | 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 | - + - + | rde_stack_get (p->ES, ec, (void***) ev); } SCOPE void rde_param_query_ls (RDE_PARAM p, long int* lc, void*** lv) { rde_stack_get (p->LS, lc, lv); } |
︙ | |||
859 860 861 862 863 864 865 | 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 | - + | { error_state_free (p->ER); p->ER = ALLOC (ERROR_STATE); p->ER->refCount = 1; p->ER->loc = p->CL; p->ER->msg = rde_stack_new (NULL); ASSERT_BOUNDS(s,p->numstr); |
︙ | |||
949 950 951 952 953 954 955 | 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 | - + | NC_STATE* scs; Tcl_HashEntry* hPtr; Tcl_HashTable* tablePtr; hPtr = Tcl_FindHashEntry (&p->NC, (char*) p->CL); if (!hPtr) { return 0; } tablePtr = (Tcl_HashTable*) Tcl_GetHashValue (hPtr); |
︙ | |||
974 975 976 977 978 979 980 | 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 | - + - + | Tcl_HashEntry* hPtr; Tcl_HashTable* tablePtr; int isnew; ENTER ("rde_param_i_symbol_save"); TRACE (("RDE_PARAM %p",p)); TRACE (("INT %d",s)); |
︙ | |||
1132 1133 1134 1135 1136 1137 1138 | 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 | - + + + - + | UniCharIsAscii (int character) { return (character >= 0) && (character < 0x80); } static int UniCharIsHexDigit (int character) { |
︙ |
Changes to modules/pt/tests/data/ok/peg_cparam-tea/8_pkleene.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 | + | /************************************************************ ** ** TEA-based C/PARAM implementation of the parsing ** expression grammar ** ** TEMPLATE ** ** Generated from file TEST ** for user unknown ** * * ** *** ***** ******** ************* *********************/ #include <string.h> #include <tcl.h> #include <stdint.h> #include <stdlib.h> #include <ctype.h> #define SCOPE static #line 1 "rde_critcl/util.h" #ifndef _RDE_UTIL_H |
︙ | |||
695 696 697 698 699 700 701 | 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 | - + - + | rde_stack_get (p->ES, ec, (void***) ev); } SCOPE void rde_param_query_ls (RDE_PARAM p, long int* lc, void*** lv) { rde_stack_get (p->LS, lc, lv); } |
︙ | |||
859 860 861 862 863 864 865 | 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 | - + | { error_state_free (p->ER); p->ER = ALLOC (ERROR_STATE); p->ER->refCount = 1; p->ER->loc = p->CL; p->ER->msg = rde_stack_new (NULL); ASSERT_BOUNDS(s,p->numstr); |
︙ | |||
949 950 951 952 953 954 955 | 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 | - + | NC_STATE* scs; Tcl_HashEntry* hPtr; Tcl_HashTable* tablePtr; hPtr = Tcl_FindHashEntry (&p->NC, (char*) p->CL); if (!hPtr) { return 0; } tablePtr = (Tcl_HashTable*) Tcl_GetHashValue (hPtr); |
︙ | |||
974 975 976 977 978 979 980 | 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 | - + - + | Tcl_HashEntry* hPtr; Tcl_HashTable* tablePtr; int isnew; ENTER ("rde_param_i_symbol_save"); TRACE (("RDE_PARAM %p",p)); TRACE (("INT %d",s)); |
︙ | |||
1132 1133 1134 1135 1136 1137 1138 | 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 | - + + + - + | UniCharIsAscii (int character) { return (character >= 0) && (character < 0x80); } static int UniCharIsHexDigit (int character) { |
︙ |
Changes to modules/pt/tests/data/ok/peg_cparam-tea/9_ahead.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 | + | /************************************************************ ** ** TEA-based C/PARAM implementation of the parsing ** expression grammar ** ** TEMPLATE ** ** Generated from file TEST ** for user unknown ** * * ** *** ***** ******** ************* *********************/ #include <string.h> #include <tcl.h> #include <stdint.h> #include <stdlib.h> #include <ctype.h> #define SCOPE static #line 1 "rde_critcl/util.h" #ifndef _RDE_UTIL_H |
︙ | |||
695 696 697 698 699 700 701 | 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 | - + - + | rde_stack_get (p->ES, ec, (void***) ev); } SCOPE void rde_param_query_ls (RDE_PARAM p, long int* lc, void*** lv) { rde_stack_get (p->LS, lc, lv); } |
︙ | |||
859 860 861 862 863 864 865 | 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 | - + | { error_state_free (p->ER); p->ER = ALLOC (ERROR_STATE); p->ER->refCount = 1; p->ER->loc = p->CL; p->ER->msg = rde_stack_new (NULL); ASSERT_BOUNDS(s,p->numstr); |
︙ | |||
949 950 951 952 953 954 955 | 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 | - + | NC_STATE* scs; Tcl_HashEntry* hPtr; Tcl_HashTable* tablePtr; hPtr = Tcl_FindHashEntry (&p->NC, (char*) p->CL); if (!hPtr) { return 0; } tablePtr = (Tcl_HashTable*) Tcl_GetHashValue (hPtr); |
︙ | |||
974 975 976 977 978 979 980 | 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 | - + - + | Tcl_HashEntry* hPtr; Tcl_HashTable* tablePtr; int isnew; ENTER ("rde_param_i_symbol_save"); TRACE (("RDE_PARAM %p",p)); TRACE (("INT %d",s)); |
︙ | |||
1132 1133 1134 1135 1136 1137 1138 | 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 | - + + + - + | UniCharIsAscii (int character) { return (character >= 0) && (character < 0x80); } static int UniCharIsHexDigit (int character) { |
︙ |
Changes to modules/rc4/rc4c.tcl.
︙ | |||
16 17 18 19 20 21 22 23 24 25 26 27 28 29 | 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 | + + | package require critcl # @sak notprovided rc4c package provide rc4c 1.1.0 namespace eval ::rc4 { critcl::ccode { #include <string.h> #include <string.h> typedef struct RC4_CTX { unsigned char x; unsigned char y; unsigned char s[256]; } RC4_CTX; |
︙ |
Changes to modules/sha1/sha1c.tcl.
︙ | |||
28 29 30 31 32 33 34 | 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 | - + - | static Tcl_ObjType sha1_type; /* fast internal access representation */ static void sha1_free_rep(Tcl_Obj* obj) { |
︙ |
Changes to modules/struct/graph/arc.c.
1 2 3 4 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 | - - - - + + + + + | /* struct::tree - critcl - layer 1 declarations * (b) Arc operations. */ |
︙ |
Changes to modules/struct/graph/attr.c.
1 2 3 4 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 | - - + + + + | /* struct::graph - critcl - layer 1 definitions * (c) Graph functions */ |
︙ |
Changes to modules/struct/graph/ds.h.
︙ | |||
156 157 158 159 160 161 162 | 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 | - + | } G; /* * 'Global' management. One structure per interpreter. */ typedef struct GG { |
︙ |
Changes to modules/struct/graph/filter.c.
1 2 3 4 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 | - - - + + + + | /* struct::graph - critcl - layer 1 definitions * (c) Graph functions */ |
︙ | |||
249 250 251 252 253 254 255 | 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 | - - - - - - - + + + + + + | l.v = NALLOC (gx->n, Tcl_Obj*); if (!na->key && !na->filter && (na->mode == NA_NONE)) { filter_none (interp, gx, &l); } else { |
︙ | |||
320 321 322 323 324 325 326 327 328 329 330 331 332 333 | 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 | + | switch (mode) { case NA_ADJ: filter_mode_a_adj (gx, l, nc, nv, g); break; case NA_EMBEDDING: filter_mode_a_emb (gx, l, nc, nv, g); break; case NA_IN: filter_mode_a_in (gx, l, nc, nv, g); break; case NA_INNER: filter_mode_a_inn (gx, l, nc, nv, g); break; case NA_OUT: filter_mode_a_out (gx, l, nc, nv, g); break; case NA_NONE: /* nothing */; } } /* .................................................. */ static void filter_mode_a_adj (GCC* gx, NARES* l, int nc, Tcl_Obj* const* nv, G* g) |
︙ | |||
580 581 582 583 584 585 586 587 588 589 590 591 592 593 | 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 | + | switch (mode) { case NA_ADJ: filter_mode_n_adj (gx, l, nc, nv, g); break; case NA_EMBEDDING: filter_mode_n_emb (gx, l, nc, nv, g); break; case NA_IN: filter_mode_n_in (gx, l, nc, nv, g); break; case NA_INNER: filter_mode_n_inn (gx, l, nc, nv, g); break; case NA_OUT: filter_mode_n_out (gx, l, nc, nv, g); break; case NA_NONE: /* nothing */; } } /* .................................................. */ static void filter_mode_n_adj (GCC* gx, NARES* l, int nc, Tcl_Obj* const* nv, G* g) |
︙ |
Changes to modules/struct/graph/global.c.
︙ | |||
20 21 22 23 24 25 26 | 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 | - + | gg = ALLOC (GG); gg->counter = 0; Tcl_SetAssocData (interp, KEY, proc, (ClientData) gg); } gg->counter ++; |
︙ |
Changes to modules/struct/graph/graph.c.
1 2 3 4 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 | - - - - - - + + + + + + + | /* struct::graph - critcl - layer 1 definitions * (c) Graph functions */ |
︙ | |||
155 156 157 158 159 160 161 | 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 | - + - + - + - + | j = 0; for (i=0; i < oc; i++) { ASSERT_BOUNDS(i, oc); n = gn_get_node (g, ov[i], interp, go); if (!n) { goto abort; } |
︙ |
Changes to modules/struct/graph/methods.c.
1 2 3 4 5 6 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 | - - - - - - - - + + + + + + + + + + | /* struct::tree - critcl - layer 3 definitions. * * -> Method functions. * Implementations for all tree methods. */ |
︙ |
Changes to modules/struct/graph/methods.h.
︙ | |||
26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 | 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 | + + + + + | int gm_UNSET (G* g, Tcl_Interp* interp, int objc, Tcl_Obj* const* objv); int gm_WALK (G* g, Tcl_Interp* interp, int objc, Tcl_Obj* const* objv); int gm_arc_APPEND (G* g, Tcl_Interp* interp, int objc, Tcl_Obj* const* objv); int gm_arc_ATTR (G* g, Tcl_Interp* interp, int objc, Tcl_Obj* const* objv); int gm_arc_DELETE (G* g, Tcl_Interp* interp, int objc, Tcl_Obj* const* objv); int gm_arc_EXISTS (G* g, Tcl_Interp* interp, int objc, Tcl_Obj* const* objv); int gm_arc_FLIP (G* g, Tcl_Interp* interp, int objc, Tcl_Obj* const* objv); int gm_arc_GET (G* g, Tcl_Interp* interp, int objc, Tcl_Obj* const* objv); int gm_arc_GETALL (G* g, Tcl_Interp* interp, int objc, Tcl_Obj* const* objv); int gm_arc_GETUNWEIGH (G* g, Tcl_Interp* interp, int objc, Tcl_Obj* const* objv); int gm_arc_GETWEIGHT (G* g, Tcl_Interp* interp, int objc, Tcl_Obj* const* objv); int gm_arc_HASWEIGHT (G* g, Tcl_Interp* interp, int objc, Tcl_Obj* const* objv); int gm_arc_INSERT (G* g, Tcl_Interp* interp, int objc, Tcl_Obj* const* objv); int gm_arc_KEYEXISTS (G* g, Tcl_Interp* interp, int objc, Tcl_Obj* const* objv); int gm_arc_KEYS (G* g, Tcl_Interp* interp, int objc, Tcl_Obj* const* objv); int gm_arc_LAPPEND (G* g, Tcl_Interp* interp, int objc, Tcl_Obj* const* objv); int gm_arc_MOVE (G* g, Tcl_Interp* interp, int objc, Tcl_Obj* const* objv); int gm_arc_MOVE_SRC (G* g, Tcl_Interp* interp, int objc, Tcl_Obj* const* objv); int gm_arc_MOVE_TARG (G* g, Tcl_Interp* interp, int objc, Tcl_Obj* const* objv); int gm_arc_NODES (G* g, Tcl_Interp* interp, int objc, Tcl_Obj* const* objv); int gm_arc_RENAME (G* g, Tcl_Interp* interp, int objc, Tcl_Obj* const* objv); int gm_arc_SET (G* g, Tcl_Interp* interp, int objc, Tcl_Obj* const* objv); int gm_arc_SETUNWEIGH (G* g, Tcl_Interp* interp, int objc, Tcl_Obj* const* objv); int gm_arc_SETWEIGHT (G* g, Tcl_Interp* interp, int objc, Tcl_Obj* const* objv); int gm_arc_SOURCE (G* g, Tcl_Interp* interp, int objc, Tcl_Obj* const* objv); int gm_arc_TARGET (G* g, Tcl_Interp* interp, int objc, Tcl_Obj* const* objv); int gm_arc_UNSET (G* g, Tcl_Interp* interp, int objc, Tcl_Obj* const* objv); |
︙ |
Changes to modules/struct/graph/nacommon.c.
1 2 3 4 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 | - - - + + + + | /* struct::graph - critcl - layer 1 definitions * (c) Graph functions */ |
︙ |
Changes to modules/struct/graph/node.c.
1 2 3 4 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 | + - - - + + + | /* struct::graph - critcl - layer 1 declarations * (b) Node operations. */ #include "nacommon.h" |
︙ |
Changes to modules/struct/graph/objcmd.c.
︙ | |||
36 37 38 39 40 41 42 | 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 | - + - + - + - + - + | NULL }; enum methods { M_GSET, M_GASSIGN, M_APPEND, M_ARC, M_ARCS, M_DESERIALIZE, M_DESTROY, M_GET, M_GETALL, M_KEYEXISTS, M_KEYS, M_LAPPEND, M_NODE, M_NODES, M_SERIALIZE, M_SET, M_SWAP, M_UNSET, M_WALK |
︙ | |||
137 138 139 140 141 142 143 | 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 | - + | if (objc < 3) { Tcl_WrongNumArgs (interp, objc, objv, "option ?arg arg ...?"); return TCL_ERROR; } else if (Tcl_GetIndexFromObj (interp, objv [2], n_methods, "option", 0, &m) != TCL_OK) { return TCL_ERROR; } |
︙ |
Changes to modules/struct/graph/util.c.
︙ | |||
73 74 75 76 77 78 79 | 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 | - + | ckfree ((char*) qi); return n; } /* Delete all items in the list. */ |
︙ |
Changes to modules/struct/graph/util.h.
︙ | |||
49 50 51 52 53 54 55 | 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 | - + | NLptr end; } NLQ; void g_nlq_init (NLQ* q); void g_nlq_append (NLQ* q, void* n); void g_nlq_push (NLQ* q, void* n); void* g_nlq_pop (NLQ* q); |
︙ |
Changes to modules/struct/graph/walk.c.
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 | - - - - - + + + + + - + |
|
︙ | |||
283 284 285 286 287 288 289 | 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 | - + | Tcl_DecrRefCount (ev [cc+2]); return res; } /* .................................................. */ |
︙ |
Changes to modules/struct/queue/ms.c.
︙ | |||
37 38 39 40 41 42 43 | 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 | - + - + | "unget", NULL }; enum methods { M_CLEAR, M_DESTROY, M_GET, M_PEEK, M_PUT, M_SIZE, M_UNGET |
︙ |
Changes to modules/struct/queue_c.tcl.
︙ | |||
31 32 33 34 35 36 37 | 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 | - + | #include <m.h> /* .................................................. */ /* Global queue management, per interp */ typedef struct QDg { |
︙ | |||
59 60 61 62 63 64 65 | 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 | - + | qdg->counter = 0; Tcl_SetAssocData (interp, KEY, proc, (ClientData) qdg); } qdg->counter ++; |
︙ |
Changes to modules/struct/sets/m.c.
︙ | |||
76 77 78 79 80 81 82 | 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 | - + | if (Tcl_IsShared (val)) { val = Tcl_DuplicateObj (val); (void) Tcl_ObjSetVar2 (interp, objv[2], NULL, val, 0); s_get (interp, val, &vs); } |
︙ |
Changes to modules/struct/sets/s.c.
︙ | |||
289 290 291 292 293 294 295 | 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 | - + | he != NULL; he = Tcl_NextHashEntry(&hs)) { key = Tcl_GetHashKey (&a->el, he); if (Tcl_FindHashEntry (&b->el, key) != NULL) continue; /* key is in a, not in b <=> in (a-b) */ |
︙ | |||
325 326 327 328 329 330 331 | 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 | - + | he != NULL; he = Tcl_NextHashEntry(&hs)) { key = Tcl_GetHashKey (&a->el, he); if (Tcl_FindHashEntry (&b->el, key) == NULL) continue; /* key is in a, in b <=> in (a*b) */ |
︙ | |||
361 362 363 364 365 366 367 | 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 | - + - + | CONST char* key; if (b->el.numEntries) { for(he = Tcl_FirstHashEntry(&b->el, &hs); he != NULL; he = Tcl_NextHashEntry(&hs)) { key = Tcl_GetHashKey (&b->el, he); |
︙ |
Changes to modules/struct/sets_c.tcl.
︙ | |||
49 50 51 52 53 54 55 | 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 | - + - + | NULL }; enum methods { S_add, S_contains, S_difference, S_empty, S_equal,S_exclude, S_include, S_intersect, S_intersect3, S_size, S_subsetof, S_subtract, S_symdiff, S_union |
︙ |
Changes to modules/struct/stack/ms.c.
︙ | |||
35 36 37 38 39 40 41 | 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 | - + - + | "clear", "destroy", "get", "getr", "peek", "peekr", "pop", "push", "rotate", "size", "trim", "trim*", NULL }; enum methods { M_CLEAR, M_DESTROY, M_GET, M_GETR, M_PEEK, M_PEEKR, M_POP, M_PUSH, M_ROTATE, M_SIZE, M_TRIM, M_TRIMV |
︙ |
Changes to modules/struct/stack_c.tcl.
︙ | |||
36 37 38 39 40 41 42 | 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 | - + | #include <m.h> /* .................................................. */ /* Global stack management, per interp */ typedef struct SDg { |
︙ | |||
64 65 66 67 68 69 70 | 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 | - + | sdg->counter = 0; Tcl_SetAssocData (interp, KEY, proc, (ClientData) sdg); } sdg->counter ++; |
︙ |
Changes to modules/struct/tree/m.c.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 | + + + + | /* struct::tree - critcl - layer 3 definitions. * * -> Method functions. * Implementations for all tree methods. */ #include <ctype.h> #include <stdint.h> #include <string.h> #include "util.h" #include "m.h" #include "t.h" #include "tn.h" #include "ms.h" /* .................................................. * Handling of all indices, numeric and 'end-x' forms. Copied straight out of * the Tcl core as this is not exported through the public API. */ static int TclGetIntForIndex (Tcl_Interp* interp, Tcl_Obj* objPtr, int endValue, int* indexPtr); static int TclCheckBadOctal (Tcl_Interp *interp, const char *value); static int TclFormatInt (char *buffer, long n); /* .................................................. */ /* *--------------------------------------------------------------------------- * * tm_TASSIGN -- |
︙ | |||
2541 2542 2543 2544 2545 2546 2547 | 2545 2546 2547 2548 2549 2550 2551 2552 2553 2554 2555 2556 2557 2558 2559 | - + | for (i = 0; i < cc; i++) { ev [i] = cv [i]; Tcl_IncrRefCount (ev [i]); } res = t_walk (interp, tn, type, order, t_walk_invokecmd, |
︙ |
Changes to modules/struct/tree/ms.c.
︙ | |||
308 309 310 311 312 313 314 | 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 | - + - + | M_CHILDREN, M_CUT, M_DELETE, M_DEPTH, M_DESCENDANTS, M_DESERIALIZE, M_DESTROY, M_EXISTS, M_GET, M_GETALL, M_HEIGHT, M_INDEX, M_INSERT, M_ISLEAF, M_KEYEXISTS, M_KEYS, M_LAPPEND, M_LEAVES, M_MOVE, M_NEXT, M_NODES, M_NUMCHILDREN, M_PARENT, M_PREVIOUS, M_RENAME, M_ROOTNAME, M_SERIALIZE, M_SET, M_SIZE, M_SPLICE, M_SWAP, M_UNSET, M_WALK, M_WALKPROC |
︙ |
Changes to modules/struct/tree/t.c.
1 2 3 4 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 | - - - + + + + | /* struct::tree - critcl - layer 1 definitions * (c) Tree functions */ |
︙ |
Changes to modules/struct/tree/tn.c.
1 2 3 4 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 | - - + + + | /* struct::tree - critcl - layer 1 declarations * (b) Node operations. */ |
︙ |
Changes to modules/struct/tree/util.c.
︙ | |||
73 74 75 76 77 78 79 | 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 | - + | ckfree ((char*) qi); return n; } /* Delete all items in the list. */ |
︙ |
Changes to modules/struct/tree/util.h.
︙ | |||
48 49 50 51 52 53 54 | 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 | - + | NLptr end; } NLQ; void nlq_init (NLQ* q); void nlq_append (NLQ* q, void* n); void nlq_push (NLQ* q, void* n); void* nlq_pop (NLQ* q); |
︙ |
Changes to modules/struct/tree/walk.c.
1 2 | 1 2 3 4 5 6 7 8 9 10 11 12 13 | + - - - + + + | #include <stdint.h> #include <string.h> |
︙ | |||
233 234 235 236 237 238 239 | 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 | - + | int t_walk_invokecmd (Tcl_Interp* interp, TN* n, Tcl_Obj* dummy0, Tcl_Obj* dummy1, Tcl_Obj* dummy2, Tcl_Obj* action) { int res; |
︙ |
Changes to modules/struct/tree_c.tcl.
︙ | |||
37 38 39 40 41 42 43 | 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 | - + | #include <m.h> /* .................................................. */ /* Global tree management, per interp */ typedef struct TDg { |
︙ | |||
65 66 67 68 69 70 71 | 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 | - + | tdg->counter = 0; Tcl_SetAssocData (interp, KEY, proc, (ClientData) tdg); } tdg->counter ++; |
︙ |