denes
/
genkernel_fork
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Remove keymap trq/38 as it contains C sources of test(1) rather than a keymap at the moment

Browse Source
cleanup-cruft
Sebastian Pipping 13 years ago
parent a3cc35f063
commit c6c9f30607
3 changed files with 1 additions and 392 deletions
Show Stats Download Patch File Download Diff File

1
defaults/keymaps/38.map
Unescape View File

@ -1 +0,0 @@
trq.map

2
defaults/keymaps/keymapList
Unescape View File

@ -2,7 +2,7 @@ Please select a keymap from the following list by typing in the appropriate
name or number. Hit Enter for the default "us/41" US English keymap. name or number. Hit Enter for the default "us/41" US English keymap.
1 azerty 7 cf 13 es 19 il 25 mk 31 ru 37 trf 1 azerty 7 cf 13 es 19 il 25 mk 31 ru 37 trf
2 be 8 croat 14 et 20 is 26 nl 32 se 38 trq 2 be 8 croat 14 et 20 is 26 nl 32 se
3 bg 9 cz 15 fi 21 it 27 no 33 sg 39 ua 3 bg 9 cz 15 fi 21 it 27 no 33 sg 39 ua
4 br-a 10 de 16 fr 22 jp 28 pl 34 sk-y 40 uk 4 br-a 10 de 16 fr 22 jp 28 pl 34 sk-y 40 uk
5 br-l 11 dk 17 gr 23 la 29 pt 35 sk-z 41 us 5 br-l 11 dk 17 gr 23 la 29 pt 35 sk-z 41 us

390
defaults/keymaps/trq.map
Unescape View File

