Adwaith-Rajesh/gperf
1
0
Fork 0
mirror of https://git.savannah.gnu.org/git/gperf.git synced 2025-12-02 13:09:22 +00:00
Code Activity

Completely new asso_values search algorithm.

Browse Source
This commit is contained in:
Bruno Haible
2003-03-18 10:22:37 +00:00
parent 40f37680ac
commit 6d268d095b
20 changed files with 1918 additions and 2117 deletions
Download Patch File Download Diff File Expand all files Collapse all files

230
tests/c-parse.exp
View File

@@ -7,9 +7,9 @@ struct resword { const char *name; short token; enum rid rid; };
#define TOTAL_KEYWORDS 83
#define MIN_WORD_LENGTH 2
#define MAX_WORD_LENGTH 20
#define MIN_HASH_VALUE 8
#define MAX_HASH_VALUE 141
/* maximum key range = 134, duplicates = 0 */
#define MIN_HASH_VALUE 12
#define MAX_HASH_VALUE 125
/* maximum key range = 114, duplicates = 0 */
#ifdef __GNUC__
__inline
@@ -25,32 +25,32 @@ hash (str, len)
{
static unsigned char asso_values[] =
{
142, 142, 142, 142, 142, 142, 142, 142, 142, 142,
142, 142, 142, 142, 142, 142, 142, 142, 142, 142,
142, 142, 142, 142, 142, 142, 142, 142, 142, 142,
142, 142, 142, 142, 142, 142, 142, 142, 142, 142,
142, 142, 142, 142, 142, 142, 142, 142, 142, 142,
142, 142, 142, 142, 142, 142, 142, 142, 142, 142,
142, 142, 142, 142, 35, 142, 142, 142, 142, 142,
142, 142, 142, 142, 142, 142, 142, 142, 142, 142,
142, 142, 142, 142, 142, 142, 142, 142, 142, 142,
142, 142, 142, 142, 142, 1, 142, 90, 1, 28,
40, 6, 1, 24, 3, 13, 142, 36, 60, 14,
49, 3, 6, 142, 19, 8, 1, 50, 33, 11,
2, 23, 4, 142, 142, 142, 142, 142, 142, 142,
142, 142, 142, 142, 142, 142, 142, 142, 142, 142,
142, 142, 142, 142, 142, 142, 142, 142, 142, 142,
142, 142, 142, 142, 142, 142, 142, 142, 142, 142,
142, 142, 142, 142, 142, 142, 142, 142, 142, 142,
142, 142, 142, 142, 142, 142, 142, 142, 142, 142,
142, 142, 142, 142, 142, 142, 142, 142, 142, 142,
142, 142, 142, 142, 142, 142, 142, 142, 142, 142,
142, 142, 142, 142, 142, 142, 142, 142, 142, 142,
142, 142, 142, 142, 142, 142, 142, 142, 142, 142,
142, 142, 142, 142, 142, 142, 142, 142, 142, 142,
142, 142, 142, 142, 142, 142, 142, 142, 142, 142,
142, 142, 142, 142, 142, 142, 142, 142, 142, 142,
142, 142, 142, 142, 142, 142
126, 126, 126, 126, 126, 126, 126, 126, 126, 126,
126, 126, 126, 126, 126, 126, 126, 126, 126, 126,
126, 126, 126, 126, 126, 126, 126, 126, 126, 126,
126, 126, 126, 126, 126, 126, 126, 126, 126, 126,
126, 126, 126, 126, 126, 126, 126, 126, 126, 126,
126, 126, 126, 126, 126, 126, 126, 126, 126, 126,
126, 126, 126, 126, 19, 126, 126, 126, 126, 126,
126, 126, 126, 126, 126, 126, 126, 126, 126, 126,
126, 126, 126, 126, 126, 126, 126, 126, 126, 126,
126, 126, 126, 126, 126, 1, 126, 12, 50, 17,
22, 18, 51, 37, 5, 10, 126, 15, 35, 49,
27, 40, 28, 126, 2, 20, 1, 33, 64, 7,
11, 4, 7, 126, 126, 126, 126, 126, 126, 126,
126, 126, 126, 126, 126, 126, 126, 126, 126, 126,
126, 126, 126, 126, 126, 126, 126, 126, 126, 126,
126, 126, 126, 126, 126, 126, 126, 126, 126, 126,
126, 126, 126, 126, 126, 126, 126, 126, 126, 126,
126, 126, 126, 126, 126, 126, 126, 126, 126, 126,
126, 126, 126, 126, 126, 126, 126, 126, 126, 126,
126, 126, 126, 126, 126, 126, 126, 126, 126, 126,
126, 126, 126, 126, 126, 126, 126, 126, 126, 126,
126, 126, 126, 126, 126, 126, 126, 126, 126, 126,
126, 126, 126, 126, 126, 126, 126, 126, 126, 126,
126, 126, 126, 126, 126, 126, 126, 126, 126, 126,
126, 126, 126, 126, 126, 126, 126, 126, 126, 126,
126, 126, 126, 126, 126, 126
};
register int hval = len;
@@ -71,112 +71,102 @@ static struct resword wordlist[] =
{
{"", 0, 0}, {"", 0, 0}, {"", 0, 0}, {"", 0, 0},
{"", 0, 0}, {"", 0, 0}, {"", 0, 0}, {"", 0, 0},
{"out", TYPE_QUAL, RID_OUT},
{"", 0, 0},
{"float", TYPESPEC, RID_FLOAT},
{"__typeof", TYPEOF, NORID},
{"", 0, 0},
{"", 0, 0}, {"", 0, 0}, {"", 0, 0}, {"", 0, 0},
{"__real__", REALPART, NORID},
{"__typeof__", TYPEOF, NORID},
{"typeof", TYPEOF, NORID},
{"typedef", SCSPEC, RID_TYPEDEF},
{"if", IF, NORID},
{"short", TYPESPEC, RID_SHORT},
{"__restrict", TYPE_QUAL, RID_RESTRICT},
{"int", TYPESPEC, RID_INT},
{"sizeof", SIZEOF, NORID},
{"__restrict__", TYPE_QUAL, RID_RESTRICT},
{"", 0, 0}, {"", 0, 0}, {"", 0, 0},
{"__imag__", IMAGPART, NORID},
{"__asm__", ASM_KEYWORD, NORID},
{"__inline__", SCSPEC, RID_INLINE},
{"__iterator", SCSPEC, RID_ITERATOR},
{"__iterator__", SCSPEC, RID_ITERATOR},
{"__alignof__", ALIGNOF, NORID},
{"__const", TYPE_QUAL, RID_CONST},
{"__attribute__", ATTRIBUTE, NORID},
{"__const__", TYPE_QUAL, RID_CONST},
{"struct", STRUCT, NORID},
{"__complex__", TYPESPEC, RID_COMPLEX},
{"restrict", TYPE_QUAL, RID_RESTRICT},
{"__signed__", TYPESPEC, RID_SIGNED},
{"__extension__", EXTENSION, NORID},
{"inout", TYPE_QUAL, RID_INOUT},
{"__imag__", IMAGPART, NORID},
{"else", ELSE, NORID},
{"__inline__", SCSPEC, RID_INLINE},
{"byref", TYPE_QUAL, RID_BYREF},
{"__iterator__", SCSPEC, RID_ITERATOR},
{"__inline", SCSPEC, RID_INLINE},
{"__real__", REALPART, NORID},
{"switch", SWITCH, NORID},
{"__restrict", TYPE_QUAL, RID_RESTRICT},
{"goto", GOTO, NORID},
{"__restrict__", TYPE_QUAL, RID_RESTRICT},
{"struct", STRUCT, NORID},
{"while", WHILE, NORID},
{"restrict", TYPE_QUAL, RID_RESTRICT},
{"__const", TYPE_QUAL, RID_CONST},
{"oneway", TYPE_QUAL, RID_ONEWAY},
{"__const__", TYPE_QUAL, RID_CONST},
{"__complex", TYPESPEC, RID_COMPLEX},
{"__complex__", TYPESPEC, RID_COMPLEX},
{"for", FOR, NORID},
{"__iterator", SCSPEC, RID_ITERATOR},
{"__imag", IMAGPART, NORID},
{"do", DO, NORID},
{"case", CASE, NORID},
{"__volatile__", TYPE_QUAL, RID_VOLATILE},
{"break", BREAK, NORID},
{"default", DEFAULT, NORID},
{"__volatile", TYPE_QUAL, RID_VOLATILE},
{"", 0, 0}, {"", 0, 0}, {"", 0, 0},
{"@defs", DEFS, NORID},
{"id", OBJECTNAME, RID_ID},
{"", 0, 0},
{"__signed", TYPESPEC, RID_SIGNED},
{"bycopy", TYPE_QUAL, RID_BYCOPY},
{"", 0, 0}, {"", 0, 0}, {"", 0, 0},
{"extern", SCSPEC, RID_EXTERN},
{"", 0, 0},
{"char", TYPESPEC, RID_CHAR},
{"return", RETURN, NORID},
{"__inline", SCSPEC, RID_INLINE},
{"__complex", TYPESPEC, RID_COMPLEX},
{"in", TYPE_QUAL, RID_IN},
{"while", WHILE, NORID},
{"switch", SWITCH, NORID},
{"__attribute", ATTRIBUTE, NORID},
{"", 0, 0},
{"@compatibility_alias", ALIAS, NORID},
{"", 0, 0},
{"__real", REALPART, NORID},
{"out", TYPE_QUAL, RID_OUT},
{"__label__", LABEL, NORID},
{"@private", PRIVATE, NORID},
{"@selector", SELECTOR, NORID},
{"register", SCSPEC, RID_REGISTER},
{"__label__", LABEL, NORID},
{"", 0, 0}, {"", 0, 0},
{"enum", ENUM, NORID},
{"return", RETURN, NORID},
{"", 0, 0}, {"", 0, 0},
{"signed", TYPESPEC, RID_SIGNED},
{"", 0, 0}, {"", 0, 0}, {"", 0, 0}, {"", 0, 0},
{"const", TYPE_QUAL, RID_CONST},
{"", 0, 0},
{"inline", SCSPEC, RID_INLINE},
{"__real", REALPART, NORID},
{"", 0, 0}, {"", 0, 0}, {"", 0, 0},
{"void", TYPESPEC, RID_VOID},
{"continue", CONTINUE, NORID},
{"", 0, 0}, {"", 0, 0}, {"", 0, 0}, {"", 0, 0},
{"", 0, 0},
{"@encode", ENCODE, NORID},
{"auto", SCSPEC, RID_AUTO},
{"__asm__", ASM_KEYWORD, NORID},
{"@interface", INTERFACE, NORID},
{"__alignof", ALIGNOF, NORID},
{"double", TYPESPEC, RID_DOUBLE},
{"__alignof__", ALIGNOF, NORID},
{"__signed", TYPESPEC, RID_SIGNED},
{"extern", SCSPEC, RID_EXTERN},
{"@protected", PROTECTED, NORID},
{"__attribute__", ATTRIBUTE, NORID},
{"unsigned", TYPESPEC, RID_UNSIGNED},
{"volatile", TYPE_QUAL, RID_VOLATILE},
{"__attribute", ATTRIBUTE, NORID},
{"@class", CLASS, NORID},
{"__asm", ASM_KEYWORD, NORID},
{"", 0, 0}, {"", 0, 0},
{"@implementation", IMPLEMENTATION, NORID},
{"", 0, 0}, {"", 0, 0}, {"", 0, 0},
{"union", UNION, NORID},
{"", 0, 0}, {"", 0, 0},
{"@public", PUBLIC, NORID},
{"asm", ASM_KEYWORD, NORID},
{"", 0, 0},
{"@protocol", PROTOCOL, NORID},
{"", 0, 0}, {"", 0, 0}, {"", 0, 0}, {"", 0, 0},
{"@end", END, NORID},
{"", 0, 0}, {"", 0, 0}, {"", 0, 0},
{"__imag", IMAGPART, NORID},
{"static", SCSPEC, RID_STATIC},
{"inout", TYPE_QUAL, RID_INOUT},
{"auto", SCSPEC, RID_AUTO},
{"for", FOR, NORID},
{"case", CASE, NORID},
{"else", ELSE, NORID},
{"__typeof", TYPEOF, NORID},
{"@defs", DEFS, NORID},
{"if", IF, NORID},
{"do", DO, NORID},
{"@protocol", PROTOCOL, NORID},
{"short", TYPESPEC, RID_SHORT},
{"__asm", ASM_KEYWORD, NORID},
{"oneway", TYPE_QUAL, RID_ONEWAY},
{"inline", SCSPEC, RID_INLINE},
{"continue", CONTINUE, NORID},
{"@encode", ENCODE, NORID},
{"@end", END, NORID},
{"__alignof", ALIGNOF, NORID},
{"@interface", INTERFACE, NORID},
{"union", UNION, NORID},
{"@public", PUBLIC, NORID},
{"bycopy", TYPE_QUAL, RID_BYCOPY},
{"__volatile__", TYPE_QUAL, RID_VOLATILE},
{"double", TYPESPEC, RID_DOUBLE},
{"@class", CLASS, NORID},
{"default", DEFAULT, NORID},
{"goto", GOTO, NORID},
{"unsigned", TYPESPEC, RID_UNSIGNED},
{"sizeof", SIZEOF, NORID},
{"signed", TYPESPEC, RID_SIGNED},
{"typeof", TYPEOF, NORID},
{"typedef", SCSPEC, RID_TYPEDEF},
{"break", BREAK, NORID},
{"", 0, 0}, {"", 0, 0}, {"", 0, 0}, {"", 0, 0},
{"long", TYPESPEC, RID_LONG},
{"__volatile", TYPE_QUAL, RID_VOLATILE},
{"", 0, 0}, {"", 0, 0}, {"", 0, 0},
{"char", TYPESPEC, RID_CHAR}
{"float", TYPESPEC, RID_FLOAT},
{"", 0, 0},
{"@compatibility_alias", ALIAS, NORID},
{"void", TYPESPEC, RID_VOID},
{"", 0, 0}, {"", 0, 0},
{"long", TYPESPEC, RID_LONG},
{"enum", ENUM, NORID},
{"", 0, 0}, {"", 0, 0}, {"", 0, 0},
{"byref", TYPE_QUAL, RID_BYREF},
{"", 0, 0},
{"@implementation", IMPLEMENTATION, NORID},
{"", 0, 0}, {"", 0, 0},
{"asm", ASM_KEYWORD, NORID},
{"", 0, 0}, {"", 0, 0}, {"", 0, 0}, {"", 0, 0},
{"", 0, 0}, {"", 0, 0}, {"", 0, 0}, {"", 0, 0},
{"", 0, 0}, {"", 0, 0}, {"", 0, 0},
{"volatile", TYPE_QUAL, RID_VOLATILE}
};
#ifdef __GNUC__

1212
tests/chill.exp
View File

File diff suppressed because it is too large Load Diff

303
tests/cplusplus.exp
View File

@@ -8,8 +8,8 @@ struct resword { const char *name; short token; enum rid rid;};
#define MIN_WORD_LENGTH 2
#define MAX_WORD_LENGTH 16
#define MIN_HASH_VALUE 4
#define MAX_HASH_VALUE 250
/* maximum key range = 247, duplicates = 0 */
#define MAX_HASH_VALUE 163
/* maximum key range = 160, duplicates = 0 */
#ifdef __GNUC__
__inline
@@ -25,32 +25,32 @@ hash (str, len)
{
static unsigned char asso_values[] =
{
251, 251, 251, 251, 251, 251, 251, 251, 251, 251,
251, 251, 251, 251, 251, 251, 251, 251, 251, 251,
251, 251, 251, 251, 251, 251, 251, 251, 251, 251,
251, 251, 251, 251, 251, 251, 251, 251, 251, 251,
251, 251, 251, 251, 251, 251, 251, 251, 251, 251,
251, 251, 251, 251, 251, 251, 251, 251, 251, 251,
251, 251, 251, 251, 251, 251, 251, 251, 251, 251,
251, 251, 251, 251, 251, 251, 251, 251, 251, 251,
251, 251, 251, 251, 251, 251, 251, 251, 251, 251,
251, 251, 251, 251, 251, 0, 251, 64, 93, 3,
0, 0, 74, 35, 0, 26, 251, 2, 31, 65,
23, 76, 7, 19, 45, 37, 6, 64, 12, 38,
14, 4, 251, 251, 251, 251, 251, 251, 251, 251,
251, 251, 251, 251, 251, 251, 251, 251, 251, 251,
251, 251, 251, 251, 251, 251, 251, 251, 251, 251,
251, 251, 251, 251, 251, 251, 251, 251, 251, 251,
251, 251, 251, 251, 251, 251, 251, 251, 251, 251,
251, 251, 251, 251, 251, 251, 251, 251, 251, 251,
251, 251, 251, 251, 251, 251, 251, 251, 251, 251,
251, 251, 251, 251, 251, 251, 251, 251, 251, 251,
251, 251, 251, 251, 251, 251, 251, 251, 251, 251,
251, 251, 251, 251, 251, 251, 251, 251, 251, 251,
251, 251, 251, 251, 251, 251, 251, 251, 251, 251,
251, 251, 251, 251, 251, 251, 251, 251, 251, 251,
251, 251, 251, 251, 251, 251, 251, 251, 251, 251,
251, 251, 251, 251, 251, 251
164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
164, 164, 164, 164, 164, 0, 164, 44, 58, 15,
55, 0, 24, 23, 25, 2, 164, 4, 26, 75,
36, 11, 40, 74, 14, 23, 1, 45, 45, 90,
50, 50, 164, 164, 164, 164, 164, 164, 164, 164,
164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
164, 164, 164, 164, 164, 164, 164, 164, 164, 164,
164, 164, 164, 164, 164, 164
};
register int hval = len;
@@ -84,162 +84,141 @@ is_reserved_word (str, len)
{
{"", 0, 0}, {"", 0, 0}, {"", 0, 0}, {"", 0, 0},
{"else", ELSE, NORID,},
{"true", CXX_TRUE, NORID,},
{"int", TYPESPEC, RID_INT,},
{"", 0, 0},
{"delete", DELETE, NORID,},
{"case", CASE, NORID,},
{"__real__", REALPART, NORID},
{"", 0, 0},
{"true", CXX_TRUE, NORID,},
{"catch", CATCH, NORID,},
{"typeid", TYPEID, NORID,},
{"try", TRY, NORID,},
{"", 0, 0}, {"", 0, 0},
{"void", TYPESPEC, RID_VOID,},
{"", 0, 0}, {"", 0, 0}, {"", 0, 0}, {"", 0, 0},
{"", 0, 0}, {"", 0, 0}, {"", 0, 0}, {"", 0, 0},
{"inline", SCSPEC, RID_INLINE,},
{"", 0, 0},
{"private", VISSPEC, RID_PRIVATE,},
{"template", TEMPLATE, RID_TEMPLATE,},
{"protected", VISSPEC, RID_PROTECTED,},
{"extern", SCSPEC, RID_EXTERN,},
{"", 0, 0}, {"", 0, 0},
{"not", '!', NORID,},
{"", 0, 0},
{"__signed", TYPESPEC, RID_SIGNED},
{"int", TYPESPEC, RID_INT,},
{"__signed__", TYPESPEC, RID_SIGNED},
{"__real", REALPART, NORID},
{"", 0, 0},
{"xor_eq", ASSIGN, NORID,},
{"", 0, 0}, {"", 0, 0}, {"", 0, 0},
{"__attribute", ATTRIBUTE, NORID},
{"__asm__", ASM_KEYWORD, NORID},
{"", 0, 0},
{"__attribute__", ATTRIBUTE, NORID},
{"compl", '~', NORID,},
{"public", VISSPEC, RID_PUBLIC,},
{"not_eq", EQCOMPARE, NORID,},
{"switch", SWITCH, NORID,},
{"__extension__", EXTENSION, NORID},
{"", 0, 0},
{"export", SCSPEC, RID_EXPORT,},
{"case", CASE, NORID,},
{"__const", CV_QUALIFIER, RID_CONST},
{"__const__", CV_QUALIFIER, RID_CONST},
{"__volatile", CV_QUALIFIER, RID_VOLATILE},
{"", 0, 0},
{"__volatile__", CV_QUALIFIER, RID_VOLATILE},
{"__restrict", CV_QUALIFIER, RID_RESTRICT},
{"__restrict__", CV_QUALIFIER, RID_RESTRICT},
{"or", OROR, NORID,},
{"if", IF, NORID,},
{"", 0, 0},
{"__asm__", ASM_KEYWORD, NORID},
{"typeof", TYPEOF, NORID,},
{"__real", REALPART, NORID},
{"", 0, 0}, {"", 0, 0},
{"__sigof__", SIGOF, NORID /* Extension */,},
{"static_cast", STATIC_CAST, NORID,},
{"explicit", SCSPEC, RID_EXPLICIT,},
{"register", SCSPEC, RID_REGISTER,},
{"__wchar_t", TYPESPEC, RID_WCHAR /* Unique to ANSI C++ */,},
{"not", '!', NORID,},
{"for", FOR, NORID,},
{"extern", SCSPEC, RID_EXTERN,},
{"short", TYPESPEC, RID_SHORT,},
{"const", CV_QUALIFIER, RID_CONST,},
{"static", SCSPEC, RID_STATIC,},
{"", 0, 0},
{"__inline", SCSPEC, RID_INLINE},
{"", 0, 0},
{"__inline__", SCSPEC, RID_INLINE},
{"__restrict__", CV_QUALIFIER, RID_RESTRICT},
{"inline", SCSPEC, RID_INLINE,},
{"const_cast", CONST_CAST, NORID,},
{"static_cast", STATIC_CAST, NORID,},
{"__restrict", CV_QUALIFIER, RID_RESTRICT},
{"xor", '^', NORID,},
{"__wchar_t", TYPESPEC, RID_WCHAR /* Unique to ANSI C++ */,},
{"new", NEW, NORID,},
{"__alignof__", ALIGNOF, NORID},
{"signed", TYPESPEC, RID_SIGNED,},
{"and", ANDAND, NORID,},
{"", 0, 0}, {"", 0, 0}, {"", 0, 0},
{"explicit", SCSPEC, RID_EXPLICIT,},
{"", 0, 0},
{"__imag__", IMAGPART, NORID},
{"while", WHILE, NORID,},
{"", 0, 0}, {"", 0, 0}, {"", 0, 0},
{"do", DO, NORID,},
{"typename", TYPENAME_KEYWORD, NORID,},
{"friend", SCSPEC, RID_FRIEND,},
{"continue", CONTINUE, NORID,},
{"class", AGGR, RID_CLASS,},
{"default", DEFAULT, NORID,},
{"this", THIS, NORID,},
{"dynamic_cast", DYNAMIC_CAST, NORID,},
{"typeof", TYPEOF, NORID,},
{"virtual", SCSPEC, RID_VIRTUAL,},
{"export", SCSPEC, RID_EXPORT,},
{"and_eq", ASSIGN, NORID,},
{"__typeof__", TYPEOF, NORID},
{"__const__", CV_QUALIFIER, RID_CONST},
{"__volatile", CV_QUALIFIER, RID_VOLATILE},
{"short", TYPESPEC, RID_SHORT,},
{"__volatile__", CV_QUALIFIER, RID_VOLATILE},
{"__const", CV_QUALIFIER, RID_CONST},
{"namespace", NAMESPACE, NORID,},
{"char", TYPESPEC, RID_CHAR,},
{"unsigned", TYPESPEC, RID_UNSIGNED,},
{"double", TYPESPEC, RID_DOUBLE,},
{"or_eq", ASSIGN, NORID,},
{"__null", CONSTANT, RID_NULL},
{"if", IF, NORID,},
{"__signature__", AGGR, RID_SIGNATURE /* Extension */,},
{"__label__", LABEL, NORID},
{"long", TYPESPEC, RID_LONG,},
{"__imag", IMAGPART, NORID},
{"__asm", ASM_KEYWORD, NORID},
{"", 0, 0},
{"__sigof__", SIGOF, NORID /* Extension */,},
{"", 0, 0}, {"", 0, 0}, {"", 0, 0},
{"struct", AGGR, RID_RECORD,},
{"", 0, 0},
{"volatile", CV_QUALIFIER, RID_VOLATILE,},
{"__complex__", TYPESPEC, RID_COMPLEX},
{"goto", GOTO, NORID,},
{"template", TEMPLATE, RID_TEMPLATE,},
{"this", THIS, NORID,},
{"false", CXX_FALSE, NORID,},
{"sizeof", SIZEOF, NORID,},
{"__complex__", TYPESPEC, RID_COMPLEX},
{"", 0, 0}, {"", 0, 0}, {"", 0, 0},
{"for", FOR, NORID,},
{"or", OROR, NORID,},
{"register", SCSPEC, RID_REGISTER,},
{"throw", THROW, NORID,},
{"try", TRY, NORID,},
{"switch", SWITCH, NORID,},
{"typedef", SCSPEC, RID_TYPEDEF,},
{"", 0, 0},
{"using", USING, NORID,},
{"", 0, 0}, {"", 0, 0},
{"__complex", TYPESPEC, RID_COMPLEX},
{"operator", OPERATOR, NORID,},
{"__signature__", AGGR, RID_SIGNATURE /* Extension */,},
{"catch", CATCH, NORID,},
{"delete", DELETE, NORID,},
{"typeid", TYPEID, NORID,},
{"sigof", SIGOF, NORID /* Extension */,},
{"const_cast", CONST_CAST, NORID,},
{"__signed", TYPESPEC, RID_SIGNED},
{"class", AGGR, RID_CLASS,},
{"xor", '^', NORID,},
{"do", DO, NORID,},
{"continue", CONTINUE, NORID,},
{"auto", SCSPEC, RID_AUTO,},
{"__typeof__", TYPEOF, NORID},
{"", 0, 0},
{"asm", ASM_KEYWORD, NORID,},
{"signature", AGGR, RID_SIGNATURE /* Extension */,},
{"enum", ENUM, NORID,},
{"reinterpret_cast", REINTERPRET_CAST, NORID,},
{"mutable", SCSPEC, RID_MUTABLE,},
{"__alignof", ALIGNOF, NORID},
{"return", RETURN_KEYWORD, NORID,},
{"", 0, 0}, {"", 0, 0}, {"", 0, 0}, {"", 0, 0},
{"", 0, 0}, {"", 0, 0}, {"", 0, 0}, {"", 0, 0},
{"", 0, 0}, {"", 0, 0},
{"__alignof__", ALIGNOF, NORID},
{"float", TYPESPEC, RID_FLOAT,},
{"", 0, 0}, {"", 0, 0}, {"", 0, 0}, {"", 0, 0},
{"", 0, 0}, {"", 0, 0}, {"", 0, 0}, {"", 0, 0},
{"struct", AGGR, RID_RECORD,},
{"long", TYPESPEC, RID_LONG,},
{"__null", CONSTANT, RID_NULL},
{"", 0, 0},
{"__label__", LABEL, NORID},
{"__inline", SCSPEC, RID_INLINE},
{"reinterpret_cast", REINTERPRET_CAST, NORID,},
{"__inline__", SCSPEC, RID_INLINE},
{"__imag__", IMAGPART, NORID},
{"typename", TYPENAME_KEYWORD, NORID,},
{"friend", SCSPEC, RID_FRIEND,},
{"compl", '~', NORID,},
{"public", VISSPEC, RID_PUBLIC,},
{"bitor", '|', NORID,},
{"namespace", NAMESPACE, NORID,},
{"or_eq", ASSIGN, NORID,},
{"", 0, 0},
{"private", VISSPEC, RID_PRIVATE,},
{"__typeof", TYPEOF, NORID},
{"", 0, 0},
{"__alignof", ALIGNOF, NORID},
{"__complex", TYPESPEC, RID_COMPLEX},
{"union", AGGR, RID_UNION,},
{"", 0, 0},
{"__extension__", EXTENSION, NORID},
{"", 0, 0},
{"return", RETURN_KEYWORD, NORID,},
{"and", ANDAND, NORID,},
{"__asm", ASM_KEYWORD, NORID},
{"__imag", IMAGPART, NORID},
{"virtual", SCSPEC, RID_VIRTUAL,},
{"protected", VISSPEC, RID_PROTECTED,},
{"throw", THROW, NORID,},
{"default", DEFAULT, NORID,},
{"using", USING, NORID,},
{"unsigned", TYPESPEC, RID_UNSIGNED,},
{"break", BREAK, NORID,},
{"", 0, 0},
{"signature", AGGR, RID_SIGNATURE /* Extension */,},
{"bool", TYPESPEC, RID_BOOL,},
{"", 0, 0},
{"typedef", SCSPEC, RID_TYPEDEF,},
{"__typeof", TYPEOF, NORID},
{"bitand", '&', NORID,},
{"break", BREAK, NORID,},
{"", 0, 0}, {"", 0, 0}, {"", 0, 0},
{"union", AGGR, RID_UNION,},
{"", 0, 0}, {"", 0, 0}, {"", 0, 0}, {"", 0, 0},
{"", 0, 0}, {"", 0, 0}, {"", 0, 0}, {"", 0, 0},
{"", 0, 0}, {"", 0, 0}, {"", 0, 0}, {"", 0, 0},
{"", 0, 0}, {"", 0, 0}, {"", 0, 0}, {"", 0, 0},
{"", 0, 0}, {"", 0, 0}, {"", 0, 0}, {"", 0, 0},
{"not_eq", EQCOMPARE, NORID,},
{"", 0, 0}, {"", 0, 0},
{"goto", GOTO, NORID,},
{"sigof", SIGOF, NORID /* Extension */,},
{"", 0, 0}, {"", 0, 0}, {"", 0, 0}, {"", 0, 0},
{"", 0, 0}, {"", 0, 0}, {"", 0, 0}, {"", 0, 0},
{"", 0, 0}, {"", 0, 0}, {"", 0, 0}, {"", 0, 0},
{"", 0, 0}, {"", 0, 0}, {"", 0, 0}, {"", 0, 0},
{"", 0, 0}, {"", 0, 0}, {"", 0, 0}, {"", 0, 0},
{"", 0, 0}, {"", 0, 0}, {"", 0, 0}, {"", 0, 0},
{"", 0, 0}, {"", 0, 0},
{"bitor", '|', NORID,},
{"auto", SCSPEC, RID_AUTO,},
{"", 0, 0}, {"", 0, 0}, {"", 0, 0}, {"", 0, 0},
{"", 0, 0}, {"", 0, 0}, {"", 0, 0}, {"", 0, 0},
{"", 0, 0}, {"", 0, 0}, {"", 0, 0}, {"", 0, 0},
{"", 0, 0}, {"", 0, 0}, {"", 0, 0}, {"", 0, 0},
{"", 0, 0}, {"", 0, 0}, {"", 0, 0}, {"", 0, 0},
{"", 0, 0}, {"", 0, 0}, {"", 0, 0}, {"", 0, 0},
{"", 0, 0}, {"", 0, 0}, {"", 0, 0}, {"", 0, 0},
{"double", TYPESPEC, RID_DOUBLE,},
{"signed", TYPESPEC, RID_SIGNED,},
{"while", WHILE, NORID,},
{"asm", ASM_KEYWORD, NORID,},
{"volatile", CV_QUALIFIER, RID_VOLATILE,},
{"and_eq", ASSIGN, NORID,},
{"", 0, 0},
{"operator", OPERATOR, NORID,}
{"mutable", SCSPEC, RID_MUTABLE,},
{"dynamic_cast", DYNAMIC_CAST, NORID,},
{"", 0, 0},
{"new", NEW, NORID,},
{"xor_eq", ASSIGN, NORID,},
{"", 0, 0}, {"", 0, 0}, {"", 0, 0}, {"", 0, 0},
{"", 0, 0}, {"", 0, 0}, {"", 0, 0}, {"", 0, 0},
{"", 0, 0}, {"", 0, 0}, {"", 0, 0}, {"", 0, 0},
{"", 0, 0}, {"", 0, 0}, {"", 0, 0}, {"", 0, 0},
{"", 0, 0}, {"", 0, 0}, {"", 0, 0}, {"", 0, 0},
{"", 0, 0}, {"", 0, 0}, {"", 0, 0},
{"enum", ENUM, NORID,},
{"", 0, 0}, {"", 0, 0}, {"", 0, 0}, {"", 0, 0},
{"void", TYPESPEC, RID_VOID,},
{"", 0, 0}, {"", 0, 0}, {"", 0, 0},
{"bitand", '&', NORID,}
};
if (len <= MAX_WORD_LENGTH && len >= MIN_WORD_LENGTH)

109
tests/gpc.exp
View File

@@ -17,8 +17,8 @@ struct resword { char *name; short token; short iclass;};
#define MIN_WORD_LENGTH 2
#define MAX_WORD_LENGTH 9
#define MIN_HASH_VALUE 2
#define MAX_HASH_VALUE 43
/* maximum key range = 42, duplicates = 0 */
#define MAX_HASH_VALUE 37
/* maximum key range = 36, duplicates = 0 */
#ifdef __GNUC__
__inline
@@ -34,32 +34,32 @@ hash (str, len)
{
static unsigned char asso_values[] =
{
44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
44, 44, 44, 44, 44, 18, 29, 14, 6, 7,
10, 20, 44, 28, 44, 44, 28, 19, 22, 15,
0, 44, 9, 23, 0, 23, 26, 2, 44, 44,
44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
0, 0, 13, 44, 30, 44, 44, 44, 0, 25,
1, 0, 44, 44, 0, 44, 1, 44, 25, 44,
44, 0, 44, 44, 44, 44, 44, 44, 44, 44,
44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
44, 44, 44, 44, 44, 44
38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
38, 38, 38, 38, 38, 14, 32, 16, 13, 9,
1, 32, 38, 9, 38, 38, 22, 26, 16, 3,
2, 38, 7, 23, 0, 19, 25, 23, 38, 38,
38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
5, 1, 5, 38, 3, 38, 38, 38, 8, 16,
0, 0, 38, 38, 3, 38, 7, 38, 8, 38,
38, 4, 38, 38, 38, 38, 38, 38, 38, 38,
38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
38, 38, 38, 38, 38, 38
};
return len + asso_values[(unsigned char)str[len - 1]] + asso_values[(unsigned char)str[0]];
}
@@ -77,41 +77,40 @@ is_reserved_word (str, len)
{""}, {""},
{"To", TO, PASCAL_ISO},
{""},
{"Type", TYPE, PASCAL_ISO},
{"Then", THEN, PASCAL_ISO},
{"Packed", PACKED, PASCAL_ISO},
{"While", WHILE, PASCAL_ISO},
{"Do", DO, PASCAL_ISO},
{"Procedure", PROCEDURE, PASCAL_ISO},
{"End", END, PASCAL_ISO},
{"Else", ELSE, PASCAL_ISO},
{"Downto", DOWNTO, PASCAL_ISO},
{"For", FOR, PASCAL_ISO},
{"Type", TYPE, PASCAL_ISO},
{"File", FILE_, PASCAL_ISO},
{"Record", RECORD, PASCAL_ISO},
{"Repeat", REPEAT, PASCAL_ISO},
{"For", FOR, PASCAL_ISO},
{"Or", OR, PASCAL_ISO},
{"Case", CASE, PASCAL_ISO},
{"Function", FUNCTION, PASCAL_ISO},
{"Const", CONST, PASCAL_ISO},
{"And", AND, PASCAL_ISO},
{"Mod", MOD, PASCAL_ISO},
{"Array", ARRAY, PASCAL_ISO},
{"Goto", GOTO, PASCAL_ISO},
{"Nil", NIL, PASCAL_ISO},
{"Not", NOT, PASCAL_ISO},
{"Set", SET, PASCAL_ISO},
{"Until", UNTIL, PASCAL_ISO},
{"Var", VAR, PASCAL_ISO},
{"Of", OF, PASCAL_ISO},
{"In", IN, PASCAL_ISO},
{"Program",PROGRAM,PASCAL_ISO},
{"Label", LABEL, PASCAL_ISO},
{"Procedure", PROCEDURE, PASCAL_ISO},
{"Packed", PACKED, PASCAL_ISO},
{"Else", ELSE, PASCAL_ISO},
{"Do", DO, PASCAL_ISO},
{"If", IF, PASCAL_ISO},
{"End", END, PASCAL_ISO},
{"Record", RECORD, PASCAL_ISO},
{"Downto", DOWNTO, PASCAL_ISO},
{"Repeat", REPEAT, PASCAL_ISO},
{"Case", CASE, PASCAL_ISO},
{"And", AND, PASCAL_ISO},
{"Array", ARRAY, PASCAL_ISO},
{"Div", DIV, PASCAL_ISO},
{"Begin", BEGIN_, PASCAL_ISO},
{"Program",PROGRAM,PASCAL_ISO},
{"Not", NOT, PASCAL_ISO},
{"Nil", NIL, PASCAL_ISO},
{"Const", CONST, PASCAL_ISO},
{"While", WHILE, PASCAL_ISO},
{"With", WITH, PASCAL_ISO},
{""}, {""}, {""}, {""}, {""}, {""},
{"If", IF, PASCAL_ISO}
{"Var", VAR, PASCAL_ISO},
{"Until", UNTIL, PASCAL_ISO},
{"Set", SET, PASCAL_ISO},
{"Mod", MOD, PASCAL_ISO},
{"Label", LABEL, PASCAL_ISO},
{"Goto", GOTO, PASCAL_ISO},
{"Begin", BEGIN_, PASCAL_ISO}
};
if (len <= MAX_WORD_LENGTH && len >= MIN_WORD_LENGTH)

151
tests/java.exp
View File

@@ -31,9 +31,9 @@ struct java_keyword { const char *name; int token; };
#define TOTAL_KEYWORDS 50
#define MIN_WORD_LENGTH 2
#define MAX_WORD_LENGTH 12
#define MIN_HASH_VALUE 6
#define MAX_HASH_VALUE 86
/* maximum key range = 81, duplicates = 0 */
#define MIN_HASH_VALUE 7
#define MAX_HASH_VALUE 76
/* maximum key range = 70, duplicates = 0 */
#ifdef __GNUC__
__inline
@@ -49,32 +49,32 @@ hash (str, len)
{
static unsigned char asso_values[] =
{
87, 87, 87, 87, 87, 87, 87, 87, 87, 87,
87, 87, 87, 87, 87, 87, 87, 87, 87, 87,
87, 87, 87, 87, 87, 87, 87, 87, 87, 87,
87, 87, 87, 87, 87, 87, 87, 87, 87, 87,
87, 87, 87, 87, 87, 87, 87, 87, 87, 87,
87, 87, 87, 87, 87, 87, 87, 87, 87, 87,
87, 87, 87, 87, 87, 87, 87, 87, 87, 87,
87, 87, 87, 87, 87, 87, 87, 87, 87, 87,
87, 87, 87, 87, 87, 87, 87, 87, 87, 87,
87, 87, 87, 87, 87, 87, 87, 18, 37, 38,
27, 1, 30, 3, 12, 8, 87, 2, 11, 87,
8, 1, 5, 87, 24, 1, 1, 30, 2, 36,
87, 1, 87, 87, 87, 87, 87, 87, 87, 87,
87, 87, 87, 87, 87, 87, 87, 87, 87, 87,
87, 87, 87, 87, 87, 87, 87, 87, 87, 87,
87, 87, 87, 87, 87, 87, 87, 87, 87, 87,
87, 87, 87, 87, 87, 87, 87, 87, 87, 87,
87, 87, 87, 87, 87, 87, 87, 87, 87, 87,
87, 87, 87, 87, 87, 87, 87, 87, 87, 87,
87, 87, 87, 87, 87, 87, 87, 87, 87, 87,
87, 87, 87, 87, 87, 87, 87, 87, 87, 87,
87, 87, 87, 87, 87, 87, 87, 87, 87, 87,
87, 87, 87, 87, 87, 87, 87, 87, 87, 87,
87, 87, 87, 87, 87, 87, 87, 87, 87, 87,
87, 87, 87, 87, 87, 87, 87, 87, 87, 87,
87, 87, 87, 87, 87, 87
77, 77, 77, 77, 77, 77, 77, 77, 77, 77,
77, 77, 77, 77, 77, 77, 77, 77, 77, 77,
77, 77, 77, 77, 77, 77, 77, 77, 77, 77,
77, 77, 77, 77, 77, 77, 77, 77, 77, 77,
77, 77, 77, 77, 77, 77, 77, 77, 77, 77,
77, 77, 77, 77, 77, 77, 77, 77, 77, 77,
77, 77, 77, 77, 77, 77, 77, 77, 77, 77,
77, 77, 77, 77, 77, 77, 77, 77, 77, 77,
77, 77, 77, 77, 77, 77, 77, 77, 77, 77,
77, 77, 77, 77, 77, 77, 77, 7, 30, 7,
12, 1, 14, 28, 41, 3, 77, 16, 11, 77,
16, 23, 1, 77, 15, 1, 1, 34, 30, 18,
77, 11, 77, 77, 77, 77, 77, 77, 77, 77,
77, 77, 77, 77, 77, 77, 77, 77, 77, 77,
77, 77, 77, 77, 77, 77, 77, 77, 77, 77,
77, 77, 77, 77, 77, 77, 77, 77, 77, 77,
77, 77, 77, 77, 77, 77, 77, 77, 77, 77,
77, 77, 77, 77, 77, 77, 77, 77, 77, 77,
77, 77, 77, 77, 77, 77, 77, 77, 77, 77,
77, 77, 77, 77, 77, 77, 77, 77, 77, 77,
77, 77, 77, 77, 77, 77, 77, 77, 77, 77,
77, 77, 77, 77, 77, 77, 77, 77, 77, 77,
77, 77, 77, 77, 77, 77, 77, 77, 77, 77,
77, 77, 77, 77, 77, 77, 77, 77, 77, 77,
77, 77, 77, 77, 77, 77, 77, 77, 77, 77,
77, 77, 77, 77, 77, 77
};
register int hval = len;
@@ -102,70 +102,63 @@ java_keyword (str, len)
static struct java_keyword wordlist[] =
{
{"", 0}, {"", 0}, {"", 0}, {"", 0}, {"", 0}, {"", 0},
{"try", TRY_TK},
{"", 0},
{"else", ELSE_TK},
{"short", SHORT_TK},
{"goto", GOTO_TK},
{"extends", EXTENDS_TK},
{"", 0}, {"", 0},
{"int", INT_TK},
{"this", THIS_TK},
{"", 0},
{"native", NATIVE_TK},
{"", 0}, {"", 0},
{"interface", INTERFACE_TK},
{"extends", EXTENDS_TK},
{"import", IMPORT_TK},
{"private", PRIVATE_TK},
{"volatile", VOLATILE_TK},
{"", 0},
{"case", CASE_TK},
{"interface", INTERFACE_TK},
{"implements", IMPLEMENTS_TK},
{"", 0},
{"long", LONG_TK},
{"switch", SWITCH_TK},
{"package", PACKAGE_TK},
{"abstract", ABSTRACT_TK},
{"transient", TRANSIENT_TK},
{"do", DO_TK},
{"", 0},
{"throws", THROWS_TK},
{"", 0},
{"null", NULL_TK},
{"super", SUPER_TK},
{"true", TRUE_TK},
{"float", FLOAT_TK},
{"", 0},
{"return", RETURN_TK},
{"if", IF_TK},
{"void", VOID_TK},
{"protected", PROTECTED_TK},
{"byte", BYTE_TK},
{"case", CASE_TK},
{"break", BREAK_TK},
{"finally", FINALLY_TK},
{"false", FALSE_TK},
{"synchronized", SYNCHRONIZED_TK},
{"instanceof", INSTANCEOF_TK},
{"while", WHILE_TK},
{"package", PACKAGE_TK},
{"const", CONST_TK},
{"boolean", BOOLEAN_TK},
{"final", FINAL_TK},
{"continue", CONTINUE_TK},
{"catch", CATCH_TK},
{"", 0}, {"", 0}, {"", 0}, {"", 0}, {"", 0},
{"class", CLASS_TK},
{"static", STATIC_TK},
{"double", DOUBLE_TK},
{"default", DEFAULT_TK},
{"throw", THROW_TK},
{"", 0}, {"", 0}, {"", 0}, {"", 0}, {"", 0}, {"", 0},
{"", 0}, {"", 0}, {"", 0}, {"", 0}, {"", 0}, {"", 0},
{"", 0}, {"", 0},
{"for", FOR_TK},
{"super", SUPER_TK},
{"throws", THROWS_TK},
{"native", NATIVE_TK},
{"", 0},
{"new", NEW_TK},
{"try", TRY_TK},
{"while", WHILE_TK},
{"instanceof", INSTANCEOF_TK},
{"const", CONST_TK},
{"short", SHORT_TK},
{"false", FALSE_TK},
{"continue", CONTINUE_TK},
{"char", CHAR_TK},
{"default", DEFAULT_TK},
{"", 0},
{"public", PUBLIC_TK}
{"byte", BYTE_TK},
{"do", DO_TK},
{"return", RETURN_TK},
{"throw", THROW_TK},
{"true", TRUE_TK},
{"synchronized", SYNCHRONIZED_TK},
{"null", NULL_TK},
{"float", FLOAT_TK},
{"public", PUBLIC_TK},
{"protected", PROTECTED_TK},
{"final", FINAL_TK},
{"for", FOR_TK},
{"finally", FINALLY_TK},
{"void", VOID_TK},
{"volatile", VOLATILE_TK},
{"switch", SWITCH_TK},
{"break", BREAK_TK},
{"double", DOUBLE_TK},
{"catch", CATCH_TK},
{"new", NEW_TK},
{"goto", GOTO_TK},
{"", 0}, {"", 0},
{"long", LONG_TK},
{"", 0}, {"", 0}, {"", 0}, {"", 0}, {"", 0}, {"", 0},
{"", 0}, {"", 0}, {"", 0}, {"", 0}, {"", 0}, {"", 0},
{"", 0}, {"", 0}, {"", 0}, {"", 0},
{"boolean", BOOLEAN_TK}
};
if (len <= MAX_WORD_LENGTH && len >= MIN_WORD_LENGTH)

192
tests/modula2.exp
View File

@@ -5,8 +5,8 @@
#define MIN_WORD_LENGTH 2
#define MAX_WORD_LENGTH 14
#define MIN_HASH_VALUE 1
#define MAX_HASH_VALUE 256
/* maximum key range = 256, duplicates = 0 */
#define MAX_HASH_VALUE 155
/* maximum key range = 155, duplicates = 0 */
#ifdef __GNUC__
__inline
@@ -20,34 +20,34 @@ hash (str, len)
register const char *str;
register unsigned int len;
{
static unsigned short asso_values[] =
static unsigned char asso_values[] =
{
257, 257, 257, 257, 257, 257, 257, 257, 257, 257,
257, 257, 257, 257, 257, 257, 257, 257, 257, 257,
257, 257, 257, 257, 257, 257, 257, 257, 257, 257,
257, 257, 257, 257, 257, 257, 257, 257, 257, 257,
257, 257, 257, 257, 257, 257, 257, 257, 257, 257,
257, 257, 257, 257, 257, 257, 257, 257, 257, 257,
257, 257, 257, 257, 257, 25, 30, 35, 21, 0,
30, 15, 30, 45, 257, 257, 0, 5, 45, 0,
10, 0, 1, 20, 25, 15, 30, 40, 15, 5,
257, 257, 257, 257, 257, 257, 257, 257, 257, 257,
257, 257, 257, 257, 257, 257, 257, 257, 257, 257,
257, 257, 257, 257, 257, 257, 257, 257, 257, 257,
257, 257, 257, 257, 257, 257, 257, 257, 257, 257,
257, 257, 257, 257, 257, 257, 257, 257, 257, 257,
257, 257, 257, 257, 257, 257, 257, 257, 257, 257,
257, 257, 257, 257, 257, 257, 257, 257, 257, 257,
257, 257, 257, 257, 257, 257, 257, 257, 257, 257,
257, 257, 257, 257, 257, 257, 257, 257, 257, 257,
257, 257, 257, 257, 257, 257, 257, 257, 257, 257,
257, 257, 257, 257, 257, 257, 257, 257, 257, 257,
257, 257, 257, 257, 257, 257, 257, 257, 257, 257,
257, 257, 257, 257, 257, 257, 257, 257, 257, 257,
257, 257, 257, 257, 257, 257, 257, 257, 257, 257,
257, 257, 257, 257, 257, 257, 257, 257, 257, 257,
257, 257, 257, 257, 257, 257, 257, 257, 257, 257,
257, 257, 257, 257, 257, 257
156, 156, 156, 156, 156, 156, 156, 156, 156, 156,
156, 156, 156, 156, 156, 156, 156, 156, 156, 156,
156, 156, 156, 156, 156, 156, 156, 156, 156, 156,
156, 156, 156, 156, 156, 156, 156, 156, 156, 156,
156, 156, 156, 156, 156, 156, 156, 156, 156, 156,
156, 156, 156, 156, 156, 156, 156, 156, 156, 156,
156, 156, 156, 156, 156, 1, 10, 30, 25, 0,
10, 55, 6, 0, 156, 156, 15, 15, 35, 15,
30, 0, 5, 1, 0, 45, 21, 45, 6, 1,
156, 156, 156, 156, 156, 156, 156, 156, 156, 156,
156, 156, 156, 156, 156, 156, 156, 156, 156, 156,
156, 156, 156, 156, 156, 156, 156, 156, 156, 156,
156, 156, 156, 156, 156, 156, 156, 156, 156, 156,
156, 156, 156, 156, 156, 156, 156, 156, 156, 156,
156, 156, 156, 156, 156, 156, 156, 156, 156, 156,
156, 156, 156, 156, 156, 156, 156, 156, 156, 156,
156, 156, 156, 156, 156, 156, 156, 156, 156, 156,
156, 156, 156, 156, 156, 156, 156, 156, 156, 156,
156, 156, 156, 156, 156, 156, 156, 156, 156, 156,
156, 156, 156, 156, 156, 156, 156, 156, 156, 156,
156, 156, 156, 156, 156, 156, 156, 156, 156, 156,
156, 156, 156, 156, 156, 156, 156, 156, 156, 156,
156, 156, 156, 156, 156, 156, 156, 156, 156, 156,
156, 156, 156, 156, 156, 156, 156, 156, 156, 156,
156, 156, 156, 156, 156, 156, 156, 156, 156, 156,
156, 156, 156, 156, 156, 156
};
register int hval = 0;
@@ -85,108 +85,90 @@ in_word_set (str, len)
{
static unsigned char lengthtable[] =
{
0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0,
0, 0, 0, 0, 0, 0, 4, 2, 0, 0, 0, 2, 3, 0,
0, 0, 2, 3, 0, 0, 0, 2, 4, 0, 0, 0, 4, 6,
0, 0, 0, 3, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0,
3, 5, 6, 0, 0, 6, 0, 0, 0, 0, 3, 0, 0, 0,
3, 0, 0, 0, 0, 2, 0, 0, 0, 0, 4, 0, 0, 9,
0, 4, 6, 6, 0, 0, 2, 3, 0, 0, 0, 5, 3, 0,
0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 14, 0,
0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5,
7, 0, 0, 0, 5, 0, 0, 0, 0, 5, 0, 0, 0, 0,
4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0,
0, 3, 0, 0, 0, 0, 4, 0, 0, 0, 2, 2, 0, 5,
0, 2, 4, 0, 0, 0, 2, 0, 0, 0, 0, 2, 5, 3,
0, 0, 3, 4, 4, 0, 0, 2, 6, 0, 0, 0, 2, 4,
0, 0, 0, 4, 3, 0, 0, 0, 3, 4, 0, 0, 0, 3,
6, 0, 0, 0, 3, 3, 0, 0, 0, 6, 5, 0, 0, 0,
10, 9, 0, 0, 0, 4, 0, 0, 0, 0, 6, 5, 0, 0,
0, 7, 0, 0, 0, 0, 6, 0, 0, 0, 0, 5, 0, 0,
0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 14, 0,
0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 10
0, 9
};
static const char * wordlist[] =
{
"",
"OR",
"", "", "", "", "", "", "", "",
"LOOP",
"", "", "", "", "", "", "", "", "",
"ELSE",
"DO",
"", "", "",
"TO",
"MOD",
"", "", "",
"OF",
"FOR",
"", "", "",
"BY",
"FROM",
"", "", "",
"TYPE",
"MODULE",
"", "", "",
"SET",
"", "", "", "", "",
"EXPORT",
"", "", "", "",
"VAR",
"ARRAY",
"RECORD",
"", "",
"REPEAT",
"", "", "", "",
"END",
"EXIT",
"", "", "",
"NOT",
"", "", "", "",
"IF",
"BY",
"",
"ARRAY",
"",
"TO",
"ELSE",
"", "", "",
"OR",
"", "", "", "",
"OF",
"ELSIF",
"VAR",
"", "",
"FOR",
"TYPE",
"CASE",
"", "",
"PROCEDURE",
"",
"EXIT",
"IMPORT",
"RETURN",
"", "",
"IN",
"AND",
"REPEAT",
"", "", "",
"ELSIF",
"DO",
"THEN",
"", "", "",
"FROM",
"DIV",
"", "", "",
"THEN",
"", "", "", "", "", "", "", "", "",
"IMPLEMENTATION",
"", "", "", "",
"WHILE",
"", "", "", "", "", "", "", "", "",
"CONST",
"POINTER",
"NOT",
"WITH",
"", "", "",
"MOD",
"EXPORT",
"", "", "",
"END",
"AND",
"", "", "",
"IMPORT",
"WHILE",
"", "", "",
"DEFINITION",
"QUALIFIED",
"", "", "",
"LOOP",
"", "", "", "",
"RECORD",
"CONST",
"", "", "",
"POINTER",
"", "", "", "",
"RETURN",
"", "", "", "",
"UNTIL",
"", "", "", "",
"BEGIN",
"", "", "", "", "", "", "", "", "",
"IMPLEMENTATION",
"", "", "", "",
"WITH",
"", "", "", "", "", "", "", "", "",
"", "", "", "", "", "", "", "", "",
"",
"QUALIFIED",
"MODULE",
"", "", "", "", "", "", "", "", "",
"", "", "", "", "", "", "", "", "",
"", "", "", "", "", "", "", "", "",
"", "", "", "", "", "", "", "", "",
"", "", "", "", "", "", "", "", "",
"", "", "", "", "", "", "", "", "",
"", "", "", "", "", "", "", "", "",
"", "", "", "", "", "", "", "", "",
"", "", "", "", "", "", "", "", "",
"", "", "", "", "", "", "", "", "",
"", "", "", "", "",
"DEFINITION"
"", "", "",
"PROCEDURE"
};
if (len <= MAX_WORD_LENGTH && len >= MIN_WORD_LENGTH)

177
tests/objc.exp
View File

@@ -7,8 +7,8 @@ struct resword { char *name; short token; enum rid rid; };
#define TOTAL_KEYWORDS 59
#define MIN_WORD_LENGTH 2
#define MAX_WORD_LENGTH 15
#define MIN_HASH_VALUE 11
#define MAX_HASH_VALUE 98
#define MIN_HASH_VALUE 8
#define MAX_HASH_VALUE 95
/* maximum key range = 88, duplicates = 0 */
#ifdef __GNUC__
@@ -25,32 +25,32 @@ hash (str, len)
{
static unsigned char asso_values[] =
{
99, 99, 99, 99, 99, 99, 99, 99, 99, 99,
99, 99, 99, 99, 99, 99, 99, 99, 99, 99,
99, 99, 99, 99, 99, 99, 99, 99, 99, 99,
99, 99, 99, 99, 99, 99, 99, 99, 99, 99,
99, 99, 99, 99, 99, 99, 99, 99, 99, 99,
99, 99, 99, 99, 99, 99, 99, 99, 99, 99,
99, 99, 99, 99, 16, 99, 99, 99, 99, 99,
99, 99, 99, 99, 99, 99, 99, 99, 99, 99,
99, 99, 99, 99, 99, 99, 99, 99, 99, 99,
99, 99, 99, 99, 99, 1, 99, 2, 1, 32,
1, 5, 19, 36, 25, 13, 99, 1, 8, 37,
2, 41, 34, 99, 27, 12, 1, 42, 21, 28,
99, 99, 12, 99, 99, 99, 99, 99, 99, 99,
99, 99, 99, 99, 99, 99, 99, 99, 99, 99,
99, 99, 99, 99, 99, 99, 99, 99, 99, 99,
99, 99, 99, 99, 99, 99, 99, 99, 99, 99,
99, 99, 99, 99, 99, 99, 99, 99, 99, 99,
99, 99, 99, 99, 99, 99, 99, 99, 99, 99,
99, 99, 99, 99, 99, 99, 99, 99, 99, 99,
99, 99, 99, 99, 99, 99, 99, 99, 99, 99,
99, 99, 99, 99, 99, 99, 99, 99, 99, 99,
99, 99, 99, 99, 99, 99, 99, 99, 99, 99,
99, 99, 99, 99, 99, 99, 99, 99, 99, 99,
99, 99, 99, 99, 99, 99, 99, 99, 99, 99,
99, 99, 99, 99, 99, 99, 99, 99, 99, 99,
99, 99, 99, 99, 99, 99
96, 96, 96, 96, 96, 96, 96, 96, 96, 96,
96, 96, 96, 96, 96, 96, 96, 96, 96, 96,
96, 96, 96, 96, 96, 96, 96, 96, 96, 96,
96, 96, 96, 96, 96, 96, 96, 96, 96, 96,
96, 96, 96, 96, 96, 96, 96, 96, 96, 96,
96, 96, 96, 96, 96, 96, 96, 96, 96, 96,
96, 96, 96, 96, 19, 96, 96, 96, 96, 96,
96, 96, 96, 96, 96, 96, 96, 96, 96, 96,
96, 96, 96, 96, 96, 96, 96, 96, 96, 96,
96, 96, 96, 96, 96, 2, 96, 2, 1, 10,
26, 1, 23, 27, 27, 24, 96, 1, 25, 36,
10, 34, 23, 96, 10, 6, 8, 11, 41, 2,
96, 96, 23, 96, 96, 96, 96, 96, 96, 96,
96, 96, 96, 96, 96, 96, 96, 96, 96, 96,
96, 96, 96, 96, 96, 96, 96, 96, 96, 96,
96, 96, 96, 96, 96, 96, 96, 96, 96, 96,
96, 96, 96, 96, 96, 96, 96, 96, 96, 96,
96, 96, 96, 96, 96, 96, 96, 96, 96, 96,
96, 96, 96, 96, 96, 96, 96, 96, 96, 96,
96, 96, 96, 96, 96, 96, 96, 96, 96, 96,
96, 96, 96, 96, 96, 96, 96, 96, 96, 96,
96, 96, 96, 96, 96, 96, 96, 96, 96, 96,
96, 96, 96, 96, 96, 96, 96, 96, 96, 96,
96, 96, 96, 96, 96, 96, 96, 96, 96, 96,
96, 96, 96, 96, 96, 96, 96, 96, 96, 96,
96, 96, 96, 96, 96, 96
};
register int hval = len;
@@ -77,77 +77,76 @@ is_reserved_word (str, len)
{
static struct resword wordlist[] =
{
{""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
{""}, {""},
{"__asm__", ASM, NORID},
{""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
{"break", BREAK, NORID},
{"__typeof__", TYPEOF, NORID},
{"extern", SCSPEC, RID_EXTERN},
{"__alignof__", ALIGNOF, NORID},
{""},
{"__attribute__", ATTRIBUTE, NORID},
{"int", TYPESPEC, RID_INT},
{"__attribute", ATTRIBUTE, NORID},
{"__extension__", EXTENSION, NORID},
{""},
{"__signed", TYPESPEC, RID_SIGNED},
{"@end", END, NORID},
{"__signed__", TYPESPEC, RID_SIGNED},
{"__inline__", SCSPEC, RID_INLINE},
{""}, {""}, {""},
{"else", ELSE, NORID},
{"__inline", SCSPEC, RID_INLINE},
{"default", DEFAULT, NORID},
{"__typeof", TYPEOF, NORID},
{"@encode", ENCODE, NORID},
{"__alignof", ALIGNOF, NORID},
{"inline", SCSPEC, RID_INLINE},
{"@interface", INTERFACE, NORID},
{"if", IF, NORID},
{"__volatile__", TYPE_QUAL, RID_VOLATILE},
{"return", RETURN, NORID},
{"__volatile", TYPE_QUAL, RID_VOLATILE},
{"@defs", DEFS, NORID},
{"void", TYPESPEC, RID_VOID},
{"const", TYPE_QUAL, RID_CONST},
{"__const", TYPE_QUAL, RID_CONST},
{"volatile", TYPE_QUAL, RID_VOLATILE},
{"__const__", TYPE_QUAL, RID_CONST},
{"do", DO, NORID},
{"__asm", ASM, NORID},
{"struct", STRUCT, NORID},
{"continue", CONTINUE, NORID},
{"auto", SCSPEC, RID_AUTO},
{"sizeof", SIZEOF, NORID},
{"long", TYPESPEC, RID_LONG},
{"while", WHILE, NORID},
{"static", SCSPEC, RID_STATIC},
{"__asm__", ASM, NORID},
{""}, {""},
{"__attribute", ATTRIBUTE, NORID},
{"__alignof__", ALIGNOF, NORID},
{"__extension__", EXTENSION, NORID},
{"__attribute__", ATTRIBUTE, NORID},
{"__signed__", TYPESPEC, RID_SIGNED},
{"case", CASE, NORID},
{"double", TYPESPEC, RID_DOUBLE},
{"signed", TYPESPEC, RID_SIGNED},
{"switch", SWITCH, NORID},
{"@selector", SELECTOR, NORID},
{"__typeof__", TYPEOF, NORID},
{"__const__", TYPE_QUAL, RID_CONST},
{"static", SCSPEC, RID_STATIC},
{"extern", SCSPEC, RID_EXTERN},
{"char", TYPESPEC, RID_CHAR},
{"__const", TYPE_QUAL, RID_CONST},
{""},
{"short", TYPESPEC, RID_SHORT},
{"typeof", TYPEOF, NORID},
{"typedef", SCSPEC, RID_TYPEDEF},
{"continue", CONTINUE, NORID},
{"struct", STRUCT, NORID},
{"@defs", DEFS, NORID},
{"while", WHILE, NORID},
{"const", TYPE_QUAL, RID_CONST},
{"return", RETURN, NORID},
{"__inline", SCSPEC, RID_INLINE},
{"__alignof", ALIGNOF, NORID},
{"@encode", ENCODE, NORID},
{"__inline__", SCSPEC, RID_INLINE},
{"@selector", SELECTOR, NORID},
{"@interface", INTERFACE, NORID},
{"__typeof", TYPEOF, NORID},
{"__signed", TYPESPEC, RID_SIGNED},
{"int", TYPESPEC, RID_INT},
{"double", TYPESPEC, RID_DOUBLE},
{"__asm", ASM, NORID},
{"for", FOR, NORID},
{"@public", PUBLIC, NORID},
{"auto", SCSPEC, RID_AUTO},
{"if", IF, NORID},
{"union", UNION, NORID},
{"unsigned", TYPESPEC, RID_UNSIGNED},
{""},
{"char", TYPESPEC, RID_CHAR},
{"float", TYPESPEC, RID_FLOAT},
{"enum", ENUM, NORID},
{"short", TYPESPEC, RID_SHORT},
{"__volatile", TYPE_QUAL, RID_VOLATILE},
{"register", SCSPEC, RID_REGISTER},
{"inline", SCSPEC, RID_INLINE},
{"__volatile__", TYPE_QUAL, RID_VOLATILE},
{"sizeof", SIZEOF, NORID},
{"@end", END, NORID},
{"typeof", TYPEOF, NORID},
{"typedef", SCSPEC, RID_TYPEDEF},
{"do", DO, NORID},
{"switch", SWITCH, NORID},
{"default", DEFAULT, NORID},
{"signed", TYPESPEC, RID_SIGNED},
{"long", TYPESPEC, RID_LONG},
{""}, {""}, {""},
{"@implementation", IMPLEMENTATION, NORID},
{""}, {""}, {""}, {""}, {""},
{"for", FOR, NORID},
{""}, {""},
{"asm", ASM, NORID},
{"float", TYPESPEC, RID_FLOAT},
{""}, {""},
{"goto", GOTO, NORID},
{""},
{"volatile", TYPE_QUAL, RID_VOLATILE},
{""},
{"asm", ASM, NORID},
{""}, {""},
{"@implementation", IMPLEMENTATION, NORID},
{""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
{""}, {""}, {""}, {""}, {""},
{"enum", ENUM, NORID},
{""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
{"@public", PUBLIC, NORID},
{"register", SCSPEC, RID_REGISTER}
{"void", TYPESPEC, RID_VOID}
};
if (len <= MAX_WORD_LENGTH && len >= MIN_WORD_LENGTH)

214
tests/test-4.exp
View File

@@ -7,9 +7,9 @@ struct resword { const char *name; short token; enum rid rid; };
#define TOTAL_KEYWORDS 83
#define MIN_WORD_LENGTH 2
#define MAX_WORD_LENGTH 20
#define MIN_HASH_VALUE 6
#define MAX_HASH_VALUE 170
/* maximum key range = 165, duplicates = 8 */
#define MIN_HASH_VALUE 4
#define MAX_HASH_VALUE 127
/* maximum key range = 124, duplicates = 8 */
#ifdef __GNUC__
__inline
@@ -25,32 +25,32 @@ hash (str, len)
{
static unsigned char asso_values[] =
{
171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
171, 171, 171, 171, 30, 171, 171, 171, 171, 171,
171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
171, 171, 171, 171, 171, 0, 171, 10, 80, 60,
15, 20, 85, 45, 0, 30, 171, 0, 40, 35,
45, 20, 171, 171, 60, 0, 10, 15, 35, 0,
5, 60, 171, 171, 171, 171, 171, 171, 171, 171,
171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
171, 171, 171, 171, 171, 171
128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
128, 128, 128, 128, 0, 128, 128, 128, 128, 128,
128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
128, 128, 128, 128, 128, 5, 128, 0, 15, 50,
55, 0, 15, 35, 65, 60, 128, 40, 0, 60,
65, 10, 128, 128, 15, 20, 30, 20, 40, 0,
20, 15, 128, 128, 128, 128, 128, 128, 128, 128,
128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
128, 128, 128, 128, 128, 128
};
return len + asso_values[(unsigned char)str[len - 1]] + asso_values[(unsigned char)str[0]];
}
@@ -65,7 +65,17 @@ in_word_set (str, len)
{
static struct resword wordlist[] =
{
{"switch", SWITCH, NORID},
{"else", ELSE, NORID},
{"while", WHILE, NORID},
{"@encode", ENCODE, NORID},
{"@private", PRIVATE, NORID},
{"@protocol", PROTOCOL, NORID},
{"@interface", INTERFACE, NORID},
{"__real", REALPART, NORID},
{"__inline", SCSPEC, RID_INLINE},
{"auto", SCSPEC, RID_AUTO},
{"__volatile", TYPE_QUAL, RID_VOLATILE},
{"__attribute", ATTRIBUTE, NORID},
{"__asm__", ASM_KEYWORD, NORID},
{"__imag__", IMAGPART, NORID},
{"__real__", REALPART, NORID},
@@ -81,99 +91,83 @@ in_word_set (str, len)
{"__restrict__", TYPE_QUAL, RID_RESTRICT},
{"__attribute__", ATTRIBUTE, NORID},
{"__extension__", EXTENSION, NORID},
{"__complex", TYPESPEC, RID_COMPLEX},
{"short", TYPESPEC, RID_SHORT},
{"struct", STRUCT, NORID},
{"__const", TYPE_QUAL, RID_CONST},
{"__restrict", TYPE_QUAL, RID_RESTRICT},
{"signed", TYPESPEC, RID_SIGNED},
{"__signed", TYPESPEC, RID_SIGNED},
{"while", WHILE, NORID},
{"__inline", SCSPEC, RID_INLINE},
{"__volatile", TYPE_QUAL, RID_VOLATILE},
{"__attribute", ATTRIBUTE, NORID},
{"default", DEFAULT, NORID},
{"out", TYPE_QUAL, RID_OUT},
{"auto", SCSPEC, RID_AUTO},
{"@selector", SELECTOR, NORID},
{"@defs", DEFS, NORID},
{"@class", CLASS, NORID},
{"do", DO, NORID},
{"unsigned", TYPESPEC, RID_UNSIGNED},
{"__asm", ASM_KEYWORD, NORID},
{"double", TYPESPEC, RID_DOUBLE},
{"int", TYPESPEC, RID_INT},
{"else", ELSE, NORID},
{"inout", TYPE_QUAL, RID_INOUT},
{"__real", REALPART, NORID},
{"id", OBJECTNAME, RID_ID},
{"asm", ASM_KEYWORD, NORID},
{"@end", END, NORID},
{"@compatibility_alias", ALIAS, NORID},
{"__imag", IMAGPART, NORID},
{"void", TYPESPEC, RID_VOID},
{"@protected", PROTECTED, NORID},
{"inline", SCSPEC, RID_INLINE},
{"@encode", ENCODE, NORID},
{"@private", PRIVATE, NORID},
{"enum", ENUM, NORID},
{"@interface", INTERFACE, NORID},
{"volatile", TYPE_QUAL, RID_VOLATILE},
{"union", UNION, NORID},
{"static", SCSPEC, RID_STATIC},
{"goto", GOTO, NORID},
{"__iterator", SCSPEC, RID_ITERATOR},
{"extern", SCSPEC, RID_EXTERN},
{"const", TYPE_QUAL, RID_CONST},
{"in", TYPE_QUAL, RID_IN},
{"restrict", TYPE_QUAL, RID_RESTRICT},
{"@protocol", PROTOCOL, NORID},
{"case", CASE, NORID},
{"break", BREAK, NORID},
{"oneway", TYPE_QUAL, RID_ONEWAY},
{"continue", CONTINUE, NORID},
{"long", TYPESPEC, RID_LONG},
{"@implementation", IMPLEMENTATION, NORID},
{"sizeof", SIZEOF, NORID},
{"__typeof", TYPEOF, NORID},
{"__alignof", ALIGNOF, NORID},
{"@public", PUBLIC, NORID},
{"@selector", SELECTOR, NORID},
{"__iterator", SCSPEC, RID_ITERATOR},
{"oneway", TYPE_QUAL, RID_ONEWAY},
{"for", FOR, NORID},
{"__complex", TYPESPEC, RID_COMPLEX},
{"byref", TYPE_QUAL, RID_BYREF},
{"bycopy", TYPE_QUAL, RID_BYCOPY},
{"register", SCSPEC, RID_REGISTER},
{"long", TYPESPEC, RID_LONG},
{"@compatibility_alias", ALIAS, NORID},
{"sizeof", SIZEOF, NORID},
{"__const", TYPE_QUAL, RID_CONST},
{"out", TYPE_QUAL, RID_OUT},
{"__restrict", TYPE_QUAL, RID_RESTRICT},
{"__imag", IMAGPART, NORID},
{"volatile", TYPE_QUAL, RID_VOLATILE},
{"goto", GOTO, NORID},
{"float", TYPESPEC, RID_FLOAT},
{"typeof", TYPEOF, NORID},
{"typedef", SCSPEC, RID_TYPEDEF},
{"return", RETURN, NORID},
{"if", IF, NORID},
{"restrict", TYPE_QUAL, RID_RESTRICT},
{"case", CASE, NORID},
{"short", TYPESPEC, RID_SHORT},
{"struct", STRUCT, NORID},
{"@public", PUBLIC, NORID},
{"continue", CONTINUE, NORID},
{"@end", END, NORID},
{"break", BREAK, NORID},
{"double", TYPESPEC, RID_DOUBLE},
{"asm", ASM_KEYWORD, NORID},
{"enum", ENUM, NORID},
{"@protected", PROTECTED, NORID},
{"inline", SCSPEC, RID_INLINE},
{"do", DO, NORID},
{"__signed", TYPESPEC, RID_SIGNED},
{"char", TYPESPEC, RID_CHAR},
{"register", SCSPEC, RID_REGISTER},
{"bycopy", TYPE_QUAL, RID_BYCOPY},
{"for", FOR, NORID},
{"byref", TYPE_QUAL, RID_BYREF}
{"__asm", ASM_KEYWORD, NORID},
{"extern", SCSPEC, RID_EXTERN},
{"static", SCSPEC, RID_STATIC},
{"if", IF, NORID},
{"@implementation", IMPLEMENTATION, NORID},
{"signed", TYPESPEC, RID_SIGNED},
{"unsigned", TYPESPEC, RID_UNSIGNED},
{"const", TYPE_QUAL, RID_CONST},
{"return", RETURN, NORID},
{"union", UNION, NORID},
{"switch", SWITCH, NORID},
{"default", DEFAULT, NORID},
{"int", TYPESPEC, RID_INT},
{"inout", TYPE_QUAL, RID_INOUT},
{"void", TYPESPEC, RID_VOID},
{"id", OBJECTNAME, RID_ID},
{"in", TYPE_QUAL, RID_IN}
};
static short lookup[] =
{
-1, -1, -1, -1, -1, -1, 0, 1,
-156, -151, -145, -136, -110, -102, 16, 17,
18, 19, -69, -2, 20, 21, -1, 22,
-1, 23, -72, -3, 24, -1, 25, 26,
27, 28, 29, 30, 31, 32, 33, -1,
34, 35, -1, 36, 37, 38, 39, 40,
41, 42, 43, 44, -74, -2, 45, 46,
47, 48, 49, 50, 51, -77, -3, 52,
-1, 53, 54, -79, -2, 55, 56, 57,
-81, -2, -1, 58, -1, 59, 60, 61,
-1, -1, -1, -1, 62, 63, 64, -1,
65, 66, 67, 68, -1, 69, 70, -1,
-1, 71, -1, 72, 73, 74, 75, -1,
-1, -1, -1, -1, -1, -1, -1, 76,
-1, -1, -1, -1, -1, 77, -1, -1,
-1, -1, -1, -1, 78, -1, -1, -1,
79, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, 0, 1, -1, 2,
3, 4, 5, 6, -1, 7, 8, 9,
10, 11, -184, -180, -171, -162, -158, -156,
26, 27, 28, -1, 29, 30, 31, 32,
-1, 33, 34, 35, 36, -1, 37, 38,
39, 40, 41, 42, -1, 43, 44, -1,
45, 46, 47, 48, 49, 50, 51, 52,
53, 54, 55, 56, 57, 58, -1, 59,
60, 61, 62, 63, 64, 65, 66, 67,
-59, -2, -62, -3, 68, 69, -64, -2,
70, 71, -1, 72, -1, 73, 74, -67,
-3, -1, 75, 76, 77, 78, -1, 79,
-69, -2, -1, 80, -71, -2, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, 80, -1, 81, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, 82
-1, -1, -1, -1, -1, 81, -1, -1,
-1, -1, -1, -1, -1, -1, -1, 82
};
if (len <= MAX_WORD_LENGTH && len >= MIN_WORD_LENGTH)

9
tests/test-6.exp
View File

@@ -87,12 +87,6 @@ Algorithm employed by gperf:
$,1,2,4,6-10.
-D, --duplicates Handle keywords that hash to duplicate values. This
is useful for certain highly redundant keyword sets.
-f, --fast=ITERATIONS Generate the gen-perf.hash function "fast". This
decreases gperf's running time at the cost of
minimizing generated table size. The numeric
argument represents the number of times to iterate
when resolving a collision. '0' means "iterate by
the number of keywords".
-m, --multiple-iterations=ITERATIONS
Perform multiple choices of the -i and -j values,
and choose the best results. This increases the
@@ -106,9 +100,6 @@ Algorithm employed by gperf:
be an odd number, default is 5.
-n, --no-strlen Do not include the length of the keyword when
computing the hash function.
-o, --occurrence-sort Reorders input keys by frequency of occurrence of
the key sets. This should decrease the search time
dramatically.
-r, --random Utilizes randomness to initialize the associated
values table.
-s, --size-multiple=N Affects the size of the generated hash table. The