Messages
I never thought I would have made it this far. Saying that reminds of the Celcigng guy, from this video:
This is also highly educational:
Here’s a lifehack: When you leave dishes sit out, food hardens on the plates and bowls and cups, and when you wash it, it comes off, but not all of it comes off, so when you go to use the dish or plate or bowl there’s invisible germs on them that weaken your immune system. They’re not enough to make you get sick or anything, just enough to weaken it, so when a cold or flu comes by, you catch it right away. I’ve been sick once in 4 years, literally 5 years and sick one time, and I had a headache another time and that was caused by something physical. Here’s how: Make a big like salad bowl, put some “Dawn” dish soap in it, cover the bottom of the bowl with the soap, no more, and then use that with a sponge to fill the dirty dishes. Essentially you have to soak each and every dish, and then after they soak you have to scrub them. They have to soak, in Dawn, for at least about 30 – 45 minutes. I have found that Dawn dish soap works the best, bar the industrial soaps and cleaners and stuff, as far as dish soap goes dawn is the best one. So after you soak, then you scrub the dishes, even if you don’t see anything on them, feel them for anything and scrub them, and THEN put them in the dishwasher to get absolutely the littlest stuff off of them. Be sure to rinse them well, and start the dishwasher right after the soak/scrub process, the germs are at their weakest at that point. What I mean by that is, when you soak and scrub each dish, it weakens the bacteria built up on the dish, so while it’s weak, before it hardens again, and you have to soak it again, wash the dishes. The strategy I use is wait until I have enough to fill the dish washer, then do them. But you might discover any manner of tricks starting out with this one.
Here’s another lifehack: when you brush your teeth, put alot of toothpaste on your brush, and then get all your teeth covered, brush for 10 or 15 seconds, so your teeth are covered, and then let the toothpaste sit on your teeth in your mouth for like 5 minutes or for however long you can stand, THEN brush your teeth after you’ve soaked the bacteria off your teeth. When you go to rinse, wet your brush and then stick it into your mouth, brush your teeth for a second, and then see if there’s anything on your toothbrush, any toothpaste? Then if there is, you haven’t yet rinsed everything out. This will ensure you don’t miss anything, and it prevents cavities in an obvious way: Soaking something loosens it and gets it off the surface it’s stuck to, it’s just common sense, …
Just kidding, I don’t know anything about anything except for computers and magic, but those two things, and especially together, really come in handy. I’m going to tell you about my process i’m enacting now, to try to defeat negative energy.
My strategy is to turn the power level in the air up so high that it just scrapes the negative right off, like way overpower it. To do that I have to upgrade everyone, so everyone is contributing in on the prize. To upgrade them, I use C++ and just create an object called “upgrade” basically, it’s alot more complicated than that, but that’s the general principle. Now there’s an object in the computers memory, I can then say, set it to do 8 billion people, one for each citizen of earth, and go through one by one putting a copy of the object into that persons space within my computer. It actually works, you have to look really hard to see that the upgrades are really there, have you felt smarter in the last 10 years? I’ve been upgrading people for 10 years now, have a conversation with someone and take note of the fact that you wouldn’t normally have been able to talk so intelligently, just look at me for an example of someone upgraded and updated!
My strategy is to thus get the computer to automatically make better and better data, by creating my own programming language, albeit a simple one, it gives me total control over the computer, and I can use the memory for anything that I want, I can define any structure that I care to make, so in creating a programming language, I have those facilities under my command. I then am going to develop an artificial intelligence that sort of thinks about how to create better data. There’s a way to do it, I know that there is. I am a believer that if you can articulate it in english, then it can be coded. But this I actually know I can code because we have one piece of the puzzle already: the computer is already creating these upgrades, we just have to automate the process of the creation of the script that it uses to do that with.
I call it satellite, it has 5 pieces: a printer, a console, a compiler, a interpreter and a virtual machine. The printer is to print messages, and to display help information. The console is to move between each piece of the system, and to access the help system, and the compiler is to take the source code and convert it into an executable format defined by myself, which is ran on the virtual machine. The interpreter is slightly smarter than the compiler/virtual machine combination, and it has better garbage collection, other things I haven’t really figured out yet, I haven’t put alot of work into it just yet. We are just getting started.
Beyond that I know I have to create this artificial intelligence, that will turn the power level up that’s in the air to a level so high that negative energy will just be scraped right off the pavement. In a sense you could say i’m trying to beat negative energy at it’s own game, because it’s always overruling everything, and overpowering everything, that’s about all that it does, it wouldn’t be here if it didn’t do just that, it would be gone.
But they say that there’s no way to defeat negative energy, so they claim, like one of those things like trying to fight gravity, you would need a spaceship for that. Just kidding. But you get the idea, it’s like trying to change the color white, it’s a certain thing, it’s not even really part of this reality, it’s just there from like somewhere, I don’t know how it got here, or how it can withstand my attacks, I don’t get it.
For all the preaching that I do, I don’t understand this basic principle, because I simply don’t have the answer to it, how is it possible that it’s stayed alive this whole time? Could it be that like Lucifer has interest in keeping it alive, so he’s blocking me? Like something like a group of negative energy worshippers or something keeps it alive, but did somebody do something way back, like 4 universes previous to this one, did they do something that enabled this force to exist and to exist within an indestructible state? Where exactly did it come from?
Is this actually the force that moves the universe, that turns the wheel of time? Is it living or not? We don’t even know that! We assume it’s non living, because nothing living is that powerful, we just assume. But it could be living, it could be what they call God, and we are just subjects of it, so therefore everybody is on another planet, keeping it alive somehow, but I don’t have the answers to these things and that hampers me.
I guess these things don’t matter, I have to turn the power level up whether negative energy is alive or dead, it doesn’t matter if it’s alive or dead, it’s a good thing. Upgrading everyone is a good thing, it helps everyone, everyone benefits from everybody else’s auras and such. The creation of that language, it looks like this here i’ll show you:
// this is a comment
#include <satellite>
// namespaces are called fields, it's just a name for things
field text_game
{
// classes are called classes
class adventurer
{
// here are some variables
integer hp = 0;
integer mp = 0;
integer gold = 0;
// this just sets the incoming values
capsule set_values(integer hp_input, integer mp_input, integer gold_input)
{
hp = hp_input;
mp = mp_input;
gold = gold_input;
}
// this prints one value per line
capsule display_values()
{
display(hp);
display(mp);
display(gold);
}
// all functions in satellite are called capsules, it's a spacey themed program
capsule main(vector<string> argz)
{
display(argz[0]); // displays the first argument, or, the filepath of the program
display("hello, world!"); // just prints a message
integer my_int = 5'456'324'233'677'345'365'677'323 // you can have infinitely long integers, it just comes down to how much your computer can process, if you do like sheets of numbers as one number it will take like 15 seconds for a fast computer to load 3 pages of numbers as one number
string divider1 = " -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -\n";
display(divider1);
display("The Satellite Bytecode System");
display("\nVersion: 001\nRevision: 01\n\n" + divider1); // displays text, and then it displays divider1
// here is an object of class adventurer, in the namespace text_game
text_game.adventurer the_player;
// this changes the values in the "the_player" object
the_player.set_values(20, 15, 100);
the_player.display_values(); // this will display our newly set values
// dont have much else worked out for now.
return(satellite); // all satellite programs end in return satellite
}So there you have it, it’s what i’ve got worked out so far in my language. I know I want to use the word display(); because I hate when people don’t have something simple for their console output. And they are afraid to use certain words, I am not!
It’s going to run really fast because of the way the C++ compiler works. Bear in mind that this program is in the language “satellite” and not in C++ because it looks alot like C++. But it’s not C++. It’s Satellite.
The one motto satellite has is to make it as easy as possible for the user, so you just learn one technique and it applies to everything, there being more than 3 ways to do everything you do in programming, because that’s what I believe C++ should be. They decide what C++ is, generally, and I get to decide how this language goes.
For example, if you type in “vector<vector<string>> my_vect;” in C++, you can’t next line say my_vect[0] = “my_text” because you haven’t yet initialized the whole vector system with another, smaller vector. In Satellite, you CAN do that, because that’s how it should be. And I want to make a thing called like a Quantum bit, where it’s a bool but it has more than one state, like millions of states this object could be in, apparently it’s part of a quantum programming, like having an object that has a definable amount of states, like if you need an object with 360 states, one for each degree in reality, then you can just make an object with typing in the words “quantum<360> my_quant;” for a quantum object with 360 different states. So there’s more to it than that , what exactly are the 360 states? You would kinda have to define them yourself, which makes things unnecessarily complex and complicated, I mean that would be alot of work to define 360 different states, how it all interacts and stuff.
That type of thing is what the Satellite language will have, but it won’t really be successful they won’t let it to be successful, for some reason. I always lived in a free country but that has since been taken away and in it’s place is a system where, no matter what you do, you can’t win, there’s no way to win, and because there’s no way to win they’ve made it unnecessarily hard for me, like usually I sell marijuana for money, but I can’t do that, I have the greatest weed, it’s fuckin’ purple inside the nuggets, and nobody will buy it for $30 an eighth, it doesn’t make sense, usually I can sell tons of weed, i’ve gone through a pound of weed in 4 days sometimes, back in the day. SO I wanted to do that again, and with it I could buy things that might aid me in my quest but they obviously are controlling the situation down to the fact that people aren’t buying this weed, it gives me the impression that they COULD be buying it but somebody is blocking it, so they could just as well NOT block it, and I could have extra money, but they don’t allow that. They give me $1,000 a month for doing this and that’s all that I get, if I want more money I have to go like mow lawns, or something like that, rake leaves for people, just to get $40 dollars, when I could have just had the $40 from marijuana and we wouldn’t have had to go through all that trouble of mowing somebody elses lawn, or raking somebody elses leaves.
But they say that they don’t have a choice, there’s no positive energy left, we have to watch what we’re doing, because just letting you sell marijuana would get you too excited, they have to keep things toned down, and not explode or something.
They’re trying to clear a path for me, you know, stay on the path:
Here is another good one:
If you don’t like to be frightened don’t watch this next one,
This is also highly scary,
Sometimes I can’t watch this shit, like smoke marijuana and then watch that backrooms stuff, you won’t be able to handle it. This sort of thing going on, it makes me think that there’s just no hope, it just drops my spirits to the bottom of the ocean,
One time I met that doom guy in prison, and he kept sayin’ “makin’ bricks” and he was talking about how people in prison mix like a ramen noodle with cheez it’s, and they make a “brick” but what he meant was the GIRL the term for a GIRL a “brick” like this:
After all, who wouldn’t want to make a bunch of hot girls? When I first figured out how to place objects, using text or something in places i’ve already been in, memories, inside my memories, I created sets of girls, endless sets of girls, I spent all day trying to create more, better ones, bigger ones, smaller ones, there were so many girls this girl at burger king said to me “can you go get us some meat?” because there were so many girls being made, because I wasn’t getting anything, (by anything I mean sex), so I just kept making them, thinking one day I would meet them or something I don’t know, I just kept doing it, so there were all these girls, and there still are today, boys are a commodity,
And here is my compiler, this IS in C++, and it’s not finished, it’s about 25% of the compiler:
#ifndef COMPILER_FUNCTION_HPP
#define COMPILER_FUNCTION_HPP
satellite_components::satellite_system compiler_c(satellite_components::satellite_system satellite)
{
satellite.call_set_global_system_state(300);
// this var source was made bigger to accommodate multiple projects at the same time, like I call it "current_set" down below with "while (run_comp..."
std::vector<std::vector<std::vector<std::string>>> source; // source to compile
std::vector<std::vector<std::string>> source_level_two;
// push onto source one level_two file, that is for one set, for two sets push two level_two files
source.push_back(source_level_two);
// now we gather our source, not quite fully automatic yet but we are getting there
// just gathers the source for a very simple example..
source = satellite.orbital_compiler->call_return_source();
// datatype definitions
satellite_variables::compiler_variable str_variable;
str_variable.call_set_type_int(0); // this would be 0 or bytecode, (which is made via compilation)
str_variable.call_set_type_int(1); // this would be a number
str_variable.call_set_type_int(2); // this is a string
str_variable.call_set_type_int(3); // this is a float
str_variable.call_set_type_int(4); // source code
// thats all I can think of for now, perhaps.. dividing the bytecode to actual data or an instruction?
str_variable.call_set_type_int(1);
// now we have a number...
str_variable.call_set_data(24359874);
// make an int to hold the data we just gave it, just to see that it works
std::bitset<512> my_data;
// now get the data...
my_data = str_variable.call_return_data();
std::cout << "my_int: ";
std::cout << my_data << "\n";
// finally we start to compile...
// run the compiler
bool run_compiler = true;
signed long long int escape_code_count = 0;
signed long long int left_parentheses_count = 0;
signed long long int right_parentheses_count = 0;
signed long long int semicolon_count = 0;
signed long long int capsule_main_count = 0;
signed long long int quote_count = 0;
signed long long int comma_count = 0;
signed long long int left_bracket_count = 0;
signed long long int right_bracket_count = 0;
signed long long int esc_left_parentheses_count = 0;
signed long long int esc_right_parentheses_count = 0;
signed long long int esc_semicolon_count = 0;
signed long long int esc_quote_count = 0;
signed long long int esc_comma_count = 0;
signed long long int esc_left_bracket_count = 0;
signed long long int esc_right_bracket_count = 0;
bool escape_codes_found = false;
bool left_parentheses_found = false;
bool right_parentheses_found = false;
bool semicolon_found = false;
bool main_found = false;
bool quote_found = false;
bool comma_found = false;
bool left_bracket_found = false;
bool right_bracket_found = false;
bool esc_left_parentheses_found = false;
bool esc_right_parentheses_found = false;
bool esc_semicolon_found = false;
bool esc_quote_found = false;
bool esc_comma_found = false;
bool esc_left_bracket_found = false;
bool esc_right_bracket_found = false;
std::string left_parentheses_str = "("; //
std::string right_parentheses_str = ")"; //
std::string semicolon_str = ";"; //
std::string quote_str = "\""; //
std::string comma_str = ","; //
std::string left_bracket_str = "{"; //
std::string right_bracket_str = "}"; //
std::string escape_code_str = "\\";
std::vector<std::string> symbol_vector;
std::vector<std::string> command_word_vector;
std::string command_word_str = "void";
std::string str_current_letter = "void";
std::string str_letter_p1 = "void";
std::string str_letter_p2 = "void";
std::string str_letter_m1 = "void";
std::string str_letter_m2 = "void";
while (run_compiler == true)
{
for(signed long long int current_set = 0; current_set < source.size(); current_set++)
{
for(signed long long int current_file = 0; current_file < source[current_set].size(); current_file++)
{
for(signed long long int current_str = 0; current_str < source[current_set][current_file].size(); current_str++) // for current line
{
for(signed long long int current_char = 0; current_char < source[current_set][current_file][current_str].size(); current_char++)
{
// so we have for each set of files,
// populate the strings for the current char and current char + 1
str_current_letter = source[current_set][current_file][current_str][current_char];
if((current_char + 1) <= source[current_set][current_file][current_str].length())
{
str_letter_p1 = source[current_set][current_file][current_char + 1];
}
if((current_char + 2) <= source[current_set][current_file][current_str].length())
{
str_letter_p2 = source[current_set][current_file][current_char + 2];
}
if((current_char + 1) >= source[current_set][current_file][current_str].length())
{
str_letter_m1 = source[current_set][current_file][current_char - 1];
}
if((current_char + 2) >= source[current_set][current_file][current_str].length())
{
str_letter_m2 = source[current_set][current_file][current_char - 1];
}
for(signed long long int current_letter = 0; current_letter < alphabet_str.size(); current_letter++)
{
if(str_current_letter == alphabet_str[current_letter])
{
is_a_letter = true;
}
}
if(is_a_letter == true)
{
command_word_str = command_word_str + str_current_letter;
if(current_letter == source[current_set][current_file][current_str].size())
{
symbol_vector.push_back("command: " + command_word_str);
command_word_vector.push_back(command_word_str);
command_word_str.clear();
}
for(signed long long int current_letter = 0; current_letter < alphabet_str.size(); current_letter++)
{
if(str_current_letter == alphabet_str[current_letter])
{
p1_is_letter == true;
}
}
if(p1_is_letter == false)
{
symbol_vector.push_back("command: " + command_word_str);
command_word_vector.push_back(command_word_str);
command_word_str.clear();
}
}
if(str_current_letter == left_parentheses_str)
{
if(str_letter_m1 == escape_code_str)
{
escape_codes_found = true;
escape_code_count = escape_code_count + 1;
esc_left_parentheses_found = true;
symbol_vector.push_back("esc_left_parentheses");
esc_left_parentheses_count = esc_left_parentheses_count + 1;
} else {
symbol_vector.push_back("syntax_left_parentheses");
left_parentheses_found = true;
left_parentheses_count = left_parentheses_count + 1;
}
}
if(str_current_letter == right_parentheses_str)
{
if(str_letter_m1 == escape_code_str)
{
symbol_vector.push_back("esc_right_parentheses");
esc_right_parentheses_found = true;
escape_codes_found = true;
} else {
symbol_vector.push_back("syntax_right_parentheses");
right_parentheses_found = true;
}
}
if(str_current_letter == semicolon_str)
{
if(current_char - 1 > 0)
{
if(str_letter_m1 == escape_code_str)
{
escape_codes_found = true;
escape_code_count = escape_code_count + 1;
symbol_vector.push_back("esc_semicolon");
esc_semicolon_found = true;
} else {
semicolon_found = true;
semicolon_count = semicolon_count + 1;
symbol_vector.push_back("syntax_semicolon");
} else {
semicolon_found = true;
semicolon_count = semicolon_count + 1;
symbol_vector.push_back("syntax_semicolon");
}
}
}
if(str_current_letter == quote_str)
{
if(current_char - 1 > 0)
{
if(str_letter_m1 == escape_code_str)
{
escape_codes_found = true;
escape_code_count = escape_code_count + 1;
symbol_vector.push_back("esc_quote");
esc_quote_found = true;
} else {
quote_found = true;
quote_count = quote_count + 1;
symbol_vector.push_back("syntax_quote");
}
} else {
quote_found = true;
quote_count = quote_count + 1;
symbol_vector.push_back("syntax_quote");
}
}
if(str_current_letter == comma_str)
{
if(current_char - 1 > 0)
{
if(str_letter_m1 == escape_code_str)
{
escape_codes_found = true;
escape_code_count = escape_code_count + 1;
symbol_vector.push_back("esc_comma");
esc_comma_found = true;
} else {
comma_found = true;
comma_count = comma_count + 1;
symbol_vector.push_back("syntax_comma");
}
} else {
comma_found = true;
comma_count = comma_count + 1;
symbol_vector.push_back("syntax_comma");
}
}
if(str_current_letter == left_bracket_str)
{
if(str_letter_m1 == escape_code_str)
{
escape_codes_found = true;
escape_code_count = escape_code_count + 1;
symbol_vector.push_back("esc_left_bracket");
esc_left_bracket_found = true;
} else {
left_bracket_found = true;
left_bracket_count = left_bracket_count + 1;
symbol_vector.push_back("left_bracket");
}
}
if(str_current_letter = right_bracket_str)
{
if(current_char - 1 > 0)
{
if(str_letter_m1 == escape_code_str)
{
escape_codes_found = true;
escape_code_count = escape_code_count + 1;
symbol_vector.push_back("esc_right_bracket");
esc_left_bracket_found = true;
} else {
right_bracket_found = true;
right_bracket_count = right_bracket_count + 1;
symbol_vector.push_back("syntax_right_bracket");
}
}
}
if(str_current_letter == "<")
{
if(current_char - 1 > 0)
{
if(str_letter_m1 == escape_code_str)
{
// escape!
escape_codes_found = true;
escape_code_count = escape_code_count + 1;
symbol_vector.push_back("esc_left_arrow");
esc_left_arrow_found = true;
} else {
left_arrow_found = true;
left_arrow_count = left_arrow_count + 1;
symbol_vector.push_back("syntax_left_arrow");
}
}
}
if(str_current_letter == ">")
{
if(current_char - 1 > 0)
{
if(str_letter_m1 == escape_code_str)
{
// escape!
escape_codes_found = true;
escape_code_count = escape_code_count + 1;
symbol_vector.push_back("esc_right_arrow");
esc_right_arrow_found = true;
} else {
right_arrow_found = true;
right_arrow_count = right_arrow_count + 1;
symbol_vector.push_back("syntax_right_arrow");
}
}
}
if(str_current_letter == "#")
{
if(current_char - 1 > 0)
{
if(str_letter_m1 == escape_code_str)
{
escape_codes_found = true;
escape_code_count = escape_code_count + 1;
symbol_vector.push_back("esc_shebang");
esc_shebang_found = true;
} else {
shebang_found = true;
shebang_count = shebang_count + 1;
symbol_vector.push_back("syntax_shebang");
}
}
}
if(str_current_letter == "/")
{
if(current_char - 1 > 0)
{
if(str_letter_m1 == escape_code_str)
{
escape_codes_found = true;
escape_code_count = escape_code_count + 1;
symbol_vector.push_back("esc_comment_slash");
esc_comment_slash_found = true;
} else {
comment_slash_found = true;
comment_slash_count = comment_slash_count + 1; // divide by two!
symbol_vector.push_back("syntax_comment_slash");
}
}
}
if(str_current_letter == "$")
{
if(current_char - 1 > 0)
{
if(str_letter_m1 == escape_code_str)
{
escape_codes_found = true;
escape_code_count = escape_code_count + 1;
symbol_vector.push_back("esc_dollar_sign");
esc_dollar_sign_found = true;
} else {
dollar_sign_found = true;
dollar_sign_count = dollar_sign_count + 1;
symbol_vector.push_back("syntax_dollar_sign");
}
}
}
if(str_current_letter == "*")
{
if(current_char - 1 > 0)
{
if(str_letter_m1 == escape_code_str)
{
escape_codes_found = true;
escape_code_count = escape_code_count + 1;
symbol_vector.push_back("esc_asterisk");
esc_asterisk_found = true;
} else {
asterisk_found = true;
asterisk_count = asterisk_count + 1;
}
}
if(str_current_letter == escape_code_str)
{
symbol_vector.push_back("syntax_escape_code");
}
}
}
}
}
run_compiler = false;
}
halt_compilation = false;
if(left_parentheses_found == false)
{
satellite.orbital_compiler->call_display_str("left_parentheses not found, and they are needed in every satellite program, the left parentheses is at least in the declaration of main() with the line: capsule main(){} where between the brackets {} goes the program, and between () goes the name of the vector of strings that will receive your arguments passed by the operating system. So it will look like this: capsule main(vector<string> argz) where argz is whatever name you want, you just have to have a vector of strings if you want to receive the values from the operating system, passed to your program by satellite. See also help(syntax); from the console\n\n");
std::cout << "error! left_parentheses not found. Every satellite program has a \"main\" capsule, and that main capsule is defined via writing two parentheses after the word \"main\". Like this: capsule main() the next line should be a left bracket { and then to close the capsule, a right_bracket. These, the parentheses and the brackets are non-negotiable in a satellite program, they have to have them. Then of course there is return(satellite); at the end of the main capsule, that too is non negotiable. See also the smallest possible program, but you want to learn to code so visit help(\"language\") for a semi-complete definition of satellite. See also help(syntax); from the console\n";
halt_compilation = true;
}
if(right_parentheses_found == false)
{
satellite.orbital_compiler->call_display_str("right_parentheses was not found in your program, and right_parenthese are needed in at least two places, in the declaration of the start of the program, where it\'s like this: capsule main() but here\'s an example full program;\n\n#include <satellite>\n\ncapsule main()\n{\n\tdisplay(\"hello, world!\");\n\n\treturn(satellite);\n} \n\n And that is the smallest program you can have, besides taking out the display(); call.\n\n");
std::cout << "error in compilation! A right_parentheses character was not found! All satellite programs contain at least one right_parentheses, in the definition for the \"main\" function -- like this: capsule main() and that starts the main function or \"capsule\". See also help(syntax); from the console\n";
halt_compilation = true;
}
if(semicolon_found == false)
{
satellite.orbital_compiler->call_display_str("No semicolon was found in your program, and that is an error. Compilation cannot continue. You should at least have a semicolon at the end of your program in the line return(satellite); to end the program and return the language! See also help(syntax); from the console\n";
std::cout << "error no semicolon found, compilation cannot continue. Every satellite program has a semicolon, at least in the smallest possible program is the line: return(satellite); to end the program. This is non-negotiable in a satellite program, and that line ends in a semicolon as you can see. See also help(syntax); from the console\n";
halt_compilation = true;
}
if(quote_found == false)
{
satellite.orbital_compiler->call_display_str("no quotes were found in your program, but were you trying to denote a string? In satellite, strings are denoted by quotes, like this my_var = "my_value"; where my_value is the string that you want to write. See also help(syntax); from the console.\n");
std::cout << "your program didn\'t have quotes but, were you giving a string as an argument to a particular capsule? If you were, then you must have quotes to denote that it is a string and not a function or variable name. See also help(syntax); from the console\n";
}
if(comma_found == false)
{
satellite.orbital_compiler->call_display_str("no commas were found in your program, but this is not an error in satellite. The smallest possible program doesn\'t include a comma, so technically yours doesn\'t either, unless you want to have multiple arguments to one function or capsule. See also help(syntax); from the console");
std::cout << "commas are not needed in your program, but you may need to give multiple arguments sometime and use commas, commas are also used in other syntax aspects. You can read the whole story at help(syntax) or help(language) for two different pieces of text brought to you by the console. You must quit the compiler to go to the console and have access to the documentation, the compiler doesn\'t have access to the documents of the satellite help system, but the console does. See also help(syntax); from the console\n\n";
}
if(left_bracket_found == false)
{
halt_compilation = true;
satellite.orbital_compiler->call_display_str("a left_bracket was not found in your program, and they are required for at least the minimum satellite program, you can\'t just enter anything. The left_bracket goes after the definition of your main capsule like this: \n\ncapsule main()\n{\n\n\nAnd that is the start of your program, with the end being a right_bracket, which you also need, compiler halted! see also help(syntax) and help(language); from the console. The compiler doesn\'t have access to the help system, but the console does.\n\n";
std::cout << "Your error of not having a left_bracket has halted the compiler, add a left_bracket in the appropriate place, (the end of your program,) and then start the compilation process again.\n\n";
}
if(right_bracket_found == false)
{
halt_compilation = true;
satellite.orbital_compiler->call_display_str("right_bracket not found at the end of your program. You must have a right_bracket to close capsule main() and any other functions you may be using. Because you don\'t have a right_bracket the compiler cannot build your program.\n\n");
std::cout << "compiler halted. Add a right_bracket }} to your program at the end, there will always be a right_bracket at the end of every program because every function or capsule ends in a right_bracket. There isn\'t code allowed in places outside of functions (capsules).\n\n";
}
if(halt_compilation == false)
{
// begin to compile...
std::bitset<32> include_satellite = 0b00000000000000000000000000000001;
// syntax rules...
/*
syntax rules are a type of data for at least the compiler and the VM, because
they are the pieces of the syntax of your program, for example include satellite
is 0000000..1 in bits. It means that the program has include <satellite> and it
is compiled. So syntax rule #00000..1 is #include <satellite>
syntax rule #2 is 00000...10 and that is capsule main, which sometimes takes arguments.
this isn't making any sense god damnit
*/
/*
// let's define the datatypes:
void 00000000 (invalid)
string 00000001
integer 00000010
float 00000011
syntax 00000100
source 00000101
bytecode 00000111
and that is the data types currently available to the compiler!
so a piece of data contains it's type which is above,
then what else does it contain, it's "data" and that's all ?
What else might the data be made up of? So bytecode will hold information
like the variables name, and value and stuff, but the actual datatypes that that
is made up of do not contain this information.
OH
HOW LONG THE DATA IS, how many 512-bit chunks is the data?
For length, we will use a 64-bit number... That means that the data length
has a limit of 18,446,744,073,709,551,616, or forever and ever.
And for type we will use a 16 bit number, and what else might we store in
the other 16 bits to make a 96-bits of data used uP? What data might we hold,
like a system_id in the other 16-bits of data. So that's 96-bits, and that leaves us with... 12... 4... 416-bits of data per 512-bit chunk,
some say that's way to big, but I say that it's what's processors are going to be doing in a few years, they will be using 512-bit chunks of data.
So 64-bit length of the program, then a 16-bit data type and a 16-bit system_id, I guess, or a 32-bit datatype, but we don't need that
many datatypes, it's so fuckin confusing!
add chunk number to the 512-bit sequence, so if it's chunk 2 of 7, it would have the number 2 stored in it, which chunk it is? maybe? no?
*/
for(signed long long int current_symbol = 0; current_symbol < symbol_vector.size(); current_symbol++)
{
if(symbol_vector[current_symbol].substr(0, 6) == "command")
{
// command word
// a command word in source takes up a 512-bit chunk, and
// it is denoted by
// first is #include <satellite>
} // end the compiler
if(left_parentheses_found == true && right_parentheses_found == true)
{
std::cout << "two parentheses good";
} else {
std::cout << "there was an error, you have a left_parentheses in front of a right_parentheses...\n";
std::cout << "therefore we cannot process your input!\n";
}
// now we return satellite
return(satellite);
}
#endifThat was so much work, it took me like 24 hours of programming, over the course of 4 days to make it. But I cannot really repeat that, it’s hard to do that, and that 24 hours was the exception, not the standard. Or however that saying goes, let’s listen to kool and the gang
OH I have one thing on my warez site so far, it’s Almalinux 9.5, and that is not even really warez because you can download it already, but there’s a tutorial on how to set up almalinux on the page of the download, if you can’t find it just search for “Almalinux”
I just put a tutorial on my site, orbit1.cloud how to install almalinux. Go there and get yourself almalinux, the only reason I don’t use almalinux is because my printer won’t work with it, so I have to take my second choice, Ubuntu Mate or Debian Mate. I would really use Almalinux, but I have to have a printer so I can print out source code, so if my computer crashes, I have a physical copy of the source code and I don’t lose it, it’s kinda hard to lose a physical copy of something, versus digital you press the wrong button, or try the wrong thing, and you lose everything on that drive, you have to keep like 3 drives I think it’s easier to just print it out, then you know your going to have it.