@ -1,390 +0,0 @@
/*
* test(1); version 7-like -- author Erik Baalbergen
* modified by Eric Gisin to be used as built-in.
* modified by Arnold Robbins to add SVR3 compatibility
* (-x -c -b -p -u -g -k) plus Korn's -L -nt -ot -ef and new -S (socket).
*/
static char *RCSid = "$Id: c_test.c,v 3.3 89/03/27 15:47:25 egisin Exp $";
#include <stddef.h>
/*#include <string.h>*/
#include <signal.h>
#include <errno.h>
#include <setjmp.h>
#include <sys/types.h>
#include <sys/stat.h>
#include "bltin.h"
/* test(1) accepts the following grammar:
oexpr ::= aexpr | aexpr "-o" oexpr ;
aexpr ::= nexpr | nexpr "-a" aexpr ;
nexpr ::= primary ! "!" primary
primary ::= unary-operator operand
| operand binary-operator operand
| operand
| "(" oexpr ")"
;
unary-operator ::= "-r"|"-w"|"-x"|"-f"|"-d"|"-c"|"-b"|"-p"|
"-u"|"-g"|"-k"|"-s"|"-t"|"-z"|"-n"|"-o"|"-O"|"-G"|"-L"|"-S";
binary-operator ::= "="|"!="|"-eq"|"-ne"|"-ge"|"-gt"|"-le"|"-lt"|
"-nt"|"-ot"|"-ef";
operand ::= <any legal UNIX file name>
*/
#define evaluate(x) getn(x)
#define errorf error
#define EOI 0
#define FILRD 1
#define FILWR 2
#define FILREG 3
#define FILID 4
#define FILGZ 5
#define FILTT 6
#define STZER 7
#define STNZE 8
#define STEQL 9
#define STNEQ 10
#define INTEQ 11
#define INTNE 12
#define INTGE 13
#define INTGT 14
#define INTLE 15
#define INTLT 16
#define UNOT 17
#define BAND 18
#define BOR 19
#define LPAREN 20
#define RPAREN 21
#define OPERAND 22
#define FILEX 23
#define FILCDEV 24
#define FILBDEV 25
#define FILFIFO 26
#define FILSETU 27
#define FILSETG 28
#define FILSTCK 29
#define FILSYM 30
#define FILNT 31
#define FILOT 32
#define FILEQ 33
#define FILSOCK 34
#define FILUID 35
#define FILGID 36
#define OPTION 37
#define UNOP 1
#define BINOP 2
#define BUNOP 3
#define BBINOP 4
#define PAREN 5
struct t_op {
char *op_text;
short op_num, op_type;
} const ops [] = {
{"-r", FILRD, UNOP},
{"-w", FILWR, UNOP},
{"-x", FILEX, UNOP},
{"-f", FILREG, UNOP},
{"-d", FILID, UNOP},
{"-c", FILCDEV,UNOP},
{"-b", FILBDEV,UNOP},
{"-p", FILFIFO,UNOP},
{"-u", FILSETU,UNOP},
{"-g", FILSETG,UNOP},
{"-k", FILSTCK,UNOP},
{"-s", FILGZ, UNOP},
{"-t", FILTT, UNOP},
{"-z", STZER, UNOP},
{"-n", STNZE, UNOP},
#if 0 /* conficts with binary -o */
{"-o", OPTION, UNOP},
#endif
{"-U", FILUID, UNOP},
{"-G", FILGID, UNOP},
{"-L", FILSYM, UNOP},
{"-S", FILSOCK,UNOP},
{"=", STEQL, BINOP},
{"!=", STNEQ, BINOP},
{"-eq", INTEQ, BINOP},
{"-ne", INTNE, BINOP},
{"-ge", INTGE, BINOP},
{"-gt", INTGT, BINOP},
{"-le", INTLE, BINOP},
{"-lt", INTLT, BINOP},
{"-nt", FILNT, BINOP},
{"-ot", FILOT, BINOP},
{"-ef", FILEQ, BINOP},
{"!", UNOT, BUNOP},
{"-a", BAND, BBINOP},
{"-o", BOR, BBINOP},
{"(", LPAREN, PAREN},
{")", RPAREN, PAREN},
{0, 0, 0}
};
char **t_wp;
struct t_op const *t_wp_op;
static void syntax();
int
testcmd(argc, wp)
char **wp;
{
int res;
t_wp = wp+1;
if (strcmp(wp[0], "[") == 0) {
while (*wp != NULL)
wp++;
if (strcmp(*--wp, "]") != 0)
errorf("[: missing ]");
*wp = NULL;
}
res = *t_wp == NULL || !oexpr(t_lex(*t_wp));
if (*t_wp != NULL && *++t_wp != NULL)
syntax(*t_wp, "unknown operand");
return res;
}
static void
syntax(op, msg)
char *op;
char *msg;
{
if (op && *op)
errorf("%s: %s", op, msg);
else
errorf("%s", msg);
}
oexpr(n)
{
int res;
res = aexpr(n);
if (t_lex(*++t_wp) == BOR)
return oexpr(t_lex(*++t_wp)) || res;
t_wp--;
return res;
}
aexpr(n)
{
int res;
res = nexpr(n);
if (t_lex(*++t_wp) == BAND)
return aexpr(t_lex(*++t_wp)) && res;
t_wp--;
return res;
}
nexpr(n)
int n; /* token */
{
if (n == UNOT)
return !nexpr(t_lex(*++t_wp));
return primary(n);
}
primary(n)
int n; /* token */
{
register char *opnd1, *opnd2;
int res;
if (n == EOI)
syntax(NULL, "argument expected");
if (n == LPAREN) {
res = oexpr(t_lex(*++t_wp));
if (t_lex(*++t_wp) != RPAREN)
syntax(NULL, "closing paren expected");
return res;
}
if (t_wp_op && t_wp_op->op_type == UNOP) {
/* unary expression */
if (*++t_wp == NULL && n != FILTT)
syntax(t_wp_op->op_text, "argument expected");
switch (n) {
/**
case OPTION:
return flag[option(*t_wp)];
**/
case STZER:
return strlen(*t_wp) == 0;
case STNZE:
return strlen(*t_wp) != 0;
case FILTT:
if (**t_wp < '0' || **t_wp > '9')
return filstat("0", n);
default: /* all other FIL* */
return filstat(*t_wp, n);
}
}
opnd1 = *t_wp;
(void) t_lex(*++t_wp);
if (t_wp_op && t_wp_op->op_type == BINOP) {
struct t_op const *op = t_wp_op;
if ((opnd2 = *++t_wp) == (char *)0)
syntax(op->op_text, "argument expected");
switch (op->op_num) {
case STEQL:
return strcmp(opnd1, opnd2) == 0;
case STNEQ:
return strcmp(opnd1, opnd2) != 0;
case INTEQ:
return evaluate(opnd1) == evaluate(opnd2);
case INTNE:
return evaluate(opnd1) != evaluate(opnd2);
case INTGE:
return evaluate(opnd1) >= evaluate(opnd2);
case INTGT:
return evaluate(opnd1) > evaluate(opnd2);
case INTLE:
return evaluate(opnd1) <= evaluate(opnd2);
case INTLT:
return evaluate(opnd1) < evaluate(opnd2);
case FILNT:
return newerf (opnd1, opnd2);
case FILOT:
return olderf (opnd1, opnd2);
case FILEQ:
return equalf (opnd1, opnd2);
}
}
t_wp--;
return strlen(opnd1) > 0;
}
filstat(nm, mode)
char *nm;
{
struct stat s;
switch (mode) {
case FILRD:
return access(nm, 4) == 0;
case FILWR:
return access(nm, 2) == 0;
case FILEX:
return access(nm, 1) == 0;
case FILREG:
return stat(nm, &s) == 0 && (s.st_mode & S_IFMT) == S_IFREG;
case FILID:
return stat(nm, &s) == 0 && (s.st_mode & S_IFMT) == S_IFDIR;
case FILCDEV:
return stat(nm, &s) == 0 && (s.st_mode & S_IFMT) == S_IFCHR;
case FILBDEV:
return stat(nm, &s) == 0 && (s.st_mode & S_IFMT) == S_IFBLK;
case FILFIFO:
#ifdef S_IFIFO
return stat(nm, &s) == 0 && (s.st_mode & S_IFMT) == S_IFIFO;
#else
return 0;
#endif
case FILSETU:
return stat(nm, &s) == 0 && (s.st_mode & S_ISUID) == S_ISUID;
case FILSETG:
return stat(nm, &s) == 0 && (s.st_mode & S_ISGID) == S_ISGID;
case FILSTCK:
return stat(nm, &s) == 0 && (s.st_mode & S_ISVTX) == S_ISVTX;
case FILGZ:
return stat(nm, &s) == 0 && s.st_size > 0L;
case FILTT:
return isatty(getn(nm));
case FILUID:
return stat(nm, &s) == 0 && s.st_uid == geteuid();
case FILGID:
return stat(nm, &s) == 0 && s.st_gid == getegid();
#ifdef S_IFLNK
case FILSYM:
return lstat(nm, &s) == 0 && (s.st_mode & S_IFMT) == S_IFLNK;
#endif
#ifdef S_IFSOCK
case FILSOCK:
return stat(nm, &s) == 0 && (s.st_mode & S_IFMT) == S_IFSOCK;
#endif
default:
return 1;
}
}
int
t_lex(s)
register char *s;
{
register struct t_op const *op = ops;
if (s == 0) {
t_wp_op = (struct t_op *)0;
return EOI;
}
while (op->op_text) {
if (strcmp(s, op->op_text) == 0) {
t_wp_op = op;
return op->op_num;
}
op++;
}
t_wp_op = (struct t_op *)0;
return OPERAND;
}
newerf (f1, f2)
char *f1, *f2;
{
struct stat b1, b2;
return (stat (f1, &b1) == 0 &&
stat (f2, &b2) == 0 &&
b1.st_mtime > b2.st_mtime);
}
olderf (f1, f2)
char *f1, *f2;
{
struct stat b1, b2;
return (stat (f1, &b1) == 0 &&
stat (f2, &b2) == 0 &&
b1.st_mtime < b2.st_mtime);
}
equalf (f1, f2)
char *f1, *f2;
{
struct stat b1, b2;
return (stat (f1, &b1) == 0 &&
stat (f2, &b2) == 0 &&
b1.st_dev == b2.st_dev &&
b1.st_ino == b2.st_ino);
}
/* atoi with error detection */
getn(as)
char *as;
{
register char *s;
register int n;
s = as;
if (*s == '-')
s++;
for (n = 0; *s >= '0' && *s <= '9'; s++)
n = (n*10) + (*s-'0');
if (*s)
errorf("%s: bad number", as);
return (*as == '-') ? -n : n;
}
Write Preview
Loading…
Cancel
Save