Resturcturing Some stuff
This commit is contained in:
parent
0f12ddcca3
commit
e1e77dfce9
@ -118,6 +118,7 @@
|
||||
<SDLCheck>true</SDLCheck>
|
||||
<PreprocessorDefinitions>_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
|
||||
<ConformanceMode>true</ConformanceMode>
|
||||
<LanguageStandard>stdcpp17</LanguageStandard>
|
||||
</ClCompile>
|
||||
<Link>
|
||||
<SubSystem>Console</SubSystem>
|
||||
|
||||
@ -11,6 +11,9 @@ namespace dms {
|
||||
return token{ tokentype::noop,codes::NOOP,"EOF",0 };
|
||||
return this->tokens[pos++];
|
||||
}
|
||||
void tokenstream::prev() {
|
||||
pos--;
|
||||
}
|
||||
std::vector<token> tokenstream::next(tokentype to, tokentype tc) {
|
||||
std::vector<token> tok;
|
||||
size_t open = 0;
|
||||
@ -70,6 +73,12 @@ namespace dms {
|
||||
std::string passer::processBuffer(std::vector<uint8_t> buf) {
|
||||
return std::string(buf.begin(), buf.end());
|
||||
}
|
||||
bool LineParser::isBlock() {
|
||||
return isBlock(bt_block); // Default block type
|
||||
}
|
||||
bool LineParser::isBlock(blocktype bk_type) {
|
||||
return current_chunk->type == bk_type;
|
||||
}
|
||||
void doCheck(passer* stream,std::vector<token>* t_vec, size_t line, bool &isNum, bool &hasDec, std::vector<uint8_t>* buffer) {
|
||||
std::string str = stream->processBuffer(*buffer);
|
||||
if (utils::isNum(str) && isNum) {
|
||||
@ -166,24 +175,33 @@ namespace dms {
|
||||
//
|
||||
return false;
|
||||
}
|
||||
std::map<std::string, chunk*> LineParser::tokenizer(dms_state* state,std::vector<token> &toks) {
|
||||
std::map<std::string,chunk*> chunks;
|
||||
chunk* current_chunk = nullptr;
|
||||
std::string chunk_name;
|
||||
blocktype chunk_type = bt_block;
|
||||
std::stack<scope> scopes;
|
||||
size_t line=1;
|
||||
tokenstream stream;
|
||||
stream.init(&toks);
|
||||
bool LineParser::createBlock(std::string bk_name, blocktype bk_type) {
|
||||
if (current_chunk != nullptr) {
|
||||
if (!chunks.count(current_chunk->name))
|
||||
chunks.insert_or_assign(current_chunk->name, current_chunk);
|
||||
else
|
||||
{
|
||||
std::stringstream str;
|
||||
str << "Block <" << current_chunk->name << "> already defined!";
|
||||
state->push_error(errors::error{ errors::block_already_defined,str.str(),true,line });
|
||||
return false;
|
||||
}
|
||||
}
|
||||
current_chunk = new chunk;
|
||||
current_chunk->name = bk_name;
|
||||
chunk_type = bk_type;
|
||||
current_chunk->type = bk_type;
|
||||
print("Created Block: ",bk_name," <",bk_type,">");
|
||||
}
|
||||
void LineParser::_Parse(tokenstream stream) {
|
||||
token current = stream.next();
|
||||
std::vector<token> temp;
|
||||
size_t tabs = 0;
|
||||
while (stream.peek().type != tokens::eof) {
|
||||
print(current);
|
||||
if (current.type == tokens::tab)
|
||||
tabs++;
|
||||
if (current.type == tokens::flag) {
|
||||
temp = stream.next(tokens::newline);
|
||||
stream.prev(); // Unconsume the newline piece
|
||||
if (temp.size() != 2) {
|
||||
std::cout << "Error";
|
||||
}
|
||||
@ -191,7 +209,7 @@ namespace dms {
|
||||
tokens::tokentype tok = temp[0].type;
|
||||
if (code == codes::ENAB && tok == tokens::name) {
|
||||
tolower(temp[0].name);
|
||||
state->enables.insert_or_assign(temp[0].name,true);
|
||||
state->enables.insert_or_assign(temp[0].name, true);
|
||||
}
|
||||
else if (code == codes::ENTR && tok == tokens::name) {
|
||||
state->entry = temp[0].name;
|
||||
@ -204,7 +222,7 @@ namespace dms {
|
||||
state->version = std::stod(temp[0].name);
|
||||
}
|
||||
else if (code == codes::USIN && tok == tokens::name) {
|
||||
// TODO add usings, kinda useless since everything will be packed in. Perhaps extensions might work
|
||||
// TODO add usings, kinda useless atm since everything will be packed in. Perhaps extensions?
|
||||
}
|
||||
else if (code == codes::LOAD && tok == tokens::string) {
|
||||
Parse(state, temp[0].name); // Load another file
|
||||
@ -212,89 +230,53 @@ namespace dms {
|
||||
else {
|
||||
std::stringstream str;
|
||||
str << "Expected <FLAG IDENTIFIER> " << " got: " << current << temp[0];
|
||||
state->push_error(errors::error{errors::badtoken,str.str(),true,line});
|
||||
state->push_error(errors::error{ errors::badtoken,str.str(),true,line });
|
||||
}
|
||||
}
|
||||
if (stream.match(tokens::newline,tokens::bracketo,tokens::name,tokens::bracketc)) {
|
||||
// Default block
|
||||
if (stream.match(tokens::newline, tokens::bracketo, tokens::name, tokens::bracketc)) {
|
||||
stream.next();
|
||||
if (current_chunk != nullptr) {
|
||||
if (!chunks.count(current_chunk->name))
|
||||
chunks.insert_or_assign(current_chunk->name, current_chunk);
|
||||
else
|
||||
{
|
||||
std::stringstream str;
|
||||
str << "Block <" << current_chunk->name << "> already defined!";
|
||||
state->push_error(errors::error{ errors::block_already_defined,str.str(),true,line });
|
||||
}
|
||||
}
|
||||
current_chunk = new chunk;
|
||||
chunk_type = bt_block;
|
||||
std::string name = stream.next().name;
|
||||
createBlock(name,bt_block);
|
||||
line = stream.next().line_num; // Consume
|
||||
current_chunk->name = stream.next().name;
|
||||
stream.next(); // Consume
|
||||
}
|
||||
// This handles a few block types since they all follow a similar format
|
||||
else if (stream.match(tokens::newline, tokens::bracketo, tokens::name,tokens::colon,tokens::name, tokens::bracketc)) {
|
||||
else if (stream.match(tokens::newline, tokens::bracketo, tokens::name, tokens::colon, tokens::name, tokens::bracketc)) {
|
||||
stream.next();
|
||||
stream.next();
|
||||
if (current_chunk != nullptr) {
|
||||
if (!chunks.count(current_chunk->name))
|
||||
chunks.insert_or_assign(current_chunk->name, current_chunk);
|
||||
else
|
||||
{
|
||||
std::stringstream str;
|
||||
str << "Block <" << current_chunk->name << "> already defined!";
|
||||
state->push_error(errors::error{ errors::block_already_defined,str.str(),true,line });
|
||||
}
|
||||
}
|
||||
|
||||
current_chunk = new chunk;
|
||||
current_chunk->name = stream.next().name;
|
||||
std::string name = stream.next().name;
|
||||
line = stream.next().line_num;
|
||||
std::string temp = stream.next().name;
|
||||
// Characters are a feature I want to have intergrated into the language
|
||||
if (temp == "char") {
|
||||
current_chunk->type = bt_character;
|
||||
chunk_type = bt_character;
|
||||
createBlock(name, bt_character);
|
||||
}
|
||||
// Enviroments are sortof like objects, they can be uses as an object. They are a cleaner way to build a hash map like object
|
||||
else if (temp == "env") {
|
||||
current_chunk->type = bt_env;
|
||||
chunk_type = bt_env;
|
||||
createBlock(name, bt_env);
|
||||
}
|
||||
// Menus are what they say on the tin. They provide the framework for having menus within your game
|
||||
else if (temp == "menu") {
|
||||
current_chunk->type = bt_menu;
|
||||
chunk_type = bt_menu;
|
||||
createBlock(name, bt_menu);
|
||||
}
|
||||
stream.next();
|
||||
}
|
||||
else if (stream.match(tokens::newline,tokens::bracketo,tokens::name,tokens::colon,tokens::name,tokens::parao)) {
|
||||
// Function block type
|
||||
else if (stream.match(tokens::newline, tokens::bracketo, tokens::name, tokens::colon, tokens::name, tokens::parao)) {
|
||||
std::stringstream str;
|
||||
stream.next();
|
||||
stream.next();
|
||||
if (current_chunk != nullptr) {
|
||||
if (!chunks.count(current_chunk->name))
|
||||
chunks.insert_or_assign(current_chunk->name, current_chunk);
|
||||
else
|
||||
{
|
||||
std::stringstream str;
|
||||
str << "Block <" << current_chunk->name << "> already defined!";
|
||||
state->push_error(errors::error{ errors::block_already_defined,str.str(),true,line });
|
||||
}
|
||||
}
|
||||
|
||||
current_chunk = new chunk;
|
||||
current_chunk->name = stream.next().name;
|
||||
std::string name = stream.next().name;
|
||||
line = stream.next().line_num; // The color, not needed after the inital match, but we still need to consume it
|
||||
std::string b = stream.next().name;
|
||||
if (b == "function") {
|
||||
current_chunk->type = bt_method; // We have a method let's set the block type to that, but we aren't done yet
|
||||
createBlock(name, bt_method); // We have a method let's set the block type to that, but we aren't done yet
|
||||
// We need to set the params if any so the method can be supplied with arguments
|
||||
stream.next(); // parao
|
||||
std::vector<token> tokens = stream.next(tokens::parac); // Consume until we see parac
|
||||
dms_args args;
|
||||
for (size_t i = 0; i < tokens.size()-1; i++) {//The lase symbol is parac since that was the consume condition
|
||||
for (size_t i = 0; i < tokens.size() - 1; i++) {//The lase symbol is parac since that was the consume condition
|
||||
if (tokens[i].type == tokens::name) {
|
||||
// We got a name which is refering to a variable so lets build one
|
||||
value* v = new value{};
|
||||
@ -308,7 +290,7 @@ namespace dms {
|
||||
else {
|
||||
std::stringstream str;
|
||||
str << "Unexpected symbol: " << tokens[i];
|
||||
state->push_error(errors::error{errors::badtoken,str.str(),true,line });
|
||||
state->push_error(errors::error{ errors::badtoken,str.str(),true,line });
|
||||
}
|
||||
}
|
||||
// If all went well the 'args' now has all of tha params for the method we will be working with
|
||||
@ -317,22 +299,22 @@ namespace dms {
|
||||
}
|
||||
else {
|
||||
str << "'function' keyword expected got " << b;
|
||||
state->push_error(errors::error{errors::badtoken, str.str(),true,line });
|
||||
state->push_error(errors::error{ errors::badtoken, str.str(),true,line });
|
||||
}
|
||||
}
|
||||
// Control Handle all controls here
|
||||
if (stream.match(tokens::tab,tokens::control)) {
|
||||
if (stream.match(tokens::tab, tokens::control)) {
|
||||
stream.next(); // Standard consumption
|
||||
token control = stream.next();
|
||||
if (control.raw == codes::CHOI && stream.peek().type==tokens::string) {
|
||||
if (control.raw == codes::CHOI && stream.peek().type == tokens::string) {
|
||||
// Let's parse choice blocks.
|
||||
std::string prompt = stream.next().name;
|
||||
print("Prompt: ",prompt);
|
||||
print("Prompt: ", prompt);
|
||||
bool good = true;
|
||||
size_t c = 0;
|
||||
while (good) {
|
||||
// We need to template the matches
|
||||
if (stream.match(tokens::tab,tokens::string,tokens::name,tokens::parao)) {
|
||||
if (stream.match(tokens::tab, tokens::string, tokens::name, tokens::parao)) {
|
||||
stream.next();
|
||||
std::string prompt = stream.next().name;
|
||||
|
||||
@ -341,7 +323,7 @@ namespace dms {
|
||||
// We just grabbed the prompt, we don't yet know how many choices we have. So we have to figure out how we can
|
||||
// Process and write the bytecode for this.
|
||||
std::string func = stream.next().name;
|
||||
print("Choice: <",c,"> ",prompt," Funcname: ",func);
|
||||
print("Choice: <", c, "> ", prompt, " Funcname: ", func);
|
||||
std::vector funcstuff = stream.next(tokens::newline);
|
||||
|
||||
//We need to process the function data and finish creating
|
||||
@ -375,7 +357,7 @@ namespace dms {
|
||||
std::string name = stream.next().name;
|
||||
stream.next(); // That colon
|
||||
std::string msg = stream.next().name;
|
||||
print("DISP := ", name , " says '",msg,"'");
|
||||
print("DISP := ", name, " says '", msg, "'");
|
||||
// We might have to consume a newline... Depends on what's next
|
||||
if (stream.hasScope(tabs)) {
|
||||
// If true we might have a group of displaying stuff.
|
||||
@ -394,11 +376,15 @@ namespace dms {
|
||||
wait();
|
||||
}*/
|
||||
if (current.type != tokens::tab)
|
||||
tabs=0;
|
||||
tabs = 0;
|
||||
current = stream.next();
|
||||
}
|
||||
chunks.insert_or_assign(current_chunk->name, current_chunk);
|
||||
return chunks;
|
||||
}
|
||||
void LineParser::tokenizer(dms_state* state,std::vector<token> &toks) {
|
||||
stream.init(&toks);
|
||||
this->state = state; // Grab the pointer to the state and store it within the parser object
|
||||
_Parse(stream);
|
||||
}
|
||||
void LineParser::tolower(std::string &s1) {
|
||||
std::transform(s1.begin(), s1.end(), s1.begin(), std::tolower);
|
||||
@ -576,7 +562,6 @@ namespace dms {
|
||||
if (data == ' ' && !isStr) { // tokens end with a space
|
||||
std::string str = stream.processBuffer(buffer);
|
||||
tolower(str);
|
||||
print("> ",str);
|
||||
if (str == "enable") {
|
||||
t_vec.push_back(token{ tokens::flag,codes::ENAB,"",line });
|
||||
} else if (str == "entry") {
|
||||
@ -658,8 +643,7 @@ namespace dms {
|
||||
outputFile.close();
|
||||
print("Running tokenizer");
|
||||
// Tokens build let's parse
|
||||
std::map<std::string,chunk*> test = tokenizer(state, t_vec);
|
||||
print(test.size());
|
||||
tokenizer(state, t_vec);
|
||||
return state;
|
||||
}
|
||||
}
|
||||
@ -22,6 +22,7 @@ namespace dms {
|
||||
size_t pos = 0;
|
||||
void init(std::vector<tokens::token>* ptr);
|
||||
tokens::token next();
|
||||
void prev();
|
||||
std::vector<tokens::token> next(tokens::tokentype to,tokens::tokentype tc);
|
||||
tokens::token peek();
|
||||
std::vector<tokens::token> next(tokens::tokentype tk);
|
||||
@ -42,6 +43,18 @@ namespace dms {
|
||||
class LineParser
|
||||
{
|
||||
std::string fn;
|
||||
std::map<std::string, chunk*> chunks;
|
||||
chunk* current_chunk = nullptr;
|
||||
std::string chunk_name;
|
||||
blocktype chunk_type = bt_block;
|
||||
std::stack<scope> scopes;
|
||||
size_t line = 1;
|
||||
tokenstream stream;
|
||||
std::vector<tokens::token> temp;
|
||||
size_t tabs = 0;
|
||||
dms_state* state;
|
||||
|
||||
void _Parse(tokenstream stream);
|
||||
public:
|
||||
dms_state* Parse();
|
||||
dms_state* Parse(std::string l);
|
||||
@ -50,6 +63,7 @@ namespace dms {
|
||||
LineParser();
|
||||
//Matches tokens from the stream, if the tokens match it will return true and YOU should call next on the stream. This method does not change the current position
|
||||
|
||||
bool createBlock(std::string bk_name, blocktype bk_type);
|
||||
bool buildLabel(chunk c, std::string label);
|
||||
|
||||
bool processFunc(tokenstream stream, chunk c);
|
||||
@ -57,9 +71,13 @@ namespace dms {
|
||||
bool processExpr(tokenstream stream, chunk c);
|
||||
bool processLogic(tokenstream stream, chunk c);
|
||||
|
||||
//Utils
|
||||
bool isBlock();
|
||||
bool isBlock(blocktype bk_type);
|
||||
|
||||
void tolower(std::string &str);
|
||||
tokens::tokentype* expr();
|
||||
tokens::tokentype* variable();
|
||||
std::map<std::string, chunk*> tokenizer(dms_state* state, std::vector<tokens::token> &tok);
|
||||
void tokenizer(dms_state* state, std::vector<tokens::token> &tok);
|
||||
};
|
||||
}
|
||||
376
DMS/dump.txt
376
DMS/dump.txt
@ -165,6 +165,7 @@ Line <35>NOOP newline
|
||||
Line <36>NOOP bracketo
|
||||
Line <36>NOOP name main
|
||||
Line <36>NOOP bracketc
|
||||
Line <36>NOOP cbracketo
|
||||
Line <36>NOOP newline
|
||||
Line <37>NOOP tab
|
||||
Line <37>NOOP name Ryan
|
||||
@ -178,6 +179,7 @@ Line <38>NOOP newline
|
||||
Line <39>NOOP tab
|
||||
Line <39>NOOP name Ryan
|
||||
Line <39>NOOP colon
|
||||
Line <39>NOOP cbracketo
|
||||
Line <39>NOOP newline
|
||||
Line <40>NOOP tab
|
||||
Line <40>NOOP tab
|
||||
@ -204,147 +206,103 @@ Line <44>NOOP tab
|
||||
Line <44>NOOP tab
|
||||
Line <44>NOOP newline
|
||||
Line <45>NOOP tab
|
||||
Line <45>NOOP tab
|
||||
Line <45>NOOP cbracketc
|
||||
Line <45>NOOP newline
|
||||
Line <46>NOOP tab
|
||||
Line <46>NOOP name tester
|
||||
Line <46>NOOP equal
|
||||
Line <46>NOOP string Hello
|
||||
Line <46>NOOP newline
|
||||
Line <47>NOOP tab
|
||||
Line <47>NOOP name food
|
||||
Line <47>NOOP name tester
|
||||
Line <47>NOOP equal
|
||||
Line <47>NOOP number 3
|
||||
Line <47>NOOP string Hello
|
||||
Line <47>NOOP newline
|
||||
Line <48>NOOP tab
|
||||
Line <48>NOOP name a
|
||||
Line <48>NOOP name food
|
||||
Line <48>NOOP equal
|
||||
Line <48>NOOP name list
|
||||
Line <48>NOOP bracketo
|
||||
Line <48>NOOP number 1
|
||||
Line <48>NOOP bracketc
|
||||
Line <48>NOOP number 3
|
||||
Line <48>NOOP newline
|
||||
Line <49>NOOP tab
|
||||
Line <49>NOOP name a
|
||||
Line <49>NOOP equal
|
||||
Line <49>NOOP name list
|
||||
Line <49>NOOP bracketo
|
||||
Line <49>NOOP number 1
|
||||
Line <49>NOOP bracketc
|
||||
Line <49>NOOP newline
|
||||
Line <50>NOOP tab
|
||||
Line <50>NOOP name hungry
|
||||
Line <50>NOOP equal
|
||||
Line <50>NOOP parao
|
||||
Line <50>NOOP minus
|
||||
Line <50>NOOP number 2
|
||||
Line <50>NOOP plus
|
||||
Line <50>NOOP number 4
|
||||
Line <50>NOOP minus
|
||||
Line <50>NOOP parao
|
||||
Line <50>NOOP parao
|
||||
Line <50>NOOP number 5
|
||||
Line <50>NOOP multiply
|
||||
Line <50>NOOP number 5
|
||||
Line <50>NOOP parac
|
||||
Line <50>NOOP divide
|
||||
Line <50>NOOP name sqrt
|
||||
Line <50>NOOP parao
|
||||
Line <50>NOOP number 144
|
||||
Line <50>NOOP plus
|
||||
Line <50>NOOP number 5
|
||||
Line <50>NOOP parac
|
||||
Line <50>NOOP parac
|
||||
Line <50>NOOP parac
|
||||
Line <50>NOOP pow
|
||||
Line <50>NOOP number 2
|
||||
Line <50>NOOP multiply
|
||||
Line <50>NOOP number 2
|
||||
Line <50>NOOP plus
|
||||
Line <50>NOOP number 2
|
||||
Line <50>NOOP newline
|
||||
Line <51>NOOP tab
|
||||
Line <51>NOOP name list
|
||||
Line <51>NOOP bracketo
|
||||
Line <51>NOOP number 1
|
||||
Line <51>NOOP bracketc
|
||||
Line <51>NOOP equal
|
||||
Line <51>NOOP string Hello
|
||||
Line <51>IFFF control
|
||||
Line <51>NOOP name statment
|
||||
Line <51>NOOP cbracketo
|
||||
Line <51>NOOP newline
|
||||
Line <52>NOOP tab
|
||||
Line <52>NOOP name var1
|
||||
Line <52>NOOP number
|
||||
Line <52>NOOP equal
|
||||
Line <52>NOOP name func
|
||||
Line <52>NOOP parao
|
||||
Line <52>NOOP number 1
|
||||
Line <52>NOOP seperator
|
||||
Line <52>NOOP string string
|
||||
Line <52>NOOP seperator
|
||||
Line <52>NOOP number 2
|
||||
Line <52>NOOP plus
|
||||
Line <52>NOOP number 5
|
||||
Line <52>NOOP parac
|
||||
Line <52>NOOP tab
|
||||
Line <52>NOOP string test
|
||||
Line <52>NOOP newline
|
||||
Line <53>NOOP tab
|
||||
Line <53>NOOP name a
|
||||
Line <53>NOOP equal
|
||||
Line <53>NOOP name 100
|
||||
Line <53>NOOP number
|
||||
Line <53>NOOP plus
|
||||
Line <53>NOOP name func
|
||||
Line <53>NOOP parao
|
||||
Line <53>NOOP number 1
|
||||
Line <53>NOOP seperator
|
||||
Line <53>NOOP string string
|
||||
Line <53>NOOP seperator
|
||||
Line <53>NOOP number 2
|
||||
Line <53>NOOP plus
|
||||
Line <53>NOOP number 5
|
||||
Line <53>NOOP parac
|
||||
Line <53>NOOP plus
|
||||
Line <53>NOOP number 100
|
||||
Line <53>NOOP cbracketc
|
||||
Line <53>ELIF control
|
||||
Line <53>NOOP name statement
|
||||
Line <53>NOOP cbracketo
|
||||
Line <53>NOOP newline
|
||||
Line <54>NOOP tab
|
||||
Line <54>NOOP name func
|
||||
Line <54>NOOP parao
|
||||
Line <54>NOOP number 1
|
||||
Line <54>NOOP seperator
|
||||
Line <54>NOOP string string
|
||||
Line <54>NOOP seperator
|
||||
Line <54>NOOP number 2
|
||||
Line <54>NOOP plus
|
||||
Line <54>NOOP number 5
|
||||
Line <54>NOOP parac
|
||||
Line <54>NOOP tab
|
||||
Line <54>NOOP string test
|
||||
Line <54>NOOP newline
|
||||
Line <55>NOOP tab
|
||||
Line <55>NOOP label label
|
||||
Line <55>NOOP tab
|
||||
Line <55>NOOP cbracketc
|
||||
Line <55>IFFF control
|
||||
Line <55>NOOP name statement
|
||||
Line <55>NOOP cbracketo
|
||||
Line <55>NOOP newline
|
||||
Line <56>NOOP tab
|
||||
Line <56>NOOP tab
|
||||
Line <56>NOOP tab
|
||||
Line <56>NOOP string test
|
||||
Line <56>NOOP newline
|
||||
Line <57>NOOP tab
|
||||
Line <57>NOOP tab
|
||||
Line <57>NOOP tab
|
||||
Line <57>NOOP string test
|
||||
Line <57>NOOP newline
|
||||
Line <58>NOOP tab
|
||||
Line <58>NOOP tab
|
||||
Line <58>NOOP tab
|
||||
Line <58>IFFF control
|
||||
Line <58>NOOP name statment
|
||||
Line <58>NOOP name then
|
||||
Line <58>NOOP name statement
|
||||
Line <58>NOOP cbracketo
|
||||
Line <58>NOOP newline
|
||||
Line <59>NOOP tab
|
||||
Line <59>NOOP tab
|
||||
Line <59>NOOP tab
|
||||
Line <59>NOOP tab
|
||||
Line <59>NOOP string test
|
||||
Line <59>NOOP newline
|
||||
Line <60>NOOP tab
|
||||
Line <60>ELIF control
|
||||
Line <60>NOOP name statement
|
||||
Line <60>NOOP name then
|
||||
Line <60>NOOP tab
|
||||
Line <60>NOOP tab
|
||||
Line <60>NOOP cbracketc
|
||||
Line <60>ELSE control
|
||||
Line <60>NOOP cbracketo
|
||||
Line <60>NOOP newline
|
||||
Line <61>NOOP tab
|
||||
Line <61>NOOP tab
|
||||
Line <61>NOOP tab
|
||||
Line <61>NOOP tab
|
||||
Line <61>NOOP string test
|
||||
Line <61>NOOP newline
|
||||
Line <62>NOOP tab
|
||||
Line <62>NOOP tab
|
||||
Line <62>IFFF control
|
||||
Line <62>NOOP name statement
|
||||
Line <62>NOOP name then
|
||||
Line <62>NOOP tab
|
||||
Line <62>NOOP cbracketc
|
||||
Line <62>NOOP newline
|
||||
Line <63>NOOP tab
|
||||
Line <63>NOOP tab
|
||||
Line <63>NOOP tab
|
||||
Line <63>NOOP string test
|
||||
Line <63>NOOP cbracketc
|
||||
Line <63>ELIF control
|
||||
Line <63>NOOP name statement
|
||||
Line <63>NOOP cbracketo
|
||||
Line <63>NOOP newline
|
||||
Line <64>NOOP tab
|
||||
Line <64>NOOP tab
|
||||
@ -353,150 +311,216 @@ Line <64>NOOP string test
|
||||
Line <64>NOOP newline
|
||||
Line <65>NOOP tab
|
||||
Line <65>NOOP tab
|
||||
Line <65>NOOP tab
|
||||
Line <65>IFFF control
|
||||
Line <65>NOOP name statement
|
||||
Line <65>NOOP name then
|
||||
Line <65>NOOP cbracketc
|
||||
Line <65>ELSE control
|
||||
Line <65>NOOP cbracketo
|
||||
Line <65>NOOP newline
|
||||
Line <66>NOOP tab
|
||||
Line <66>NOOP tab
|
||||
Line <66>NOOP tab
|
||||
Line <66>NOOP tab
|
||||
Line <66>NOOP string test
|
||||
Line <66>NOOP newline
|
||||
Line <67>NOOP tab
|
||||
Line <67>NOOP tab
|
||||
Line <67>NOOP tab
|
||||
Line <67>NOOP name else
|
||||
Line <67>NOOP cbracketc
|
||||
Line <67>NOOP newline
|
||||
Line <68>NOOP tab
|
||||
Line <68>NOOP tab
|
||||
Line <68>NOOP tab
|
||||
Line <68>NOOP tab
|
||||
Line <68>NOOP string test
|
||||
Line <68>NOOP newline
|
||||
Line <69>NOOP tab
|
||||
Line <69>NOOP tab
|
||||
Line <69>ELIF control
|
||||
Line <69>NOOP name statement
|
||||
Line <69>NOOP name then
|
||||
Line <69>NOOP gotoo
|
||||
Line <69>NOOP string somewhere
|
||||
Line <69>NOOP newline
|
||||
Line <70>NOOP tab
|
||||
Line <70>NOOP tab
|
||||
Line <70>NOOP tab
|
||||
Line <70>NOOP string test
|
||||
Line <70>NOOP jump
|
||||
Line <70>NOOP string overhere
|
||||
Line <70>NOOP newline
|
||||
Line <71>NOOP tab
|
||||
Line <71>NOOP name else
|
||||
Line <71>NOOP newline
|
||||
Line <72>NOOP tab
|
||||
Line <72>NOOP tab
|
||||
Line <72>NOOP string test
|
||||
Line <72>NOOP name hungry
|
||||
Line <72>NOOP equal
|
||||
Line <72>NOOP parao
|
||||
Line <72>NOOP minus
|
||||
Line <72>NOOP number 2
|
||||
Line <72>NOOP plus
|
||||
Line <72>NOOP number 4
|
||||
Line <72>NOOP minus
|
||||
Line <72>NOOP parao
|
||||
Line <72>NOOP parao
|
||||
Line <72>NOOP number 5
|
||||
Line <72>NOOP multiply
|
||||
Line <72>NOOP number 5
|
||||
Line <72>NOOP parac
|
||||
Line <72>NOOP divide
|
||||
Line <72>NOOP name sqrt
|
||||
Line <72>NOOP parao
|
||||
Line <72>NOOP number 144
|
||||
Line <72>NOOP plus
|
||||
Line <72>NOOP number 5
|
||||
Line <72>NOOP parac
|
||||
Line <72>NOOP parac
|
||||
Line <72>NOOP parac
|
||||
Line <72>NOOP pow
|
||||
Line <72>NOOP number 2
|
||||
Line <72>NOOP multiply
|
||||
Line <72>NOOP number 2
|
||||
Line <72>NOOP plus
|
||||
Line <72>NOOP number 2
|
||||
Line <72>NOOP newline
|
||||
Line <73>NOOP tab
|
||||
Line <73>NOOP name list
|
||||
Line <73>NOOP bracketo
|
||||
Line <73>NOOP number 1
|
||||
Line <73>NOOP bracketc
|
||||
Line <73>NOOP equal
|
||||
Line <73>NOOP string Hello
|
||||
Line <73>NOOP newline
|
||||
Line <74>NOOP tab
|
||||
Line <74>NOOP gotoo
|
||||
Line <74>NOOP string somewhere
|
||||
Line <74>NOOP name var1
|
||||
Line <74>NOOP number
|
||||
Line <74>NOOP equal
|
||||
Line <74>NOOP name func
|
||||
Line <74>NOOP parao
|
||||
Line <74>NOOP number 1
|
||||
Line <74>NOOP seperator
|
||||
Line <74>NOOP string string
|
||||
Line <74>NOOP seperator
|
||||
Line <74>NOOP number 2
|
||||
Line <74>NOOP plus
|
||||
Line <74>NOOP number 5
|
||||
Line <74>NOOP parac
|
||||
Line <74>NOOP newline
|
||||
Line <75>NOOP tab
|
||||
Line <75>NOOP jump
|
||||
Line <75>NOOP string overhere
|
||||
Line <75>NOOP name a
|
||||
Line <75>NOOP equal
|
||||
Line <75>NOOP name 100
|
||||
Line <75>NOOP number
|
||||
Line <75>NOOP plus
|
||||
Line <75>NOOP name func
|
||||
Line <75>NOOP parao
|
||||
Line <75>NOOP number 1
|
||||
Line <75>NOOP seperator
|
||||
Line <75>NOOP string string
|
||||
Line <75>NOOP seperator
|
||||
Line <75>NOOP number 2
|
||||
Line <75>NOOP plus
|
||||
Line <75>NOOP number 5
|
||||
Line <75>NOOP parac
|
||||
Line <75>NOOP plus
|
||||
Line <75>NOOP number 100
|
||||
Line <75>NOOP newline
|
||||
Line <76>NOOP tab
|
||||
Line <76>NOOP name func
|
||||
Line <76>NOOP parao
|
||||
Line <76>NOOP number 1
|
||||
Line <76>NOOP seperator
|
||||
Line <76>NOOP string string
|
||||
Line <76>NOOP seperator
|
||||
Line <76>NOOP number 2
|
||||
Line <76>NOOP plus
|
||||
Line <76>NOOP number 5
|
||||
Line <76>NOOP parac
|
||||
Line <76>NOOP newline
|
||||
Line <77>NOOP tab
|
||||
Line <77>CHOI control
|
||||
Line <77>NOOP string Pick one:
|
||||
Line <77>NOOP cbracketo
|
||||
Line <77>NOOP label label
|
||||
Line <77>NOOP newline
|
||||
Line <78>NOOP tab
|
||||
Line <78>NOOP tab
|
||||
Line <78>NOOP string first
|
||||
Line <78>NOOP name func
|
||||
Line <78>NOOP parao
|
||||
Line <78>NOOP parac
|
||||
Line <78>NOOP newline
|
||||
Line <79>NOOP tab
|
||||
Line <79>NOOP tab
|
||||
Line <79>NOOP string second
|
||||
Line <79>NOOP name func
|
||||
Line <79>NOOP parao
|
||||
Line <79>NOOP parac
|
||||
Line <79>NOOP newline
|
||||
Line <80>NOOP tab
|
||||
Line <80>NOOP tab
|
||||
Line <80>NOOP string third
|
||||
Line <80>NOOP name func
|
||||
Line <80>NOOP parao
|
||||
Line <80>NOOP parac
|
||||
Line <80>CHOI control
|
||||
Line <80>NOOP string Pick one:
|
||||
Line <80>NOOP cbracketo
|
||||
Line <80>NOOP newline
|
||||
Line <81>NOOP tab
|
||||
Line <81>NOOP tab
|
||||
Line <81>NOOP string forth
|
||||
Line <81>NOOP string first
|
||||
Line <81>NOOP name func
|
||||
Line <81>NOOP parao
|
||||
Line <81>NOOP parac
|
||||
Line <81>NOOP newline
|
||||
Line <82>NOOP tab
|
||||
Line <82>NOOP tab
|
||||
Line <82>NOOP string fifth
|
||||
Line <82>NOOP gotoo
|
||||
Line <82>NOOP string here
|
||||
Line <82>NOOP string second
|
||||
Line <82>NOOP name func
|
||||
Line <82>NOOP parao
|
||||
Line <82>NOOP parac
|
||||
Line <82>NOOP newline
|
||||
Line <83>NOOP tab
|
||||
Line <83>NOOP tab
|
||||
Line <83>NOOP string sixth
|
||||
Line <83>NOOP gotoo
|
||||
Line <83>NOOP name name
|
||||
Line <83>NOOP string third
|
||||
Line <83>NOOP name func
|
||||
Line <83>NOOP parao
|
||||
Line <83>NOOP parac
|
||||
Line <83>NOOP newline
|
||||
Line <84>NOOP tab
|
||||
Line <84>NOOP tab
|
||||
Line <84>NOOP string sevinth
|
||||
Line <84>NOOP jump
|
||||
Line <84>NOOP string there
|
||||
Line <84>NOOP string forth
|
||||
Line <84>NOOP name func
|
||||
Line <84>NOOP parao
|
||||
Line <84>NOOP parac
|
||||
Line <84>NOOP newline
|
||||
Line <85>NOOP tab
|
||||
Line <85>NOOP tab
|
||||
Line <85>NOOP string eight
|
||||
Line <85>NOOP jump
|
||||
Line <85>NOOP name name
|
||||
Line <85>NOOP string fifth
|
||||
Line <85>NOOP gotoo
|
||||
Line <85>NOOP string here
|
||||
Line <85>NOOP newline
|
||||
Line <86>NOOP tab
|
||||
Line <86>NOOP cbracketc
|
||||
Line <86>NOOP tab
|
||||
Line <86>NOOP string sixth
|
||||
Line <86>NOOP gotoo
|
||||
Line <86>NOOP name name
|
||||
Line <86>NOOP newline
|
||||
Line <87>NOOP tab
|
||||
Line <87>NOOP tab
|
||||
Line <87>NOOP string sevinth
|
||||
Line <87>NOOP jump
|
||||
Line <87>NOOP string there
|
||||
Line <87>NOOP newline
|
||||
Line <88>NOOP tab
|
||||
Line <88>NOOP tab
|
||||
Line <88>NOOP string eight
|
||||
Line <88>NOOP jump
|
||||
Line <88>NOOP name name
|
||||
Line <88>NOOP newline
|
||||
Line <89>NOOP bracketo
|
||||
Line <89>NOOP name Bob
|
||||
Line <89>NOOP colon
|
||||
Line <89>NOOP name char
|
||||
Line <89>NOOP bracketc
|
||||
Line <89>NOOP tab
|
||||
Line <89>NOOP cbracketc
|
||||
Line <89>NOOP newline
|
||||
Line <90>NOOP tab
|
||||
Line <90>NOOP name age
|
||||
Line <90>NOOP equal
|
||||
Line <90>NOOP number 24
|
||||
Line <90>NOOP cbracketc
|
||||
Line <90>NOOP newline
|
||||
Line <91>NOOP tab
|
||||
Line <91>NOOP name money
|
||||
Line <91>NOOP equal
|
||||
Line <91>NOOP number 100
|
||||
Line <91>NOOP newline
|
||||
Line <92>NOOP newline
|
||||
Line <93>NOOP bracketo
|
||||
Line <93>NOOP name newblock
|
||||
Line <93>NOOP name Bob
|
||||
Line <93>NOOP colon
|
||||
Line <93>NOOP name function
|
||||
Line <93>NOOP parao
|
||||
Line <93>NOOP parac
|
||||
Line <93>NOOP name char
|
||||
Line <93>NOOP bracketc
|
||||
Line <93>NOOP newline
|
||||
Line <94>NOOP tab
|
||||
Line <94>NOOP string Test #2
|
||||
Line <94>NOOP number
|
||||
Line <94>NOOP name age
|
||||
Line <94>NOOP equal
|
||||
Line <94>NOOP number 24
|
||||
Line <94>NOOP newline
|
||||
Line <95>NOOP tab
|
||||
Line <95>NOOP string Does it parse this part properly?
|
||||
Line <95>NOOP name money
|
||||
Line <95>NOOP equal
|
||||
Line <95>NOOP number 100
|
||||
Line <95>NOOP newline
|
||||
Line <97>NOOP eof
|
||||
Line <96>NOOP newline
|
||||
Line <97>NOOP bracketo
|
||||
Line <97>NOOP name newblock
|
||||
Line <97>NOOP colon
|
||||
Line <97>NOOP name function
|
||||
Line <97>NOOP parao
|
||||
Line <97>NOOP parac
|
||||
Line <97>NOOP bracketc
|
||||
Line <97>NOOP newline
|
||||
Line <98>NOOP tab
|
||||
Line <98>NOOP string Test #2
|
||||
Line <98>NOOP number
|
||||
Line <98>NOOP newline
|
||||
Line <99>NOOP tab
|
||||
Line <99>NOOP string Does it parse this part properly?
|
||||
Line <99>NOOP newline
|
||||
Line <101>NOOP eof
|
||||
|
||||
0
DMS/streams.cpp
Normal file
0
DMS/streams.cpp
Normal file
1
DMS/streams.h
Normal file
1
DMS/streams.h
Normal file
@ -0,0 +1 @@
|
||||
#pragma once
|
||||
Loading…
x
Reference in New Issue
Block a user