/*
* v_count --
* Return the next count.
*/
static int
v_count(
SCR *sp,
ARG_CHAR_T fkey,
u_long *countp)
{
EVENT ev;
u_long count, tc;
ev.e_c = fkey;
count = tc = 0;
do {
/*
* XXX
* Assume that overflow results in a smaller number.
*/
tc = count * 10 + ev.e_c - '0';
if (count > tc) {
/* Toss to the next non-digit. */
do {
if (v_key(sp, 0, &ev,
EC_MAPCOMMAND | EC_MAPNODIGIT) != GC_OK)
return (1);
} while (ISDIGIT(ev.e_c));
msgq(sp, M_ERR,
"235|Number larger than %lu", ULONG_MAX);
return (1);
}
count = tc;
if (v_key(sp, 0, &ev, EC_MAPCOMMAND | EC_MAPNODIGIT) != GC_OK)
return (1);
} while (ISDIGIT(ev.e_c));
*countp = count;
return (0);
}
int main(int argc, char *argv[])
{
if (argc > 3 || argc < 2) //Only accept one or two arguments, '-d' for decrypt should not come last
{
printf("Usage: %s [-d decrypt] KEY\n\tKEY is an alphabetical phrase.\n\tEncrypts stdin using a vigenere cipher.\n", argv[0]);
return 1;
}
char *key_in = argv[argc - 1]; //Take the last command line argument as key
char intext[MESSAGE_MAX_LENGTH];
fgets(intext, MESSAGE_MAX_LENGTH, stdin);
for (int i = 0, n = 0; i < strlen(intext); i++, n++)
{
if (n == strlen(argv[argc - 1]))
n = 0;
if (isalnum(intext[i]) == 0)
--n;
if (!strcmp(argv[1], "-d"))
printf("%c", caesar(v_key(argv[argc - 1][n], 1), intext[i]));
else
printf("%c", caesar(v_key(argv[argc - 1][n], 0), intext[i]));
}
}
void BehaviorNode::send_notify(const Variant& from, const StringName &key, const Variant& value) {
_on_notify(from, key, value);
if (get_script_instance()) {
Variant v_key(key);
const Variant* ptr[3]={&from, &v_key, &value};
get_script_instance()->call_multilevel(StringName("_on_notify"),ptr,3);
}
int count = get_child_count();
for (int i = 0; i < count; ++i) {
Node *node = get_child(i);
if (node) {
BehaviorNode *bn = node->cast_to<BehaviorNode>();
if (bn) {
bn->send_notify(from, key, value);
}
}
}
}
/*
* v_cmd --
*
* The command structure for vi is less complex than ex (and don't think
* I'm not grateful!) The command syntax is:
*
* [count] [buffer] [count] key [[motion] | [buffer] [character]]
*
* and there are several special cases. The motion value is itself a vi
* command, with the syntax:
*
* [count] key [character]
*/
static gcret_t
v_cmd(
SCR *sp,
VICMD *dp,
VICMD *vp,
VICMD *ismotion, /* Previous key if getting motion component. */
int *comcountp,
int *mappedp)
{
enum { COMMANDMODE, ISPARTIAL, NOTPARTIAL } cpart;
EVENT ev;
VIKEYS const *kp;
gcret_t gcret;
u_int flags;
CHAR_T key;
char *s;
/*
* Get a key.
*
* <escape> cancels partial commands, i.e. a command where at least
* one non-numeric character has been entered. Otherwise, it beeps
* the terminal.
*
* !!!
* POSIX 1003.2-1992 explicitly disallows cancelling commands where
* all that's been entered is a number, requiring that the terminal
* be alerted.
*/
cpart = ismotion == NULL ? COMMANDMODE : ISPARTIAL;
if ((gcret =
v_key(sp, ismotion == NULL, &ev, EC_MAPCOMMAND)) != GC_OK) {
if (gcret == GC_EVENT)
vp->ev = ev;
return (gcret);
}
if (ev.e_value == K_ESCAPE)
goto esc;
if (F_ISSET(&ev.e_ch, CH_MAPPED))
*mappedp = 1;
key = ev.e_c;
if (ismotion == NULL)
cpart = NOTPARTIAL;
/* Pick up an optional buffer. */
if (key == '"') {
cpart = ISPARTIAL;
if (ismotion != NULL) {
v_emsg(sp, NULL, VIM_COMBUF);
return (GC_ERR);
}
KEY(vp->buffer, 0);
F_SET(vp, VC_BUFFER);
KEY(key, EC_MAPCOMMAND);
}
/*
* Pick up an optional count, where a leading 0 is not a count,
* it's a command.
*/
if (ISDIGIT(key) && key != '0') {
if (v_count(sp, key, &vp->count))
return (GC_ERR);
F_SET(vp, VC_C1SET);
*comcountp = 1;
KEY(key, EC_MAPCOMMAND);
} else
*comcountp = 0;
/* Pick up optional buffer. */
if (key == '"') {
cpart = ISPARTIAL;
if (F_ISSET(vp, VC_BUFFER)) {
msgq(sp, M_ERR, "234|Only one buffer may be specified");
return (GC_ERR);
}
if (ismotion != NULL) {
v_emsg(sp, NULL, VIM_COMBUF);
return (GC_ERR);
}
KEY(vp->buffer, 0);
F_SET(vp, VC_BUFFER);
KEY(key, EC_MAPCOMMAND);
}
/* Check for an OOB command key. */
cpart = ISPARTIAL;
if (key > MAXVIKEY) {
v_emsg(sp, KEY_NAME(sp, key), VIM_NOCOM);
return (GC_ERR);
}
kp = &vikeys[vp->key = key];
/*
* !!!
* Historically, D accepted and then ignored a count. Match it.
*/
if (vp->key == 'D' && F_ISSET(vp, VC_C1SET)) {
*comcountp = 0;
vp->count = 0;
F_CLR(vp, VC_C1SET);
}
/* Check for command aliases. */
if (kp->func == NULL && (kp = v_alias(sp, vp, kp)) == NULL)
return (GC_ERR);
/* The tildeop option makes the ~ command take a motion. */
if (key == '~' && O_ISSET(sp, O_TILDEOP))
kp = &tmotion;
vp->kp = kp;
/*
* Find the command. The only legal command with no underlying
* function is dot. It's historic practice that <escape> doesn't
* just erase the preceding number, it beeps the terminal as well.
* It's a common problem, so just beep the terminal unless verbose
* was set.
*/
if (kp->func == NULL) {
if (key != '.') {
v_emsg(sp, KEY_NAME(sp, key),
ev.e_value == K_ESCAPE ? VIM_NOCOM_B : VIM_NOCOM);
return (GC_ERR);
}
/* If called for a motion command, stop now. */
if (dp == NULL)
goto usage;
/*
* !!!
* If a '.' is immediately entered after an undo command, we
* replay the log instead of redoing the last command. This
* is necessary because 'u' can't set the dot command -- see
* vi/v_undo.c:v_undo for details.
*/
if (VIP(sp)->u_ccnt == sp->ccnt) {
vp->kp = &vikeys['u'];
F_SET(vp, VC_ISDOT);
return (GC_OK);
}
/* Otherwise, a repeatable command must have been executed. */
if (!F_ISSET(dp, VC_ISDOT)) {
msgq(sp, M_ERR, "208|No command to repeat");
return (GC_ERR);
}
/* Set new count/buffer, if any, and return. */
if (F_ISSET(vp, VC_C1SET)) {
F_SET(dp, VC_C1SET);
dp->count = vp->count;
}
if (F_ISSET(vp, VC_BUFFER))
dp->buffer = vp->buffer;
*vp = *dp;
return (GC_OK);
}
/* Set the flags based on the command flags. */
flags = kp->flags;
/* Check for illegal count. */
if (F_ISSET(vp, VC_C1SET) && !LF_ISSET(V_CNT))
goto usage;
/* Illegal motion command. */
if (ismotion == NULL) {
/* Illegal buffer. */
if (!LF_ISSET(V_OBUF) && F_ISSET(vp, VC_BUFFER))
goto usage;
/* Required buffer. */
if (LF_ISSET(V_RBUF)) {
KEY(vp->buffer, 0);
F_SET(vp, VC_BUFFER);
}
}
/*
* Special case: '[', ']' and 'Z' commands. Doesn't the fact that
* the *single* characters don't mean anything but the *doubled*
* characters do, just frost your shorts?
*/
if (vp->key == '[' || vp->key == ']' || vp->key == 'Z') {
/*
* Historically, half entered [[, ]] or Z commands weren't
* cancelled by <escape>, the terminal was beeped instead.
* POSIX.2-1992 probably didn't notice, and requires that
* they be cancelled instead of beeping. Seems fine to me.
*
* Don't set the EC_MAPCOMMAND flag, apparently ] is a popular
* vi meta-character, and we don't want the user to wait while
* we time out a possible mapping. This *appears* to match
* historic vi practice, but with mapping characters, You Just
* Never Know.
*/
KEY(key, 0);
if (vp->key != key) {
usage: if (ismotion == NULL)
s = kp->usage;
else if (ismotion->key == '~' && O_ISSET(sp, O_TILDEOP))
s = tmotion.usage;
else
s = vikeys[ismotion->key].usage;
v_emsg(sp, s, VIM_USAGE);
return (GC_ERR);
}
}
/* Special case: 'z' command. */
if (vp->key == 'z') {
KEY(vp->character, 0);
if (ISDIGIT(vp->character)) {
if (v_count(sp, vp->character, &vp->count2))
return (GC_ERR);
F_SET(vp, VC_C2SET);
KEY(vp->character, 0);
}
}
/*
* Commands that have motion components can be doubled to imply the
* current line.
*/
if (ismotion != NULL && ismotion->key != key && !LF_ISSET(V_MOVE)) {
msgq(sp, M_ERR, "210|%s may not be used as a motion command",
KEY_NAME(sp, key));
return (GC_ERR);
}
/* Pick up required trailing character. */
if (LF_ISSET(V_CHAR))
KEY(vp->character, 0);
/* Get any associated cursor word. */
if (F_ISSET(kp, V_KEYW) && v_curword(sp))
return (GC_ERR);
return (GC_OK);
esc: switch (cpart) {
case COMMANDMODE:
msgq(sp, M_BERR, "211|Already in command mode");
return (GC_ERR_NOFLUSH);
case ISPARTIAL:
break;
case NOTPARTIAL:
(void)sp->gp->scr_bell(sp);
break;
}
return (GC_ERR);
}
