void main()
{
int i = 0;
while (i < 8) {
print(a[i]);
i = i + 1;
}
print_newline();
int b[size];
b[0] = 0;
b[1] = 1;
b[2] = 2;
b[3] = 3;
b[4] = 4;
i = 0;
while (i < size) {
print(b[i]);
i = i + 1;
}
print_newline();
}
int demander(){
int nb_choosen_by_user;
print_text("Veuillez entrez un entier entre 1 et 10000 : ");
print_newline();
print_newline();
nb_choosen_by_user=read_int();
return nb_choosen_by_user;
}
int verifier(int nb_a_verifier){
int nbmodifiable=nb_a_verifier;
while((nbmodifiable<1)||(nbmodifiable>10000)){
print_text("Fais pas chier rentres un nombre valable ");
print_newline();
print_newline();
nbmodifiable=read_int();
print_newline();}
return nbmodifiable;}
void ir_stmt_seq::print(std::ostream& s, const uint tab) const
{
s << "SEQ(";
print_newline(s, tab+1);
s_left->print(s, tab+1);
s << ",";
print_newline(s, tab+1);
s_right->print(s, tab+1);
print_newline(s, tab);
s << ")";
}
void start_rule_callback(struct gzl_parse_state *parse_state)
{
struct gzl_buffer *buffer = (struct gzl_buffer*)parse_state->user_data;
struct gzlparse_state *user_state = (struct gzlparse_state*)buffer->user_data;
struct gzl_parse_stack_frame *frame = DYNARRAY_GET_TOP(parse_state->parse_stack);
assert(frame->frame_type == GZL_FRAME_TYPE_RTN);
struct gzl_rtn_frame *rtn_frame = &frame->f.rtn_frame;
print_newline(user_state, false);
print_indent(user_state);
char *rule = get_json_escaped_string(rtn_frame->rtn->name, 0);
printf("{\"rule\":%s, \"start\": %zu, \"line\": %zu, \"column\": %zu, ",
rule, frame->start_offset.byte,
frame->start_offset.line, frame->start_offset.column);
free(rule);
if(parse_state->parse_stack_len > 1)
{
frame--;
struct gzl_rtn_frame *prev_rtn_frame = &frame->f.rtn_frame;
char *slotname = get_json_escaped_string(prev_rtn_frame->rtn_transition->slotname, 0);
printf("\"slotname\":%s, \"slotnum\":%d, ",
slotname, prev_rtn_frame->rtn_transition->slotnum);
free(slotname);
}
printf("\"children\": [");
RESIZE_DYNARRAY(user_state->first_child, user_state->first_child_len+1);
*DYNARRAY_GET_TOP(user_state->first_child) = true;
}
void terminal_callback(struct gzl_parse_state *parse_state,
struct gzl_terminal *terminal)
{
struct gzl_buffer *buffer = (struct gzl_buffer*)parse_state->user_data;
struct gzlparse_state *user_state = (struct gzlparse_state*)buffer->user_data;
struct gzl_parse_stack_frame *frame = DYNARRAY_GET_TOP(parse_state->parse_stack);
assert(frame->frame_type == GZL_FRAME_TYPE_RTN);
struct gzl_rtn_frame *rtn_frame = &frame->f.rtn_frame;
print_newline(user_state, false);
print_indent(user_state);
char *terminal_name = get_json_escaped_string(terminal->name, 0);
int start = terminal->offset.byte - buffer->buf_offset;
assert(start >= 0);
assert(start+terminal->len <= buffer->buf_len);
char *terminal_text = get_json_escaped_string(buffer->buf+
(terminal->offset.byte - buffer->buf_offset),
terminal->len);
char *slotname = get_json_escaped_string(rtn_frame->rtn_transition->slotname, 0);
printf("{\"terminal\": %s, \"slotname\": %s, \"slotnum\": %d, \"byte_offset\": %zu, "
"\"line\": %zu, \"column\": %zu, \"len\": %zu, \"text\": %s}",
terminal_name, slotname, rtn_frame->rtn_transition->slotnum,
terminal->offset.byte, terminal->offset.line, terminal->offset.column,
terminal->len, terminal_text);
free(terminal_name);
free(terminal_text);
free(slotname);
}
troisdes rejouer(troisdes idk){
troisdes ikn=idk;
int x;
aff_des(idk);
print_newline();
print_newline();
print_text("voulez vous garder ");
print_int(ikn.d1);
print_text(" [oui/non] [0/1] ?: ");
x=read_int();
if(x==1)
ikn.d1=alea(1,6);
else
ikn.d1=ikn.d1;
print_text("voulez vous garder ");
print_int(ikn.d2);
print_text(" [oui/non] [0/1] ?: ");
x=read_int();
if(x==1)
ikn.d2=alea(1,6);
else
ikn.d2=ikn.d2;
print_text("voulez vous garder ");
print_int(ikn.d3);
print_text(" [oui/non] [0/1] ?: ");
x=read_int();
if(x==1)
ikn.d3=alea(1,6);
else
ikn.d3=ikn.d3;
return ikn;
}
void test_setup()
{
if (!test_failed)
print_newline();
test_tests_executed++;
test_failed = 0;
}
void print_seperator()
{
int i = 0;
for (; i < 80; i++)
putchar('=');
print_newline();
}
void main()
{
int a = 1;
int b = 2;
if (a < b)
print(a);
else
print(b);
print_newline();
int i = 0;
while (i < 8) {
print(i);
print_space();
i = i + 1;
}
print_newline();
}
static void interpret_command(const char* cmd)
{
if (!strcmp(cmd, "HELO")) {
uart_putstring_P(PSTR("O HAI," FIRMWARE_REVISION_STR ",42\n"));
} else if (!strcmp(cmd, "STATUS")) {
uart_print_number(battery_get_voltage()); uart_putchar(',');
uart_print_number(get_uptime_seconds()); uart_putchar(',');
struct LogInfo info;
logging_get_info(LOG_EEPROM, &info);
uart_print_number(info.id); uart_putchar(',');
uart_print_number(info.length); uart_putchar(',');
uart_print_number(info.res); uart_putchar(',');
logging_get_info(LOG_SRAM, &info);
uart_print_number(info.id); uart_putchar(',');
uart_print_number(info.length); print_newline();
} else if (!strcmp(cmd, "CLOG")) {
logging_reset_all();
uart_putstring_P(PSTR("OK\n"));
} else if (!strcmp(cmd, "SILENT")) {
silent = 1;
uart_putstring_P(PSTR("OK\n"));
} else if (!strcmp(cmd, "NOISY")) {
silent = 0;
uart_putstring_P(PSTR("OK\n"));
} else if (!strcmp(cmd, "RSLOG") || !strcmp(cmd, "REELOG")) {
LogEntry e = (cmd[1] == 'E') ? LOG_EEPROM : LOG_SRAM;
logging_fetch_log(e, print_number_uint16, print_newline);
} else if (!strcmp(cmd, "GETID")) {
uart_print_number(nv_read_word(ADDR_device_id));
print_newline();
} else if (!strncmp(cmd, "SID ", 4)) {
uint16_t value = 0;
for (uint8_t i = 4; cmd[i]; i++)
value = value * 10 + (cmd[i] - '0');
nv_update_word(ADDR_device_id, value);
uart_putstring_P(PSTR("OK\n"));
} else {
uart_putstring_P(PSTR("Unknown command!\n"));
}
}
int main(void)
{
print_seperator();
printf("Test: libsimplestack\n");
test_run();
print_newline();
test_print_result();
return 0;
}
void end_rule_callback(struct gzl_parse_state *parse_state)
{
struct gzl_buffer *buffer = (struct gzl_buffer*)parse_state->user_data;
struct gzlparse_state *user_state = (struct gzlparse_state*)buffer->user_data;
struct gzl_parse_stack_frame *frame = DYNARRAY_GET_TOP(parse_state->parse_stack);
assert(frame->frame_type == GZL_FRAME_TYPE_RTN);
RESIZE_DYNARRAY(user_state->first_child, user_state->first_child_len-1);
print_newline(user_state, true);
print_indent(user_state);
printf("], \"len\": %zu}", parse_state->offset.byte - frame->start_offset.byte);
}
int main() {
printf("Built-in types:\n");
print_type_size(char);
print_type_size(signed char);
print_type_size(unsigned char);
print_newline();
print_type_size(short);
print_type_size(unsigned short);
print_newline();
print_type_size(int);
print_type_size(unsigned int);
print_newline();
print_type_size(long);
print_type_size(unsigned long);
print_newline();
print_type_size(long long);
print_type_size(unsigned long long);
print_newline();
print_type_size(float);
print_type_size(double);
print_type_size(long double);
print_newline();
print_type_size(void *);
print_type_size(function_pointer);
print_newline();
printf("stdint.h types:\n");
print_type_size(int8_t);
print_type_size(uint8_t);
print_type_size(int16_t);
print_type_size(uint16_t);
print_type_size(int32_t);
print_type_size(uint32_t);
print_type_size(int64_t);
print_type_size(uint64_t);
print_newline();
print_type_size(size_t);
return EXIT_SUCCESS;
}
/*
* Print a line break if required and possible
* - n = size of the next token
*/
static void check_newline(printer_t *p, uint32_t n) {
if (p->no_break ||
p->line + 1 == p->area.height ||
p->overfull_count > 0) {
// a line break is not allowed
return;
}
switch (p->mode) {
case PP_HMODE:
break; // do nothing
case PP_VMODE:
print_newline(p);
break;
case PP_HVMODE:
if (p->col + n + (!p->no_space) > p->margin) {
// the next token doesn't fit on this line
print_newline(p);
}
break;
}
}
int main()
{
struct Student *stuArray[5];
struct Student s0, s1, s2, s3, s4;
stuArray[0] = &s0;
stuArray[1] = &s1;
stuArray[2] = &s2;
stuArray[3] = &s3;
stuArray[4] = &s4;
// init
int i = 0;
while (i < 5) {
stuArray[i]->id = i;
stuArray[i]->score = 100 * i;
stuArray[i]->name = 'e' - i;
i = i + 1;
}
stuArray[3]->score = 175;
stuArray[1]->score = 450;
stuArray[0]->score = 333;
sort(stuArray, compareById);
showStructArray(stuArray);
print_newline();
sort(stuArray, compareByScore);
showStructArray(stuArray);
print_newline();
sort(stuArray, compareByName);
showStructArray(stuArray);
print_newline();
}
inline void
print_nested(Printer& p, T const& range)
{
auto first = range.begin();
auto last = range.end();
// Don't print anything for empty ranges.
if (first == last)
return;
indent(p);
print_newline(p);
while (first != last) {
if (std::next(first) != last) {
print(p, *first);
print_newline(p);
} else {
print(p, *first);
}
++first;
}
undent(p);
print_newline(p);
}
// Emit a new basic block.
void
llvm_stmt(Printer& p, Block_stmt const* s)
{
// FIXME: Generate a unique integer id for each block within
// the current function. Right now we're just using the pointer
// value, which is unique but uninteresting.
//
// Print the label in the first column.
print(p, '\n');
print(p, "bb{}:", (std::uintptr_t)s);
// Print each statement in turn.
for (Stmt const* s1 : s->statements()) {
print_newline(p);
llvm_stmt(p, s1);
}
}
void sp_process()
{
char c;
while((c = serialRead()) != -1)
{
if((char_counter > 0) && ((c == '\n') || (c == '\r'))) { // Line is complete. Then execute!
line[char_counter] = 0; // treminate string
printString(line); print_newline();
status_message(gc_execute_line(line));
char_counter = 0; // reset line buffer index
} else if (c <= ' ') { // Throw away whitepace and control characters
} else if (c >= 'a' && c <= 'z') { // Upcase lowercase
line[char_counter++] = c-'a'+'A';
} else {
line[char_counter++] = c;
}
}
}
/*
* Main routine of the zfcpdump tool
*/
int main(int UNUSED(argc), char *UNUSED(argv[]))
{
int rc;
if (zfcpdump_init(module_list))
return terminate(1);
PRINT("Dump parameters:\n");
PRINT(" devno....: %s\n", g.dump_devno);
PRINT(" wwpn.....: %s\n", g.dump_wwpn);
PRINT(" lun......: %s\n", g.dump_lun);
PRINT(" conf.....: %s\n", g.dump_bootprog);
if (get_scsi_dump_params())
return terminate(1);
print_newline();
PRINT("Writing dump:\n");
rc = copy_dump("/proc/vmcore", DEV_SCSI,
dump_sb.part_start + dump_sb.dump_off);
return terminate(rc);
}
int main(){
int nombreutilisateur,nombreverifie,nombrealeatoire;
bool victoire=false;
int compteur=0,rejouer;
nombrealeatoire = alea(1,10000);
while(victoire==false){
nombreutilisateur = demander();
print_newline();
print_newline();
nombreverifie = verifier(nombreutilisateur);
victoire = comparer(nombreverifie,nombrealeatoire);
compteur = compteur+1;}
print_text("Vous avez trouvé la solution en ");
print_int(compteur);
print_text(" coups");
print_newline();
print_newline();
print_text("Voulez vous rejouer ? : Oui ? tapez(1), Non ? tapez (2) : ");
print_newline();
print_newline();
rejouer=read_int();
if(rejouer==1){main();}
else{print_text("Au revoir !"); print_newline();print_newline();}
return 0;}
void keyboard_main( ){
char status;
char key_code;
out_port(0x20, 0x20);
status = in_port(0x64); // io pressed key port for keyboards
if (status & 0x01) {
key_code = in_port(0x60); // io status key port for keyboard
if(key_code < 0)
return;
if(key_code == 0x1C) { // check if it's the enter key that was pressed
print_newline();
return;
}
VGA[curr_loc++] = keyboard_map[(unsigned char) key_code];
VGA[curr_loc++] = 0x07;
}
}
bool comparer(int nombre_a_comparer, int nb_genere_aleatoirement){
bool gagne_ou_pas;
if(nb_genere_aleatoirement < nombre_a_comparer){
print_text("Le nombre mysterieux est plus petit que le nombre entré");
print_newline();
print_newline();
gagne_ou_pas=false;}
else if(nb_genere_aleatoirement > nombre_a_comparer){
print_text("Le nombre mysterieux est plus grand que le nombre entré");
print_newline();
print_newline();
gagne_ou_pas=false;}
else{
print_text("Vous avez gagné");
print_newline();
print_newline();
gagne_ou_pas=true;}
return gagne_ou_pas;}
int managed_find_word(const char *word, const regimen_t regimen, const char *dicts_list)
{
FILE *dict_fp;
char dict_name[PATH_MAX];
int retcode = 0;
bool no_translate_flag = true;
bool no_dicts_flag = true;
extern settings_t settings;
print_begin_page(word);
while ( true ) {
if ( dicts_list == NULL )
dict_fp = next_dict_from_dir(dict_name);
else
dict_fp = next_dict_from_list(dict_name, dicts_list);
if ( dict_fp == NULL )
break;
if ( !no_translate_flag )
print_newline();
if ( (retcode = find_word(word, regimen, dict_name, dict_fp)) > 0 ) {
no_translate_flag = false;
retcode = 0;
}
if ( fclose(dict_fp) != 0 )
fprintf(stderr, "Cannot close dict file \"%s\": %s\n", dict_name, strerror(errno));
no_dicts_flag = false;
}
if ( no_translate_flag && regimen == usually_regimen && !no_dicts_flag ) {
while ( true ) {
if ( dicts_list == NULL )
dict_fp = next_dict_from_dir(dict_name);
else
dict_fp = next_dict_from_list(dict_name, dicts_list);
if ( dict_fp == NULL )
break;
if ( !no_translate_flag )
print_newline();
if ( (retcode = find_word(word, first_concurrence_regimen, dict_name, dict_fp)) > 0 ) {
no_translate_flag = false;
retcode = 0;
}
if ( fclose(dict_fp) != 0 )
fprintf(stderr, "Cannot close dict file \"%s\": %s\n", dict_name, strerror(errno));
}
}
if ( no_translate_flag ) {
switch ( settings.output_format ) {
case html_output_format : fprintf(stderr, "\t<font class=\"info_font\">This word is not found</font><br>\n"); break;
case text_output_format :
case native_output_format : fprintf(stderr, "This word is not found\n"); break;
}
}
if ( no_dicts_flag ) {
switch ( settings.output_format ) {
case html_output_format : fprintf(stderr, "\t<font class=\"info_font\">No dict is connected</font><br>"); break;
case text_output_format :
case native_output_format : fprintf(stderr, "No dict is connected\n"); break;
}
}
if ( !no_translate_flag && !no_dicts_flag )
print_separator();
print_end_page();
return retcode;
}
void tour_de_jeu(){
troisdes t;
int point;
int x;
print_newline();
print_newline();
print_newline();
print_text("Lancer Initial : ");
t=trie(lancer());
aff_des(t);
print_text("->");
point=valeur(t);
print_int(point);
print_newline();
print_newline();
print_newline();
print_text("Vous gardez [0] ou vous relancez [1]? [Oui/Non]: ");
x=read_int();
print_newline();
print_newline();
print_newline();
if (x==0){
}
else{
t=rejouer(t);
print_newline();
print_newline();
print_newline();
print_text("Deuxieme Lancer : ");
t=trie(t);
aff_des(t);
print_text ("->");
point=valeur(t);
print_int(point);
print_newline();
print_newline();
print_newline();
print_text("Vous gardez [0] ou vous relancez [1] [Oui/Non]: ");
x=read_int();
print_newline();
print_newline();
print_newline();}
if (x==0){
aff_des(t);
print_text("->");
point=valeur(t);
print_int(point);
print_newline();}
else{
t=rejouer(t);
t=trie(t);
print_newline();
print_newline();
aff_des(t);
print_text("->");
point=valeur(t);
print_int(point);
print_newline();
print_newline();
}
}
void sp_millInfo()
{
printPgmString(PSTR("\r\nMezzoMill "));
printPgmString(PSTR(MM_VERSION));
print_newline();
}
void main(void)
{
//variables
uint8 STA013 = 0x43;
uint16 timeout_val = 600;
uint16 timeout;
uint8 error = 0;
uint8 I2C_data_array[2];
uint8 * config_array;
uint32 index = 0;
// Access more RAM
AUXR = 0x0C;
// Uart at 9600 baud
uart_init();
P3_3 = 0;
// Test code from step 4
// of the experiment
timeout=timeout_val;
do
{
I2C_data_array[0] = 0x01;
error = I2C_Write( STA013, 1, I2C_data_array );
if (error==1)
{
// Bus busy error
printf("Write - Bus Busy Error");
print_newline();
}
if (error==2)
{
// NACK error
printf("Write - NACK Error");
print_newline();
}
timeout--;
}while((error!=0)&&(timeout!=0));
if(timeout!=0)
{
timeout=timeout_val;
do
{
error=I2C_Read( STA013, 1, I2C_data_array );
switch( error )
{
case 0:
break;
case 1:
printf("I2C Read Error: Bus Busy");
print_newline();
break;
case 2:
printf("I2C Read Error: Slave Device timeout");
print_newline();
break;
case 3:
printf("I2C Read Error: Improper ACK");
print_newline();
break;
default:
printf("Unspecified Error");
print_newline();
break;
}
timeout--;
}while((error!=0)&&(timeout!=0));
printf("I2C Read: %2.2bX", I2C_data_array[0]);
print_newline();
}
else
{
printf("timeout error\n\r");
}
//Sending patch file CONFIG to STA013
config_array = &CONFIG;
printf("Sending CONFIG... ");
while ( I2C_data_array[0] != 0xFF )
{
error = I2C_Write( STA013, 2, I2C_data_array );
if ( error != 0 )
{
printf("I2C Write Error %bu", error);
print_newline();
}
I2C_data_array[0] = config_array[index];
index++;
I2C_data_array[1] = config_array[index];
index++;
}
delay(1);
printf("Complete");
print_newline();
index = 0;
//Sending patch file CONFIG2
config_array = &CONFIG2;
printf("Sending CONFIG2... ");
while ( I2C_data_array[0] != 0xFF )
{
error = I2C_Write( STA013, 2, I2C_data_array );
if ( error != 0 )
{
printf("I2C Write Error %bu", error);
print_newline();
}
I2C_data_array[0] = config_array[index];
index++;
I2C_data_array[1] = config_array[index];
index++;
}
printf("Complete");
print_newline();
index = 0;
//Sending patch file CONFIG3
config_array = &CONFIG3;
printf("Sending CONFIG3... ");
while ( I2C_data_array[0] != 0xFF )
{
error = I2C_Write( STA013, 2, I2C_data_array );
if ( error != 0 )
{
printf("I2C Write Error %bu", error);
print_newline();
}
I2C_data_array[0] = config_array[index];
index++;
I2C_data_array[1] = config_array[index];
index++;
}
printf("Complete");
print_newline();
P3_3 = 1;
while (1)
{
}
}
int main(int argc, char *argv[]) {
int runtest = 0;
int pretty_print = 0;
char *encrypt = NULL, *decrypt = NULL, *key = NULL, *text = NULL, *crack = NULL, *lang = "cs";
const char *output;
int c;
const int ciphers_count = 3;
const cipherfun encfuns[] = {caesar_encrypt, substitution_encrypt, vigenere_encrypt};
const cipherfun decfuns[] = {caesar_decrypt, substitution_decrypt, vigenere_decrypt};
const crack_cipher crackfun[] = {caesar_crack, caesar_crack, vigenere_brute};
const char* cipher_names[] = {"caesar", "subs", "vig"};
const char* languages[] = {"cs", "en"};
const int lang_count = 2;
const LangStats *stats;
Keytext result;
opterr = 0;
while ((c = getopt(argc, argv, "upe:d:k:c:l:")) != -1) {
switch(c) {
case 'u':
runtest = 1;
break;
case 'e':
encrypt = optarg;
break;
case 'd':
decrypt = optarg;
break;
case 'k':
key = optarg;
break;
case 'c':
crack = optarg;
break;
case 'p':
pretty_print = 1;
break;
case 'l':
for (int i = 0; i < lang_count; i++) {
if (strcmp(optarg, languages[i]) == 0) {
lang = optarg;
break;
}
}
break;
default:
fprintf(stderr, "Unknow argument -%c.", c);
exit(EXIT_FAILURE);
}
}
if (encrypt != NULL || decrypt != NULL || crack != NULL) {
if (encrypt != NULL || decrypt != NULL) {
if (key == NULL) {
fprintf(stderr, "Error: Key is missing\n");
exit(EXIT_FAILURE);
}
}
if (argc <= optind) {
fprintf(stderr, "Error: Input text missing.\n");
exit(EXIT_FAILURE);
} else {
text = argv[optind];
}
if (encrypt != NULL) {
output = get_cipher_fun(cipher_names, encfuns, encrypt, ciphers_count)(text, key);
}
if (decrypt != NULL) {
output = get_cipher_fun(cipher_names, decfuns, decrypt, ciphers_count)(text, key);
}
if (crack != NULL) {
stats = default_stats(lang);
result = get_crack_fun(cipher_names, crackfun, crack, ciphers_count)(text, stats);
if (result.key[0] != '?') {
output = result.key;
} else {
output = "Cracking was not successful.";
}
}
printf("%s", output);
print_newline(pretty_print);
}
if (runtest) {
run_all_tests();
}
return 0;
}
void Parser::print_block(std::ostream& iStream, unsigned char* iBlock, unsigned int iSize) {
unsigned char tIndentation = 1;
print_indentation(iStream, tIndentation);
unsigned int tLoc = 0;
bool tPrevArgEnd = false;
while (tLoc < iSize) {
// Syntax
if (mGrammar->isSyntax(iBlock[tLoc])) {
switch (iBlock[tLoc]) {
case ARG_OPEN:
iStream << "(";
break;
case ARG_SEP:
iStream << ", ";
break;
case ARG_CLOSE:
iStream << ")";
tPrevArgEnd = true;
break;
case INSTR_OPEN:
if (tPrevArgEnd) {
iStream << " ";
tPrevArgEnd = false;
}
iStream << "{";
tIndentation++;
print_newline(iStream, tIndentation);
break;
case INSTR_SEP:
iStream << ";";
print_newline(iStream, tIndentation);
break;
case INSTR_CLOSE:
tIndentation--;
if (tPrevArgEnd) {
iStream << ";";
tPrevArgEnd = false;
}
print_newline(iStream, tIndentation);
iStream << "}";
break;
}
}
// Conditional
else if (mGrammar->isConditional(iBlock[tLoc])) {
switch (iBlock[tLoc]) {
case COND_IF:
iStream << "if";
break;
case COND_UNLESS:
iStream << "unless";
break;
case COND_WHILE:
iStream << "while";
break;
}
}
// Function
else if (mGrammar->isFunction(iBlock[tLoc])) {
iStream << mGrammar->nameFunction(iBlock[tLoc]);
}
// Data
else if (mGrammar->isData(iBlock[tLoc])) {
unsigned char tDataType = iBlock[tLoc++];
switch (tDataType) {
case DATA_VOID:
iStream << Value();
break;
case DATA_BOOL:
iStream << toBool(iBlock[tLoc]);
break;
case DATA_INT:
iStream << toInt(iBlock[tLoc]);
break;
}
}
tLoc++;
}
iStream << std::endl;
}
