codelist_entry *process_dat(){
char *orig_line = get_rest_of_orig_line();
int len = strlen(orig_line);
char *buf = calloc(len - 3, sizeof(char));
//Take off the DAT and following space
strncpy(buf, orig_line + 4, len - 3);
trim(buf);
printf("Dat: %s\n", buf);
codelist_entry *entry = calloc(sizeof(codelist_entry), 1);
if(is_quoted_string(buf)){
get_data_from_quoted_string(buf, entry);
}else{
get_data_from_nums(buf, entry);
}
printf("Data: ");
for(int i = 0; i < entry->data_size; i++){
printf("0x%04x ", entry->data[i]);
}
printf("\n");
for(int i = 0; i < entry->data_size; i++){
unsigned short cur = entry->data[i];
printf("%c%c", (cur >> 8), (cur & 0xFF));
}
printf("\n");
return entry;
}
void Node_Value_Parser::handle_append_command(Command_Value& cv, Moldable* bc)
{
if (tm.current_token() != Mogu_Syntax::append) return;
Node_Value tmp {};
std::string str {};
uint8_t flags {cv.get_flags()};
int token {tm.current_token()};
bool preposition_found {false};
// This is used for checking unexpected input to see if it's actually
// supposed to be represented as an integer used as a list index.
bool check_if_list {false};
tm.next();
token = tm.current_token();
// Cycle through the input, testing flag combinations and setting
// things where appropriate, until we're out of tokens.
while (token != Mogu_Syntax::OUT_OF_RANGE_END)
{
// A string will either be a value or an identifier.
if (!preposition_found && Mogu_Syntax::location == token)
{
tm.next();
std::stringstream buf;
// append location user foo bar to self
while (token != Mogu_Syntax::preposition)
{
if (Mogu_Syntax::TOKEN_DELIM == token)
buf << tm.fetch_string();
else buf << tm.current_token();
buf << " ";
tm.next();
token = tm.current_token();
}
std::string in {buf.str()}; //user foo bar
Node_Value_Parser p {};
Command_Value c {*bc};
Node_Value v {};
p.set_user_id(user_id);
p.set_group_id(group_id);
p.give_input(in,v); //"widget baz bop"
in = stripquotes(v.get_string()); // widget baz bop
buf.str(std::string{});
buf << Mogu_Syntax::append.str << " " << in << " ";
while (token != Mogu_Syntax::OUT_OF_RANGE_END)
{
if (Mogu_Syntax::TOKEN_DELIM == token)
buf << tm.fetch_string();
else buf << tm.current_token();
buf << " ";
tm.next();
token = tm.current_token();
}
p.give_input(buf.str(),c,bc);
cv = c;
return;
}
if (Mogu_Syntax::TOKEN_DELIM == token)
{
str = tm.fetch_string();
tmp.set_string(str);
// If the only thing that has been set is the action,
// then the token delimiter will be a quoted string.
if ((flags == (uint8_t)Command_Flags::action) && is_quoted_string(str))
{
flags = cv.set(Command_Flags::value, tmp);
}
// If the r_object has been set, but there's no identifier,
// the next string encountered must be the identifier.
else if (cv.test(Command_Flags::r_object) &&
!cv.test(Command_Flags::r_identifier))
{
flags = cv.set(Command_Flags::r_identifier, tmp);
}
// Same as above, but for standard objects.
else if (cv.test(Command_Flags::object) &&
!cv.test(Command_Flags::identifier))
{
flags = cv.set(Command_Flags::identifier, tmp);
}
// In all other cases, this is unexpected input, but it might
// be a list index. 'continue' not present here because we want to
// keep moving through the decision tree.
else check_if_list = true;
}
// Object tokens will either be the object or r_object, depending
// on if it was reached before the preposition or not.
else if (is_object_token(token))
{
if (!preposition_found && !cv.test(Command_Flags::r_object))
{
flags = cv.set(Command_Flags::r_object, token);
if (token == Mogu_Syntax::user)
{ // The only instance where we have
// "append user to ..." is when we are
// appending a user to a group.
tm.next();
if (tm.current_token()==Mogu_Syntax::preposition)
{
handle_user_to_group(cv,bc);
break;
}
else
tm.prev();
}
}
else if (preposition_found && !cv.test(Command_Flags::object))
{
flags = cv.set(Command_Flags::object, token);
}
else
check_if_list = true;
// Do not continue.
}
else if (is_state_token(token))
{
tmp.set_int(token);
if (!preposition_found && !cv.test(Command_Flags::r_arg))
{
flags = cv.set(Command_Flags::r_arg, tmp);
}
else if (preposition_found && !cv.test(Command_Flags::arg))
{
flags = cv.set(Command_Flags::arg, token);
}
else
check_if_list = true;
}
else if (is_preposition_token(token))
{
preposition_found = true;
}
// This would be reached in the event of unexpected input.
// If the check_if_list flag is turned on, we're going to give the
// input the benefit of the doubt and see whether or not the previous
// token was a list token. If so, that's what this is. Otherwise,
// we're going to return without doing anything.
else if (check_if_list)
{
tm.prev();
if (Mogu_Syntax::list != tm.current_token())
return;
tm.next(); // Make sure to go back where we were in the input.
tmp.set_int((int) token);
if (!preposition_found && !cv.test(Command_Flags::r_arg))
{
cv.set(Command_Flags::r_arg, tmp);
}
else if (preposition_found && !cv.test(Command_Flags::arg))
{
cv.set(Command_Flags::arg, tmp);
}
// We have no clue what the hell this is.
else return;
}
tm.next();
token = tm.current_token();
} // end while loop
// After this, there is the possibility that we'll have a reduceable value
// with r_OBJ/r_ID/r_arg. If so, we'll go ahead and reduce that now:
if (cv.object_is_reduceable(true))
{
cv.reduce_object(true, bc);
}
}
