epicknex/DMS
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Characters worked on, working on enviroments.

Browse Source
This commit is contained in:
Ryan Ward 2020-09-30 00:02:46 -04:00
parent c6f9707d79
commit 9a49433e7e
24 changed files with 663 additions and 400 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
DMS/Character.h
View File

@ -6,9 +6,12 @@ namespace dms {
struct character { struct character {
std::string fname = ""; std::string fname = "";
std::string lname = ""; std::string lname = "";
std::string unknown = "Unknown";
std::string nickname = "";
bool seen = false; bool seen = false;
double spd = 100; double spd = 100;
std::unordered_map<std::string, std::string> paths; std::unordered_map<std::string, std::string> paths;
std::unordered_map<std::string, value*> values; std::unordered_map<std::string, value*> values;
std::string getName();
}; };
} }

4
DMS/DMS.cpp
View File

@ -1,11 +1,9 @@
#include "dms.h" #include "dms.h"
#include "Handlers.h"
#include "utils.h"
#include <iostream> #include <iostream>
using namespace dms; using namespace dms;
// You can use your own choice handler! // You can use your own choice handler!
class myHandler : public Handler { class myHandler : public Handler {
uint8_t manageChoice(dms_state* state, std::string prompt, std::vector<std::string> args) const override { uint8_t handleChoice(dms_state* state, std::string prompt, std::vector<std::string> args) const override {
std::string pos; std::string pos;
for (size_t i = 0; i < args.size(); i++) for (size_t i = 0; i < args.size(); i++)
std::cout << i << ": " << args[i] << std::endl; std::cout << i << ": " << args[i] << std::endl;

5
DMS/DMS.vcxproj
View File

@ -142,6 +142,8 @@
</Link> </Link>
</ItemDefinitionGroup> </ItemDefinitionGroup>
<ItemGroup> <ItemGroup>
<ClCompile Include="character.cpp" />
<ClCompile Include="enviroment.cpp" />
<ClCompile Include="Handlers.cpp" /> <ClCompile Include="Handlers.cpp" />
<ClCompile Include="chunk.cpp" /> <ClCompile Include="chunk.cpp" />
<ClCompile Include="cmd.cpp" /> <ClCompile Include="cmd.cpp" />
@ -160,7 +162,8 @@
<ClCompile Include="value.cpp" /> <ClCompile Include="value.cpp" />
</ItemGroup> </ItemGroup>
<ItemGroup> <ItemGroup>
<ClInclude Include="Character.h" /> <ClInclude Include="character.h" />
<ClInclude Include="enviroment.h" />
<ClInclude Include="Handlers.h" /> <ClInclude Include="Handlers.h" />
<ClInclude Include="chunk.h" /> <ClInclude Include="chunk.h" />
<ClInclude Include="cmd.h" /> <ClInclude Include="cmd.h" />

23
DMS/DMS.vcxproj.filters
View File

@ -19,6 +19,12 @@
<Filter Include="Source Files\DMS"> <Filter Include="Source Files\DMS">
<UniqueIdentifier>{e3410a7b-6408-4022-b606-2c14cfaac52c}</UniqueIdentifier> <UniqueIdentifier>{e3410a7b-6408-4022-b606-2c14cfaac52c}</UniqueIdentifier>
</Filter> </Filter>
<Filter Include="Header Files\DMS\blocks">
<UniqueIdentifier>{978b41cd-27e4-4b8c-874e-3b6e927b3d4d}</UniqueIdentifier>
</Filter>
<Filter Include="Source Files\DMS\blocks">
<UniqueIdentifier>{4c0bb4c5-388c-4f15-abb7-143cb6d6232f}</UniqueIdentifier>
</Filter>
</ItemGroup> </ItemGroup>
<ItemGroup> <ItemGroup>
<ClCompile Include="cmd.cpp"> <ClCompile Include="cmd.cpp">
@ -67,7 +73,13 @@
<Filter>Source Files\DMS</Filter> <Filter>Source Files\DMS</Filter>
</ClCompile> </ClCompile>
<ClCompile Include="Handlers.cpp"> <ClCompile Include="Handlers.cpp">
<Filter>Source Files</Filter> <Filter>Source Files\DMS</Filter>
</ClCompile>
<ClCompile Include="character.cpp">
<Filter>Source Files\DMS\blocks</Filter>
</ClCompile>
<ClCompile Include="enviroment.cpp">
<Filter>Source Files\DMS\blocks</Filter>
</ClCompile> </ClCompile>
</ItemGroup> </ItemGroup>
<ItemGroup> <ItemGroup>
@ -111,10 +123,13 @@
<Filter>Header Files\DMS</Filter> <Filter>Header Files\DMS</Filter>
</ClInclude> </ClInclude>
<ClInclude Include="Handlers.h"> <ClInclude Include="Handlers.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="Character.h">
<Filter>Header Files\DMS</Filter> <Filter>Header Files\DMS</Filter>
</ClInclude> </ClInclude>
<ClInclude Include="character.h">
<Filter>Header Files\DMS\blocks</Filter>
</ClInclude>
<ClInclude Include="enviroment.h">
<Filter>Header Files\DMS\blocks</Filter>
</ClInclude>
</ItemGroup> </ItemGroup>
</Project> </Project>

24
DMS/Handlers.cpp
View File

@ -1,6 +1,6 @@
#include "Handlers.h" #include "Handlers.h"
namespace dms { namespace dms {
uint8_t Handler::manageChoice(dms_state* state, std::string prompt, std::vector<std::string> args) const { uint8_t Handler::handleChoice(dms_state* state, std::string prompt, std::vector<std::string> args) const {
std::string pos; std::string pos;
for (size_t i = 0; i < args.size(); i++) for (size_t i = 0; i < args.size(); i++)
std::cout << i+1 << ": " << args[i] << std::endl; std::cout << i+1 << ": " << args[i] << std::endl;
@ -14,8 +14,28 @@ namespace dms {
} }
catch (std::exception e) { catch (std::exception e) {
std::cout << "Invalid Choice!" << std::endl; std::cout << "Invalid Choice!" << std::endl;
return manageChoice(state,prompt,args); return handleChoice(state,prompt,args);
}
}
bool Handler::handleSpeaker(dms_state* state, character* speaker) const {
if (speaker == nullptr)
return false; // Something went wrong and we pushed the error!
if (speaker->seen) {
if (speaker->lname != "") {
utils::write(speaker->fname, " ", speaker->lname, ": ");
}
else {
utils::write(speaker->fname, ": ");
}
}
else {
utils::write(speaker->unknown, ": ");
speaker->seen = true;
}
} }
// Simple one conn event
bool Handler::OnSpeakerCreated(dms_state* state, character* chara) const {
return true;
} }
} }

9
DMS/Handlers.h
View File

@ -1,13 +1,16 @@
#pragma once #pragma once
#include "value.h" #include "value.h"
#include "utils.h" #include "utils.h"
#include "Character.h" #include "character.h"
#include <iostream> #include <iostream>
namespace dms { namespace dms {
struct Handler struct Handler
{ {
virtual uint8_t manageChoice(dms_state* state, std::string prompt, std::vector<std::string> args) const; virtual uint8_t handleChoice(dms_state* state, std::string prompt, std::vector<std::string> args) const;
//virtual bool manageSpeaker(dms_state* state, character* chara) const; virtual bool handleSpeaker(dms_state* state, character* chara) const;
//virtual bool manageMessage(dms_state* state, value* msg) const; //virtual bool manageMessage(dms_state* state, value* msg) const;
// Simple Events: only one connector!
virtual bool OnSpeakerCreated(dms_state* state, character* chara) const;
}; };
} }

62
DMS/LineParserMatchProcess.cpp
View File

@ -146,6 +146,20 @@ namespace dms {
current_chunk->addCmd(new cmd{ codes::HALT }); current_chunk->addCmd(new cmd{ codes::HALT });
return true; return true;
} }
else if ((isBlock(bt_block) || isBlock(bt_method)) && stream->match(tokens::newline,tokens::pipe ,tokens::string, tokens::newline)) {
stream->next(); // Standard consumption
stream->next(); // pipe consumption
if (current_chunk->cmds.size() && current_chunk->cmds.back()->opcode == codes::HALT) {
current_chunk->cmds.pop_back();
}
std::string msg = stream->next().name;
cmd* c = new cmd;
c->opcode = codes::APND;
c->args.push(buildValue(concat(" ", msg)));
current_chunk->addCmd(c); // Add the cmd to the current chunk
current_chunk->addCmd(new cmd{ codes::HALT });
return true;
}
else if (isBlock(bt_character) && stream->match(tokens::newline, tokens::name, tokens::colon, tokens::string, tokens::newline)) { else if (isBlock(bt_character) && stream->match(tokens::newline, tokens::name, tokens::colon, tokens::string, tokens::newline)) {
stream->next(); // Standard consumption stream->next(); // Standard consumption
std::string name = stream->next().name; std::string name = stream->next().name;
@ -245,11 +259,6 @@ namespace dms {
current_chunk->addCmd(new cmd{ codes::HALT }); current_chunk->addCmd(new cmd{ codes::HALT });
return true; return true;
} }
// emotion: "path"
// looks like a simple disp command
else if (isBlock(bt_character) && stream->match(tokens::tab, tokens::name, tokens::colon, tokens::string, tokens::newline)) {
return true;
}
return false; return false;
} }
bool LineParser::match_process_assignment(tokenstream* stream) { bool LineParser::match_process_assignment(tokenstream* stream) {
@ -318,31 +327,18 @@ namespace dms {
The bytecode generated by this code might look something like this: The bytecode generated by this code might look something like this:
off op opcodes off op opcodes
0 CHOI "Pick one!" "Choice 1" "Choice 2" "Choice 3" "Choice 4" 0 CHOI "Pick one!" CHOI_filename_index "Choice 1" "Choice 2" "Choice 3" "Choice 4"
1 FUNC print "You picked 1!" 1 LABL CHOI_filename_1
2 GOTO $CHOI_END_1 2 FUNC print "You picked 1!"
3 FUNC print "You picked 2!" 3 GOTO $CHOI_END_1
4 GOTO $CHOI_END_1 4 LABL CHOI_filename_2
5 JUMP park 5 FUNC print "You picked 2!"
6 NOOP 6 GOTO $CHOI_END_1
7 GOTO mylabel 7 LABL CHOI_filename_3
8 LABL $CHOI_END_1 8 JUMP park
9 LABL CHOI_filename_4
The CHOI code tells the vm that we need to process user input. The input we get in a number 0-3 10 GOTO mylabel
I know we have 4 choices 11 LABL $CHOI_END_1
If the user provides us with a 0 then we need to move to off 1
If the user provides us with a 1 then we need to move to off 3
If the user provides us with a 2 then we need to move to off 5
If the user provides us with a 3 then we need to move to off 7
I'm sure you see the pattern here. 1 (+2) 3 (+2) 5... We only need to jump once then let the vm continue like normal.
The math for this is: [current_pos] + (n*2+1)
n*2+1 (n = 0) = 1
n*2+1 (n = 1) = 3
n*2+1 (n = 2) = 5
n*2+1 (n = 3) = 7
Which is why you see NOOP for the JUMP code. If GOTO wasn't the last choice possible to make there would be a NOOP after that as well.
The NOOP ensures the pattern stays.
If we are provided with a number greater than 3 then we can push an execption.
*/ */
while (!stream->match(tokens::cbracketc)) { while (!stream->match(tokens::cbracketc)) {
debugInvoker(stream); debugInvoker(stream);
@ -451,6 +447,10 @@ namespace dms {
tokenstream tempstream; tokenstream tempstream;
// This is a balanced consuming method (()(())) // This is a balanced consuming method (()(()))
std::vector<token> t = stream->next(tokens::parao, tokens::parac); // Consume and get tokens std::vector<token> t = stream->next(tokens::parao, tokens::parac); // Consume and get tokens
if (t.size() == 1) { // No arg function!
current_chunk->addCmd(c);
return true;
}
token end = t.back(); token end = t.back();
t.pop_back(); t.pop_back();
t.push_back(token{ tokens::seperator,codes::NOOP,"",t[0].line_num }); t.push_back(token{ tokens::seperator,codes::NOOP,"",t[0].line_num });
@ -548,7 +548,7 @@ namespace dms {
return false; return false;
} }
bool LineParser::match_process_jump(tokenstream* stream) { bool LineParser::match_process_jump(tokenstream* stream) {
if (stream->match(tokens::jump, tokens::name) || tokens::jump, tokens::string) { if (stream->match(tokens::jump, tokens::name) || stream->match(tokens::jump, tokens::string)) {
cmd* c = new cmd; cmd* c = new cmd;
c->opcode = codes::JUMP; c->opcode = codes::JUMP;
stream->next(); // consume jump stream->next(); // consume jump

49
DMS/LineParserParse.cpp
View File

@ -20,6 +20,11 @@ namespace dms {
return Parse(state, fn); return Parse(state, fn);
} }
dms_state* dms::LineParser::Parse(dms_state* state, std::string file) { dms_state* dms::LineParser::Parse(dms_state* state, std::string file) {
bool isFirst = false;
if (!state->hasFirst) {
isFirst = true;
state->hasFirst = true;
}
std::vector<token> t_vec; std::vector<token> t_vec;
std::string li; std::string li;
std::ifstream myfile(file); std::ifstream myfile(file);
@ -88,6 +93,10 @@ namespace dms {
buffer.push_back('"'); buffer.push_back('"');
stream.next(); stream.next();
} }
else if (data == '\\' && stream.peek() == 'n' && isStr) {
buffer.push_back('\n');
stream.next();
}
else if (data == '"' && isStr) { else if (data == '"' && isStr) {
isStr = false; isStr = false;
t_vec.push_back(token{ tokens::string,codes::NOOP,stream.processBuffer(buffer),line }); t_vec.push_back(token{ tokens::string,codes::NOOP,stream.processBuffer(buffer),line });
@ -199,6 +208,10 @@ namespace dms {
doCheck(&stream, &t_vec, line, isNum, hasDec, &buffer); doCheck(&stream, &t_vec, line, isNum, hasDec, &buffer);
t_vec.push_back(token{ tokens::backtick,codes::NOOP,"`",line }); t_vec.push_back(token{ tokens::backtick,codes::NOOP,"`",line });
} }
else if (data == '|') {
doCheck(&stream, &t_vec, line, isNum, hasDec, &buffer);
t_vec.push_back(token{ tokens::pipe,codes::NOOP,"|",line });
}
else if (data == '@') { else if (data == '@') {
doCheck(&stream, &t_vec, line, isNum, hasDec, &buffer); doCheck(&stream, &t_vec, line, isNum, hasDec, &buffer);
t_vec.push_back(token{ tokens::at,codes::NOOP,"@",line }); t_vec.push_back(token{ tokens::at,codes::NOOP,"@",line });
@ -307,6 +320,29 @@ namespace dms {
tokenDump(&t_vec); tokenDump(&t_vec);
// Tokens build let's parse // Tokens build let's parse
tokenizer(state, t_vec); tokenizer(state, t_vec);
if (isFirst) {
cmd* c = new cmd;
for (const auto& [key, val] : state->chunks) {
if (val->type == blocktype::bt_character) {
value* v = buildVariable();
v->set(buildString(key));
v->type = datatypes::block;
c->opcode = codes::ASGN;
c->args.push(buildVariable(key));
c->args.push(v);
state->chunks["$INIT"]->addCmd(c);
c = new cmd;
}
}
c->opcode = codes::JUMP;
if (state->entry != "$undefined")
c->args.push(buildValue(state->entry));
else
c->args.push(buildValue(state->chunks.begin()->first));
state->chunks["$INIT"]->addCmd(c);
}
return state; return state;
} }
void LineParser::tokenDump(std::vector<token>* v) { void LineParser::tokenDump(std::vector<token>* v) {
@ -338,6 +374,7 @@ namespace dms {
current_chunk->addCmd(c); current_chunk->addCmd(c);
} }
while (stream->peek().type != tokens::eof) { while (stream->peek().type != tokens::eof) {
//print(stream->peek());
debugInvoker(stream); debugInvoker(stream);
if (current.type == tokens::flag) { if (current.type == tokens::flag) {
temp = stream->next(tokens::newline); temp = stream->next(tokens::newline);
@ -381,10 +418,10 @@ namespace dms {
// TODO add usings, kinda useless atm since everything will be packed in. Perhaps extensions? // TODO add usings, kinda useless atm since everything will be packed in. Perhaps extensions?
} }
else if (code == codes::LOAD && tok == tokens::string) { else if (code == codes::LOAD && tok == tokens::string) {
flagcmd->opcode = code; /*flagcmd->opcode = code;
flagcmd->args.push(buildValue(temp[0].name)); flagcmd->args.push(buildValue(temp[0].name));
current_chunk->addCmd(flagcmd); current_chunk->addCmd(flagcmd);
flagcmd = new cmd; flagcmd = new cmd;*/
LineParser parser = LineParser(); LineParser parser = LineParser();
parser.Parse(state, temp[0].name);// Load another file parser.Parse(state, temp[0].name);// Load another file
} }
@ -470,17 +507,19 @@ namespace dms {
// This will probably be the toughest one of them all // This will probably be the toughest one of them all
} }
} }
// Display cmd must be first!!!
// Displays both with a target and without
match_process_disp(stream); // Match and process dialogue match_process_disp(stream); // Match and process dialogue
if (stream->match(tokens::newline,tokens::label)) { // Match and process labels if (stream->match(tokens::newline,tokens::label)) { // Match and process labels
stream->next(); stream->next();
buildLabel(stream->next().name); buildLabel(stream->next().name);
} }
match_process_function(stream); // Naked Function
match_process_assignment(stream); match_process_assignment(stream);
match_process_debug(stream); match_process_debug(stream);
match_process_goto(stream); match_process_goto(stream);
match_process_function(stream); // Naked Function
match_process_jump(stream);
current = stream->next(); current = stream->next();
} }
createBlock("$END", blocktype::bt_block);// Runs code that ensures that last user block is processed into the chunks array. Yes, I could have simply added in the lines of code at the end, but I didn't want to rewrite code again! createBlock("$END", blocktype::bt_block);// Runs code that ensures that last user block is processed into the chunks array. Yes, I could have simply added in the lines of code at the end, but I didn't want to rewrite code again!

12
DMS/LineParserUtils.cpp
View File

@ -230,7 +230,7 @@ namespace dms {
} }
} }
bool LineParser::createBlock(std::string bk_name, blocktype bk_type) { bool LineParser::createBlock(std::string bk_name, blocktype bk_type) {
if (current_chunk != nullptr) { if (current_chunk != nullptr || (bk_name == "$INIT" && state->chunks.count("$INIT"))) {
if (state->chunks.count(bk_name)==0 && bk_name!="$END") if (state->chunks.count(bk_name)==0 && bk_name!="$END")
state->push_chunk(current_chunk->name, current_chunk); state->push_chunk(current_chunk->name, current_chunk);
else else
@ -262,15 +262,6 @@ namespace dms {
c->args.push(buildValue(bk_name)); c->args.push(buildValue(bk_name));
current_chunk->addCmd(c); current_chunk->addCmd(c);
} }
if (current_chunk!= nullptr && current_chunk->name == "$INIT") {
cmd* c = new cmd;
c->opcode = codes::JUMP;
if(state->entry!="$undefined")
c->args.push(buildValue(state->entry));
else
c->args.push(buildValue(bk_name));
current_chunk->addCmd(c);
}
if (current_chunk != nullptr && current_chunk->name == "$END") { if (current_chunk != nullptr && current_chunk->name == "$END") {
cmd* c = new cmd; cmd* c = new cmd;
c->opcode = codes::EXIT; c->opcode = codes::EXIT;
@ -284,6 +275,7 @@ namespace dms {
current_chunk->name = bk_name; current_chunk->name = bk_name;
chunk_type = bk_type; chunk_type = bk_type;
current_chunk->type = bk_type; current_chunk->type = bk_type;
state->push_chunk(bk_name, current_chunk);
return true; return true;
} }
void LineParser::tokenizer(dms_state* state,std::vector<token> &toks) { void LineParser::tokenizer(dms_state* state,std::vector<token> &toks) {

18
DMS/character.cpp Normal file
View File

@ -0,0 +1,18 @@
#include "character.h"
#include "utils.h"
namespace dms {
std::string character::getName() {
if (nickname != "") {
return nickname;
}
if (seen && lname !="") {
return utils::concat(fname," ", lname);
}
else if (seen) {
return utils::concat(fname);
}
else {
return unknown;
}
}
}

2
DMS/dms.h
View File

@ -1,4 +1,6 @@
#pragma once #pragma once
#include "Handlers.h"
#include "character.h"
#include "chunk.h" #include "chunk.h"
#include "cmd.h" #include "cmd.h"
#include "codes.h" #include "codes.h"

17
DMS/dms_state.cpp
View File

@ -7,7 +7,7 @@ namespace dms {
enables.insert_or_assign("debugging",false); enables.insert_or_assign("debugging",false);
enables.insert_or_assign("warnings",false); // enables.insert_or_assign("warnings",false); //
enables.insert_or_assign("statesave",true); // Allows you to save state enables.insert_or_assign("statesave",true); // Allows you to save state
enables.insert_or_assign("omniscient",true); // Allows you to know who's who when you first meet them enables.insert_or_assign("omniscient",false); // Allows you to know who's who when you first meet them
chunk* c = new chunk; chunk* c = new chunk;
c->name = "$END"; c->name = "$END";
c->type = blocktype::bt_block; c->type = blocktype::bt_block;
@ -18,6 +18,13 @@ namespace dms {
push_chunk("$END", c); push_chunk("$END", c);
setHandler(new Handler); // Use the default implementation setHandler(new Handler); // Use the default implementation
} }
bool dms_state::typeAssert(value* val, datatypes type) {
if (val->type != type) {
push_error(errors::error{ errors::invalid_type ,utils::concat("Expected a ",datatype[type]," got a ",datatype[val->type],"!") });
return false;
}
return true;
}
bool dms_state::characterExists(std::string bk_name) { bool dms_state::characterExists(std::string bk_name) {
return (chunks.count(bk_name) && chunks[bk_name]->type == blocktype::bt_character); return (chunks.count(bk_name) && chunks[bk_name]->type == blocktype::bt_character);
} }
@ -65,10 +72,12 @@ namespace dms {
memory[var->s->getValue()] = val; memory[var->s->getValue()] = val;
} }
} }
void dms_state::dump() { void dms_state::dump(bool print) {
if (print)
std::cout << "Number of chunks: " << chunks.size() << std::endl; std::cout << "Number of chunks: " << chunks.size() << std::endl;
std::ofstream outputFile("dump.bin"); std::ofstream outputFile("dump.bin");
for (const auto& [key, val] : chunks) { for (const auto& [key, val] : chunks) {
if(print)
std::cout << "Key: " << key << "<" << getBlockType(val->type) << ">" << std::endl << *val << std::endl; std::cout << "Key: " << key << "<" << getBlockType(val->type) << ">" << std::endl << *val << std::endl;
outputFile << "Key: " << key << "<" << getBlockType(val->type) << ">" << std::endl << *val << std::endl; outputFile << "Key: " << key << "<" << getBlockType(val->type) << ">" << std::endl << *val << std::endl;
} }
@ -90,7 +99,9 @@ namespace dms {
} }
void dms_state::push_warning(errors::error err) { void dms_state::push_warning(errors::error err) {
err.crash = false; // Force code to not crash then push the error err.crash = false; // Force code to not crash then push the error
if(isEnabled("warnings")) if (isEnabled("warnings")) {
err.err_msg = utils::concat("Warning: ", err.err_msg);
push_error(err); push_error(err);
} }
} }
}

9
DMS/dms_state.h
View File

@ -16,6 +16,7 @@ namespace dms {
struct dms_state struct dms_state
{ {
void* handler = nullptr; void* handler = nullptr;
bool hasFirst = false;
std::unordered_map<std::string, value*> memory; std::unordered_map<std::string, value*> memory;
std::vector<value*> garbage; std::vector<value*> garbage;
std::map<std::string, chunk*> chunks; std::map<std::string, chunk*> chunks;
@ -25,13 +26,13 @@ namespace dms {
std::map<std::string, bool> enables; std::map<std::string, bool> enables;
std::size_t cur_line=0; std::size_t cur_line=0;
const double Iversion = 1.0; const double Iversion = 1.0;
double Cversion; // The version of double Sversion; // The version of
errors::error err; errors::error err;
bool stop = false; bool stop = false;
dms_state(); dms_state();
void dump(errors::error err); void dump(errors::error err);
void dump(); void dump(bool print=false);
void push_error(errors::error err); void push_error(errors::error err);
void push_warning(errors::error err); void push_warning(errors::error err);
void push_chunk(std::string s, chunk* c); void push_chunk(std::string s, chunk* c);
@ -43,11 +44,13 @@ namespace dms {
void setHandler(void* hand); void setHandler(void* hand);
// Gets or creates a character // Gets or creates a character
character* getCharacter(std::string c);
bool assign(value* var, value* val); bool assign(value* var, value* val);
size_t seek(std::string label,std::vector<cmd*> cmds ,codes::op code, size_t pos); size_t seek(std::string label,std::vector<cmd*> cmds ,codes::op code, size_t pos);
character* getCharacter(std::string c);
bool characterExists(std::string bk_name); bool characterExists(std::string bk_name);
bool blockExists(std::string bk_name); bool blockExists(std::string bk_name);
bool typeAssert(value* val, datatypes type);
bool run(); bool run();
private: private:
// From what I gathered // From what I gathered

61
DMS/dms_state_interpret.cpp
View File

@ -2,6 +2,7 @@
#include "utils.h" #include "utils.h"
#include "Handlers.h" #include "Handlers.h"
#include <iostream> #include <iostream>
#include <chrono>
using namespace dms::utils; using namespace dms::utils;
using namespace dms::exceptions; using namespace dms::exceptions;
using namespace dms::codes; using namespace dms::codes;
@ -25,6 +26,12 @@ namespace dms {
size_t max = 0; size_t max = 0;
std::vector<cmd*> cmds; std::vector<cmd*> cmds;
init(chunks[cha], pos, max, cmds); init(chunks[cha], pos, max, cmds);
if (isEnabled("omniscient")) {
cc->seen = true;
}
else {
cc->seen = false;
}
while (true) { while (true) {
c = cmds[pos++]; c = cmds[pos++];
code = c->opcode; code = c->opcode;
@ -40,11 +47,25 @@ namespace dms {
break; break;
case ASGN: case ASGN:
if (c->args.args[0]->s->getValue() == "fname") { if (c->args.args[0]->s->getValue() == "fname") {
if(!typeAssert(c->args.args[1],datatypes::string))
return nullptr;
cc->fname = c->args.args[1]->s->getValue(); cc->fname = c->args.args[1]->s->getValue();
} }
else if (c->args.args[0]->s->getValue() == "lname") { else if (c->args.args[0]->s->getValue() == "lname" && c->args.args[1]->type == datatypes::string) {
if (!typeAssert(c->args.args[1], datatypes::string))
return nullptr;
cc->lname = c->args.args[1]->s->getValue(); cc->lname = c->args.args[1]->s->getValue();
} }
else if (c->args.args[0]->s->getValue() == "unknown" && c->args.args[1]->type == datatypes::string) {
if (!typeAssert(c->args.args[1], datatypes::string))
return nullptr;
cc->unknown = c->args.args[1]->s->getValue();
}
else if (c->args.args[0]->s->getValue() == "known" && c->args.args[1]->type == datatypes::boolean) {
if (!typeAssert(c->args.args[1], datatypes::boolean))
return nullptr;
cc->seen = c->args.args[1]->b->getValue();
}
else { else {
cc->values.insert_or_assign(c->args.args[0]->s->getValue(), c->args.args[1]); cc->values.insert_or_assign(c->args.args[0]->s->getValue(), c->args.args[1]);
} }
@ -58,6 +79,9 @@ namespace dms {
break; break;
} }
} }
characters.insert_or_assign(cha, cc);
// Call Character event!
(*(Handler*)handler).OnSpeakerCreated(this,cc);
return cc; return cc;
} }
else { else {
@ -125,7 +149,17 @@ namespace dms {
// Nothing needs to be done here // Nothing needs to be done here
break; break;
case VERN: case VERN:
Cversion = c->args.args[0]->n->getValue(); Sversion = c->args.args[0]->n->getValue();
// Version X.xx
// X: Will not guarantee compatibality. Code breaking changes should be expected especially on lower versions
// xx: Will not break compatibality. They may add features as it goes up the ranks, but those changes do not break older code. If they do they will increase the X part and not the xx part
if (Sversion > Iversion) {
push_error(errors::error{errors::incompatible_version ,"This script was made for a later version of this interperter!"});
return false;
}
else if ((int)Iversion > (int)(Sversion)) {
push_warning(errors::error{ errors::incompatible_version ,"This script was made for an older version of this interperter, some features might not work!" });
}
break; break;
case USIN: case USIN:
// How we add modules into the code. This is the code that actually loads that data! // How we add modules into the code. This is the code that actually loads that data!
@ -149,6 +183,8 @@ namespace dms {
break; break;
case HALT: case HALT:
//wait(); //wait();
std::this_thread::sleep_for(std::chrono::milliseconds(700));
std::cout << std::endl;
break; break;
case DSPD: case DSPD:
if (speaker == nullptr) { if (speaker == nullptr) {
@ -160,21 +196,22 @@ namespace dms {
} }
break; break;
case SSPK: case SSPK:
//Because we are using void* we must cast our pointers
if (characterExists(c->args.args[0]->s->getValue())){ if (characterExists(c->args.args[0]->s->getValue())){
speaker = getCharacter(c->args.args[0]->s->getValue()); speaker = getCharacter(c->args.args[0]->s->getValue());
if (speaker->lname != "") { if (!(*(Handler*)handler).handleSpeaker(this, speaker))
utils::write(speaker->fname, " ", speaker->lname, ": "); return false;
} }
else { else {
utils::write(speaker->fname, ": "); push_error(errors::error{ errors::disp_unknown,concat("Unknown character '",c->args.args[0]->s->getValue(),"'!")});
} return false;
} }
break; break;
case APND: case APND:
utils::write(c->args.args[0]->s->getValue()); utils::write(c->args.args[0]->s->getValue(this));
break; break;
case DISP: case DISP:
utils::write(c->args.args[0]->s->getValue()); utils::write(c->args.args[0]->s->getValue(this));
break; break;
case ASGN: case ASGN:
assign(c->args.args[0], c->args.args[1]); assign(c->args.args[0], c->args.args[1]);
@ -186,24 +223,20 @@ namespace dms {
break; break;
case CHOI: case CHOI:
//Because we are using void* we must cast our pointers //Because we are using void* we must cast our pointers
//The implementation of this however should mean that you only ever have to deal with one "ChoiceHandler. One annoying void*"
{ {
std::vector<std::string> args; std::vector<std::string> args;
std::string prompt = c->args.args[0]->s->getValue(); std::string prompt = c->args.args[0]->s->getValue();
std::string fn = c->args.args[1]->s->getValue(); std::string fn = c->args.args[1]->s->getValue();
for (size_t i = 2; i < c->args.args.size(); i++) for (size_t i = 2; i < c->args.args.size(); i++)
args.push_back(c->args.args[i]->resolve(memory)->s->getValue()); args.push_back(c->args.args[i]->resolve(memory)->s->getValue());
size_t npos = (*(Handler*)handler).manageChoice(this, prompt, args); size_t npos = (*(Handler*)handler).handleChoice(this, prompt, args);
print("CHOI_", fn, "_", npos);
size_t nnpos = seek(concat("CHOI_", fn, "_", npos),cmds,LABL,npos); size_t nnpos = seek(concat("CHOI_", fn, "_", npos),cmds,LABL,npos);
if (!nnpos) { if (!nnpos) {
push_error(errors::error{ errors::choice_unknown ,utils::concat("Unknown choice!") }); push_error(errors::error{ errors::choice_unknown ,utils::concat("Unknown choice!") });
return false; return false;
} }
else { else {
print(nnpos);
pos = nnpos; pos = nnpos;
wait();
} }
} }
break; break;
@ -225,7 +258,7 @@ namespace dms {
} }
else { else {
datatypes set = c->args.args[0]->resolve(memory)->type; datatypes set = c->args.args[0]->resolve(memory)->type;
push_error(errors::error{ errors::invalid_arguments, utils::concat("String expected got ",set), true,ln }); push_error(errors::error{ errors::invalid_arguments, utils::concat("String expected got ",datatype[set]), true,ln });
return false; return false;
} }
break; break;

BIN
DMS/dump.bin
View File

Binary file not shown.

528
DMS/dump.txt
View File

@ -4,9 +4,6 @@ Line <1> newline
Line <1> flag Line <1> flag
Line <1> name main Line <1> name main
Line <1> newline Line <1> newline
Line <2> flag
Line <2> name warnings
Line <2> newline
Line <2> newline Line <2> newline
Line <3> flag Line <3> flag
Line <3> name omniscient Line <3> name omniscient
@ -16,352 +13,305 @@ Line <4> flag
Line <4> name forseelabels Line <4> name forseelabels
Line <4> newline Line <4> newline
Line <4> newline Line <4> newline
Line <5> flag
Line <5> name savestate
Line <5> newline
Line <5> newline Line <5> newline
Line <6> newline Line <6> newline
Line <7> flag
Line <7> string loadtest.dms
Line <7> newline
Line <7> newline Line <7> newline
Line <8> flag Line <8> flag
Line <8> number 1.2 Line <8> string loadtest.dms
Line <8> newline Line <8> newline
Line <8> newline Line <8> newline
Line <9> flag Line <9> flag
Line <9> name extendedDefine Line <9> number 0.2
Line <9> newline Line <9> newline
Line <9> newline Line <9> newline
Line <10> flag
Line <10> name extendedDefine
Line <10> newline Line <10> newline
Line <10> newline Line <10> newline
Line <11> bracketo [
Line <11> name main
Line <11> bracketc ]
Line <11> newline Line <11> newline
Line <11> newline Line <11> newline
Line <12> string why Line <12> bracketo [
Line <12> name main
Line <12> bracketc ]
Line <12> newline Line <12> newline
Line <12> newline Line <12> newline
Line <13> name works Line <13> string why
Line <13> equal =
Line <13> true true
Line <13> newline Line <13> newline
Line <13> newline Line <13> newline
Line <14> jump
Line <14> name Bob Line <14> name Bob
Line <14> newline
Line <14> newline
Line <15> string Testing
Line <15> newline
Line <15> newline
Line <16> name Bob
Line <16> colon :
Line <16> cbracketo {
Line <16> newline
Line <16> newline
Line <17> name speed
Line <17> number 50
Line <17> newline
Line <17> newline
Line <18> name excited
Line <18> colon :
Line <18> string Hello Ryan!
Line <18> newline
Line <18> newline
Line <19> name wait
Line <19> number 200
Line <19> newline
Line <19> newline
Line <20> string How are you doing?
Line <20> newline
Line <20> newline
Line <21> cbracketc }
Line <21> newline
Line <21> newline
Line <22> newline
Line <22> newline
Line <23> name Ryan
Line <23> colon :
Line <23> cbracketo {
Line <23> newline
Line <23> newline
Line <24> string Hey Bob I'm good how are you?
Line <24> newline
Line <24> newline
Line <25> cbracketc }
Line <25> newline
Line <25> newline
Line <26> name Bob
Line <26> colon :
Line <26> string Testing...
Line <26> newline
Line <26> newline
Line <27> newline
Line <27> newline
Line <28> control
Line <28> string What do you want to do?
Line <28> cbracketo {
Line <28> newline
Line <28> newline
Line <29> string option 1
Line <29> name test2
Line <29> parao (
Line <29> string testing
Line <29> seperator ,
Line <29> cbracketo {
Line <29> number 1
Line <29> seperator ,
Line <29> number 2
Line <29> seperator ,
Line <29> number 3
Line <29> cbracketc }
Line <29> parac )
Line <29> newline
Line <29> newline
Line <30> string option 2
Line <30> jump
Line <30> string test
Line <30> newline
Line <30> newline
Line <31> string option 3
Line <31> jump
Line <31> name there
Line <31> newline
Line <31> newline
Line <32> string option 4
Line <32> gotoo
Line <32> string o3
Line <32> newline
Line <32> newline
Line <33> string option 5
Line <33> gotoo
Line <33> name here
Line <33> newline
Line <33> newline
Line <34> string option 6
Line <34> name test
Line <34> parao (
Line <34> string here
Line <34> parac )
Line <34> newline
Line <34> newline
Line <35> cbracketc }
Line <35> newline
Line <35> newline
Line <36> newline
Line <36> newline
Line <37> bracketo [
Line <37> name test
Line <37> bracketc ]
Line <37> newline
Line <37> newline
Line <38> name Ryan
Line <38> colon :
Line <38> string We are here now!
Line <38> newline
Line <38> newline
Line <39> string hehe
Line <39> newline
Line <39> newline
Line <40> newline
Line <40> newline
Line <41> bracketo [
Line <41> name Bob
Line <41> colon :
Line <41> name char
Line <41> bracketc ]
Line <41> newline
Line <41> newline
Line <42> name fname
Line <42> equal =
Line <42> string Bob
Line <42> newline
Line <42> newline
Line <43> newline
Line <44> name age
Line <44> equal =
Line <44> number 0.24
Line <44> newline
Line <44> newline
Line <45> name money
Line <45> equal =
Line <45> number 100
Line <45> newline
Line <45> newline
Line <46> name excited
Line <46> colon :
Line <46> string path/to/file
Line <46> newline
Line <46> newline
Line <47> newline
Line <47> newline
Line <48> bracketo [
Line <48> name newblock
Line <48> colon :
Line <48> name function
Line <48> parao (
Line <48> parac )
Line <48> bracketc ]
Line <48> newline
Line <48> newline
Line <49> string Test #2
Line <49> newline
Line <49> newline
Line <50> string Does it parse this part properly?
Line <50> newline
Line <50> newline
Line <51> string huh
Line <51> newline
Line <51> newline
Line <51> eof
Line <1> newline
Line <1> newline
Line <1> bracketo [
Line <1> name default
Line <1> colon :
Line <1> name char
Line <1> bracketc ]
Line <1> newline
Line <1> newline
Line <2> newline
Line <3> name money
Line <3> equal =
Line <3> number 0
Line <3> newline
Line <3> newline
Line <4> name test
Line <4> equal =
Line <4> nil nil
Line <4> newline
Line <4> newline
Line <5> newline
Line <5> newline
Line <6> bracketo [
Line <6> name Ryan
Line <6> colon :
Line <6> name char
Line <6> bracketc ]
Line <6> newline
Line <6> newline
Line <7> name age
Line <7> equal =
Line <7> number 21
Line <7> newline
Line <7> newline
Line <8> name money
Line <8> equal =
Line <8> number 1000
Line <8> newline
Line <8> newline
Line <9> name lname
Line <9> equal =
Line <9> string Ward
Line <9> newline
Line <9> newline
Line <10> newline
Line <11> name calm
Line <11> colon :
Line <11> string ./path/to/file
Line <11> newline
Line <11> newline
Line <12> name excited
Line <12> colon :
Line <12> string ./path/to/file
Line <12> newline
Line <12> newline
Line <13> newline
Line <13> newline
Line <14> bracketo [
Line <14> name step
Line <14> colon : Line <14> colon :
Line <14> name function Line <14> cbracketo {
Line <14> parao (
Line <14> name a
Line <14> seperator ,
Line <14> name b
Line <14> seperator ,
Line <14> name c
Line <14> parac )
Line <14> bracketc ]
Line <14> newline Line <14> newline
Line <14> newline Line <14> newline
Line <15> string Testing... Line <15> name speed
Line <15> number 50
Line <15> newline Line <15> newline
Line <16> name d Line <15> newline
Line <16> equal = Line <16> name excited
Line <16> parao ( Line <16> colon :
Line <16> number 100 Line <16> string Hello `Ryan:fname`!
Line <16> plus +
Line <16> name b
Line <16> parac )
Line <16> divide /
Line <16> name c
Line <16> newline Line <16> newline
Line <16> newline Line <16> newline
Line <17> name e Line <17> name wait
Line <17> equal = Line <17> number 200
Line <17> string somestring
Line <17> newline Line <17> newline
Line <17> newline Line <17> newline
Line <18> name e Line <18> string How are you doing? I hear you have $`Ryan:money` in your account, nice!
Line <18> equal =
Line <18> nil nil
Line <18> newline Line <18> newline
Line <18> newline Line <18> newline
Line <19> name g Line <19> cbracketc }
Line <19> newline
Line <19> newline
Line <20> newline
Line <20> newline
Line <21> name Ryan
Line <21> colon :
Line <21> cbracketo {
Line <21> newline
Line <21> newline
Line <22> string Hey Bob I'm good how are you?
Line <22> newline
Line <22> newline
Line <23> cbracketc }
Line <23> newline
Line <23> newline
Line <24> newline
Line <24> newline
Line <25> name Bob
Line <25> colon :
Line <25> string I am great thanks!
Line <25> newline
Line <25> newline
Line <26> newline
Line <26> newline
Line <27> control
Line <27> string What do you want to do?
Line <27> cbracketo {
Line <27> newline
Line <27> newline
Line <28> string option 1
Line <28> name test2
Line <28> parao (
Line <28> string testing
Line <28> seperator ,
Line <28> cbracketo {
Line <28> number 1
Line <28> seperator ,
Line <28> number 2
Line <28> seperator ,
Line <28> number 3
Line <28> cbracketc }
Line <28> parac )
Line <28> newline
Line <28> newline
Line <29> string option 2
Line <29> jump
Line <29> string test
Line <29> newline
Line <29> newline
Line <30> string option 3
Line <30> jump
Line <30> name there
Line <30> newline
Line <30> newline
Line <31> string option 4
Line <31> gotoo
Line <31> string o3
Line <31> newline
Line <31> newline
Line <32> string option 5
Line <32> gotoo
Line <32> name here
Line <32> newline
Line <32> newline
Line <33> string option 6
Line <33> name test
Line <33> parao (
Line <33> string here
Line <33> parac )
Line <33> newline
Line <33> newline
Line <34> cbracketc }
Line <34> newline
Line <34> newline
Line <35> newline
Line <35> newline
Line <36> bracketo [
Line <36> name test
Line <36> bracketc ]
Line <36> newline
Line <36> newline
Line <37> name Ryan
Line <37> colon :
Line <37> string We are here now!
Line <37> newline
Line <37> newline
Line <38> Line <1> newline
Line <1> newline
Line <1> flag
Line <1> name tests
Line <1> newline
Line <1> newline
Line <2> flag
Line <2> name hello
Line <2> newline
Line <2> newline
Line <3> bracketo [
Line <3> name default
Line <3> colon :
Line <3> name char
Line <3> bracketc ]
Line <3> newline
Line <3> newline
Line <4> newline
Line <5> name money
Line <5> equal =
Line <5> number 0
Line <5> newline
Line <5> newline
Line <6> name test
Line <6> equal =
Line <6> nil nil
Line <6> newline
Line <6> newline
Line <7> newline
Line <7> newline
Line <8> bracketo [
Line <8> name Ryan
Line <8> colon :
Line <8> name char
Line <8> bracketc ]
Line <8> newline
Line <8> newline
Line <9> name age
Line <9> equal =
Line <9> number 21
Line <9> newline
Line <9> newline
Line <10> name money
Line <10> equal =
Line <10> number 1000
Line <10> newline
Line <10> newline
Line <11> name lname
Line <11> equal =
Line <11> string Ward
Line <11> newline
Line <11> newline
Line <12> name known
Line <12> equal =
Line <12> true true
Line <12> newline
Line <12> newline
Line <13> newline
Line <14> name calm
Line <14> colon :
Line <14> string ./path/to/file
Line <14> newline
Line <14> newline
Line <15> name excited
Line <15> colon :
Line <15> string ./path/to/file
Line <15> newline
Line <15> newline
Line <16> newline
Line <16> newline
Line <17> bracketo [
Line <17> name step
Line <17> colon :
Line <17> name function
Line <17> parao (
Line <17> name a
Line <17> seperator ,
Line <17> name b
Line <17> seperator ,
Line <17> name c
Line <17> parac )
Line <17> bracketc ]
Line <17> newline
Line <17> newline
Line <18> string Testing...
Line <18> newline
Line <19> name d
Line <19> equal = Line <19> equal =
Line <19> false false Line <19> parao (
Line <19> number 100
Line <19> plus +
Line <19> name b
Line <19> parac )
Line <19> divide /
Line <19> name c
Line <19> newline Line <19> newline
Line <19> newline Line <19> newline
Line <20> ret Line <20> name e
Line <20> name d Line <20> equal =
Line <20> string somestring
Line <20> newline Line <20> newline
Line <20> newline Line <20> newline
Line <21> name e
Line <21> equal =
Line <21> nil nil
Line <21> newline Line <21> newline
Line <21> newline Line <21> newline
Line <22> bracketo [ Line <22> name g
Line <22> name inventory Line <22> equal =
Line <22> colon : Line <22> false false
Line <22> name env
Line <22> bracketc ]
Line <22> newline Line <22> newline
Line <22> newline Line <22> newline
Line <23> name slot1 Line <23> ret
Line <23> equal = Line <23> name d
Line <23> string
Line <23> newline Line <23> newline
Line <23> newline Line <23> newline
Line <24> name slot2
Line <24> equal =
Line <24> string
Line <24> newline Line <24> newline
Line <24> newline Line <24> newline
Line <25> name slot3 Line <25> bracketo [
Line <25> equal = Line <25> name inventory
Line <25> string Line <25> colon :
Line <25> name env
Line <25> bracketc ]
Line <25> newline Line <25> newline
Line <25> newline Line <25> newline
Line <26> name slot4 Line <26> name slot1
Line <26> equal = Line <26> equal =
Line <26> string Line <26> string
Line <26> newline Line <26> newline
Line <26> newline Line <26> newline
Line <27> name slot5 Line <27> name slot2
Line <27> equal = Line <27> equal =
Line <27> string Line <27> string
Line <27> newline Line <27> newline
Line <27> newline Line <27> newline
Line <28> name slot6 Line <28> name slot3
Line <28> equal = Line <28> equal =
Line <28> string Line <28> string
Line <28> newline Line <28> newline
Line <28> newline Line <28> newline
Line <29> name slot7 Line <29> name slot4
Line <29> equal = Line <29> equal =
Line <29> string Line <29> string
Line <29> newline Line <29> newline
Line <29> newline Line <29> newline
Line <30> name slot8 Line <30> name slot5
Line <30> equal = Line <30> equal =
Line <30> string Line <30> string
Line <30> newline Line <30> newline
Line <30> newline Line <30> newline
Line <30> eof Line <31> name slot6
Line <31> equal =
Line <31> string
Line <31> newline
Line <31> newline
Line <32> name slot7
Line <32> equal =
Line <32> string
Line <32> newline
Line <32> newline
Line <33> name slot8
Line <33> equal =
Line <33> string
Line <33> newline
Line <33> newline
Line <33> eof

12
DMS/enviroment.cpp Normal file
View File

@ -0,0 +1,12 @@
#include "enviroment.h"
namespace dms {
bool enviroment::has(std::string index) {
return values.count(index);
}
void enviroment::set(std::string index, value* val) {
values.insert_or_assign(index,val);
}
value* enviroment::get(std::string index) {
return values[index];
}
}

13
DMS/enviroment.h Normal file
View File

@ -0,0 +1,13 @@
#pragma once
#include <string>
#include <unordered_map>
#include "value.h"
namespace dms {
struct enviroment {
std::string name="";
std::unordered_map<std::string, value*> values;
bool has(std::string index);
void set(std::string index, value* val);
value* get(std::string index);
};
}

3
DMS/errors.h
View File

@ -13,7 +13,8 @@ namespace dms::errors {
choice_unknown, choice_unknown,
nested_function, nested_function,
disp_unknown, disp_unknown,
non_existing_block non_existing_block,
incompatible_version
}; };
struct error { struct error {
errortype code=unknown; errortype code=unknown;

19
DMS/loadtest.dms
View File

@ -1,3 +1,5 @@
enable tests
disable hello
[default:char] [default:char]
// The default stats for all characters. // The default stats for all characters.
money = 0 money = 0
@ -7,6 +9,7 @@
age = 21 age = 21
money = 1000 money = 1000
lname = "Ward" lname = "Ward"
known = true
// Inside a character block this syntax defines animation/image file for an emotion // Inside a character block this syntax defines animation/image file for an emotion
calm: "./path/to/file" calm: "./path/to/file"
excited: "./path/to/file" excited: "./path/to/file"
@ -20,11 +23,11 @@
return d return d
[inventory:env] [inventory:env]
slot1 = "" slot1 = "S1"
slot2 = "" slot2 = "S2"
slot3 = "" slot3 = "S3"
slot4 = "" slot4 = "S4"
slot5 = "" slot5 = "S5"
slot6 = "" slot6 = "S6"
slot7 = "" slot7 = "S7"
slot8 = "" slot8 = "S8"

24
DMS/test.dms
View File

@ -1,29 +1,28 @@
entry main // Will either start the first block seen or the block supplied by you! entry main // Will either start the first block seen or the block supplied by you!
enable warnings //enable warnings
disable omniscient disable omniscient
enable forseelabels enable forseelabels
enable savestate
//enable leaking //enable leaking
//enable debugging //enable debugging
loadfile "loadtest.dms" loadfile "loadtest.dms"
version 1.2 version 0.2
using extendedDefine using extendedDefine
[main] [main]
"why" "why"
works = true
jump Bob
"Testing"
Bob: { Bob: {
speed 50 speed 50
excited: "Hello Ryan! " excited: "Hello `Ryan:fname`! "
wait 200 wait 200
"How are you doing?" "How are you doing? I hear you have $`Ryan:money` in your account, nice!"
} }
Ryan: { Ryan: {
"Hey Bob I'm good how are you?" "Hey Bob I'm good how are you?"
} }
Bob: "Testing..."
Bob: "I am great thanks!"
choice "What do you want to do?" { choice "What do you want to do?" {
"option 1" test2("testing",{1,2,3}) "option 1" test2("testing",{1,2,3})
@ -36,11 +35,16 @@ using extendedDefine
[test] [test]
Ryan: "We are here now!" Ryan: "We are here now!"
"hehe" |"This continues from the last message!"
|"Keeps code readable. This does not cause a new line!"
Ryan: "This does trigger a new line tho!"
"This also will cause a new line!"
[Bob:char] [Bob:char]
fname = "Bob" fname = "Bob"
//lname = "" //known = true // defaults to false
lname = ""
unknown = "Some Rando"
age = .24 age = .24
money = 100 money = 100
excited: "path/to/file" excited: "path/to/file"

3
DMS/token.h
View File

@ -48,7 +48,8 @@ namespace dms::tokens {
pound, pound,
dollar, dollar,
ampersand, ampersand,
nil nil,
pipe
};//stream, t_vec, line, isNum, buffer };//stream, t_vec, line, isNum, buffer
struct token { struct token {
tokentype type = noop; tokentype type = noop;

147
DMS/value.cpp
View File

@ -11,17 +11,154 @@ namespace dms {
// Values at runtime aren't "Deleted, they are set to nil" // Values at runtime aren't "Deleted, they are set to nil"
// At the end we actually delete them! // At the end we actually delete them!
} }
value* value::resolve(std::unordered_map<std::string, value*> map, value* v) { value* value::resolve(std::unordered_map<std::string, value*> memory) {
if (v != nullptr) { if (type == datatypes::variable) {
if (this->type == datatypes::variable) { return memory[s->getValue()]->resolve(memory); // Variable types return the value
return resolve(map, map[this->s->getValue()]); // Variable types return the value
}
} }
return this; return this;
} }
void dms_args::push(value* val) { void dms_args::push(value* val) {
args.push_back(val); args.push_back(val);
} }
std::string dms_string::getValue(dms_state* state) {
std::stringstream temp;
std::stringstream var;
std::stringstream ind;
bool varStart = false;
bool indStart = false;
for (size_t i = 0; i < length; i++) {
if (indStart && val[i] == '`') {
std::string lookup = var.str();
std::string index = ind.str();
var.str("");
var.clear();
ind.str("");
ind.clear();
varStart = false;
indStart = false;
if (state->memory.count(lookup)) {
value* v = state->memory[lookup];
if (v->type == datatypes::block) {
if (state->getCharacter(v->s->getValue())!=nullptr) {
character* cha = state->getCharacter(v->s->getValue());
if (index == "fname") {
temp << cha->fname;
}
else if (index == "lname") {
temp << cha->lname;
}
else if (index == "nickname") {
temp << cha->nickname;
}
else if (cha->values.count(index)) {
temp << cha->values[index]->getPrintable();
}
else {
temp << cha->getName();
}
}
else {
temp << "nil";
}
}
else {
temp << v->getPrintable();
}
}
else {
temp << "nil";
}
}
else if (indStart && val[i] == ':') {
state->push_error(errors::error{ errors::badtoken,"Cannot index more than once in a string injection!" });
varStart = false;
indStart = false;
var.str("");
var.clear();
ind.str("");
ind.clear();
return "";
}
else if (indStart) {
ind << val[i];
}
else if (val[i] == '`' && !varStart) {
varStart = true;
}
else if (val[i] == '`' && varStart) {
std::string lookup = var.str();
var.str("");
var.clear();
varStart = false;
if (state->memory.count(lookup)) {
value* v = state->memory[lookup];
if (v->type == datatypes::block) {
if (state->getCharacter(v->s->getValue())) {
temp << state->characters[v->s->getValue()]->getName();
}
else {
temp << "nil";
}
}
else {
temp << v->getPrintable();
}
}
else {
temp << "nil";
}
}
// A space is not allowed at all
else if (val[i] == ':' && varStart) {
indStart = true;
}
else if (val[i] == ' ' && varStart) {
temp << var.str();
varStart = false;
var.str("");
var.clear();
}
else if (varStart) {
var << val[i];
}
else {
temp << val[i];
}
}
return temp.str();
}
std::string value::getPrintable() const {
std::stringstream out;
if (type == string) {
out << s->getValue();
}
else if (type == number) {
out << n->getValue();
}
else if (type == nil) {
out << "nil";
}
else if (type == boolean) {
if (b->getValue())
out << "true";
else
out << "false";
}
else if (type == env) {
out << "Env: " << this;
}
else if (type == custom) {
out << "Custom Data: " << this;
}
else if (type == block) {
out << s->getValue();
}
else if (type == datatypes::variable) {
out << s->getValue(); // Do the lookup
}
return out.str();
}
dms_string* buildString(std::string str) { dms_string* buildString(std::string str) {
size_t len = str.length(); size_t len = str.length();
uint8_t* arr = new uint8_t[len]; uint8_t* arr = new uint8_t[len];

6
DMS/value.h
View File

@ -27,10 +27,12 @@ namespace dms {
return out; return out;
}; };
}; };
struct dms_state;
struct dms_string { struct dms_string {
size_t length = 0; size_t length = 0;
uint8_t* val = nullptr; uint8_t* val = nullptr;
std::string getValue(); std::string getValue();
std::string getValue(dms_state* state);
friend std::ostream& operator << (std::ostream& out, const dms_string& c) { friend std::ostream& operator << (std::ostream& out, const dms_string& c) {
for (size_t i = 0; i < c.length; i++) { for (size_t i = 0; i < c.length; i++) {
std::cout << c.val[i]; std::cout << c.val[i];
@ -64,7 +66,7 @@ namespace dms {
dms_env* e = nullptr; dms_env* e = nullptr;
dms_custom* c = nullptr; dms_custom* c = nullptr;
value(); value();
value* resolve(std::unordered_map<std::string,value*> map,value* v=nullptr); value* resolve(std::unordered_map<std::string,value*> map);
void nuke(); void nuke();
void set(dms_string* str); void set(dms_string* str);
void set(dms_boolean* bo); void set(dms_boolean* bo);
@ -72,6 +74,7 @@ namespace dms {
void set(dms_env* en); void set(dms_env* en);
void set(); void set();
bool typeMatch(const value* o) const; bool typeMatch(const value* o) const;
std::string getPrintable() const;
std::string toString() const; std::string toString() const;
friend std::ostream& operator << (std::ostream& out, const value& c) { friend std::ostream& operator << (std::ostream& out, const value& c) {
if (c.type == string) { if (c.type == string) {
@ -98,7 +101,6 @@ namespace dms {
else if (c.type == block) { else if (c.type == block) {
out << (char)c.type << c.s->getValue(); out << (char)c.type << c.s->getValue();
} }
// Internal kinda
else if (c.type == datatypes::variable) { else if (c.type == datatypes::variable) {
out << (char)c.type << c.s->getValue(); // Do the lookup out << (char)c.type << c.s->getValue(); // Do the lookup
} }