Advertisement
Not a member of Pastebin yet?
Sign Up,
it unlocks many cool features!
- /////////////////////////////
- /// ZScript Error Logging ///
- /// and Debugging -- v0.4 ///
- /// 13th November, 2018 ///
- /// By: ZoriaRPG ///
- /////////////////////////////
- script typedef ffc namespace;
- namespace script log
- {
- void run()
- {
- print("Testing %s\n","log.print()");
- print("Test Number: %d\n",1);
- print("Testing %s, %s \n","log.print()","with iteration.");
- print("Test %s %d \n","Number: ",2);
- }
- void print(int s, int v) //what if we use an array literal for the inputs?. No, then we still don't have overloaded strings
- {
- int main_buf[2048];
- int buffer_pos; int string_pos; int q;
- for ( ; s[string_pos] != '%'; ++string_pos )
- {
- main_buf[buffer_pos] = s[string_pos]; //copy until we reach %
- ++buffer_pos; //we increment both iterators
- }
- //Now, we found an insertion token, so insert it
- //if ( s[string_pos] != '%' ) //copy the buffer text over to the buffer, until we find our token
- //{
- // main_buf[buffer_pos] = s[string_pos];
- // ++buffer_pos;
- //}
- //else //found a special token
- //{
- switch(s[string_pos+1]) //read ahead, one vhar beyond '%'
- {
- case 'S':
- case 's':
- {
- //++buffer_pos; //skip over the token
- //main_buf[buffer_pos+q+1] = ' '; //add a trailing space
- for ( q = 0; v[q]; ++q ) //until we reach NULL, imnsert the substring
- {
- main_buf[buffer_pos] = v[q]; //copy the string passed as a param
- //over to the buffer
- ++buffer_pos;
- }
- //main_buf[buffer_pos+q+1] = ' '; //add a trailing space
- //++buffer_pos; //set up the buffer for the next char
- ++string_pos;
- ++string_pos;
- break;
- }
- case 'F':
- case 'f':
- {
- //++buffer_pos; //skip over the token
- //main_buf[buffer_pos+q+1] = ' '; //add a trailing space
- int i_val[12];
- ftoa(i_val,v);
- for ( q = 0; i_val[q]; ++q )
- {
- main_buf[buffer_pos] = i_val[q];
- ++buffer_pos;
- }
- //main_buf[buffer_pos+q+1] = ' '; //add a trailing space
- //++buffer_pos; //set up the buffer for the next char
- ++string_pos;
- ++string_pos;
- break;
- }
- case 'D':
- case 'd':
- {
- //++buffer_pos;
- //main_buf[buffer_pos+q+1] = ' '; //add a trailing space
- int f_val[12];
- itoa(f_val,v);
- for ( q = 0; f_val[q] != 0; ++q )
- {
- main_buf[buffer_pos] = f_val[q];
- ++buffer_pos;
- }
- //main_buf[buffer_pos+q+1] = ' '; //add a trailing space
- //++buffer_pos; //set up the buffer for the next char
- ++string_pos;
- ++string_pos;
- break;
- }
- default: ++buffer_pos; break;
- }
- //we copied the insertion, so, resume the rest o the string:
- for ( ; s[string_pos]; ++string_pos ) //Until we reach NULL
- {
- //copy the rest of the string:
- main_buf[buffer_pos] = s[string_pos];
- ++buffer_pos;
- }
- //main_buf[buffer_pos+1] = '\n'; Put this in the string!
- TraceS(main_buf); //TraceNL();
- }
- void print(int s, int v1, int v2) //what if we use an array literal for the inputs?. No, then we still don't have overloaded strings
- {
- int main_buf[2048];
- int buffer_pos; int string_pos; int q;
- for ( ; s[string_pos] != '%'; ++string_pos )
- {
- main_buf[buffer_pos] = s[string_pos];
- ++buffer_pos;
- }
- int values[]={v1,v2};
- int sz = 2;
- int val_index = 0;
- do
- {
- ++string_pos;
- //TraceS("Val index is: "); Trace(val_index); TraceNL();
- //Trace(s[string_pos]);
- switch(s[string_pos])
- {
- case 'S':
- case 's':
- {
- int ptr = values[val_index];
- //for ( q = 0; (values[val_index[q]]); ++q ) //until we reach NULL
- for ( q = 0; ptr[q]; ++q ) //until we reach NULL
- {
- main_buf[buffer_pos] = ptr[q];
- //values[val_index[q]]; //copy the string passed as a param
- //over to the buffer
- ++buffer_pos;
- }
- ++string_pos;
- ++string_pos;
- break;
- }
- case 'F':
- case 'f':
- {
- int i_val[12];
- ftoa(i_val,values[val_index]);
- for ( q = 0; (i_val[q]); ++q ) //until we reach NULL
- {
- main_buf[buffer_pos] = i_val[q];
- ++buffer_pos;
- }
- ++string_pos;
- ++string_pos;
- break;
- }
- case 'D':
- case 'd':
- {
- int f_val[12];
- itoa(f_val,values[val_index]);
- for ( q = 0; (f_val[q]); ++q )
- {
- main_buf[buffer_pos] = f_val[q];
- ++buffer_pos;
- }
- //TraceS(f_val);
- ++string_pos;
- ++string_pos;
- break;
- }
- default: return;
- }
- //we copied the insertion, so, resume the rest o the string:
- for ( ; s[string_pos] != '%'; ++string_pos ) //Until we reach NULL
- {
- if (!(s[string_pos])) break;
- //copy the rest of the string:
- main_buf[buffer_pos] = s[string_pos];
- ++buffer_pos;
- }
- //Trace(s[string_pos]);
- ++val_index; //increase for overloads
- //we are on a token of %
- //++string_pos; //stop forward to the char after %
- }while(val_index < sz);
- //}while((s[string_pos])); //until we reach null in the main buffer
- TraceS(main_buf); //TraceNL();
- }
- void print(int s, int v1, int v2, int v3) //what if we use an array literal for the inputs?. No, then we still don't have overloaded strings
- {
- int main_buf[2048];
- int buffer_pos; int string_pos; int q;
- for ( ; s[string_pos] != '%'; ++string_pos )
- {
- main_buf[buffer_pos] = s[string_pos];
- ++buffer_pos;
- }
- int values[]={v1,v2,v3};
- int sz = 3;
- int val_index = 0;
- do
- {
- ++string_pos;
- switch(s[string_pos])
- {
- case 'S':
- case 's':
- {
- int ptr = values[val_index];
- //for ( q = 0; (values[val_index[q]]); ++q ) //until we reach NULL
- for ( q = 0; ptr[q]; ++q ) //until we reach NULL
- {
- main_buf[buffer_pos] = ptr[q];
- //values[val_index[q]]; //copy the string passed as a param
- //over to the buffer
- ++buffer_pos;
- }
- ++string_pos;
- ++string_pos;
- break;
- }
- case 'F':
- case 'f':
- {
- int i_val[12];
- ftoa(i_val,values[val_index]);
- for ( q = 0; (i_val[q]); ++q ) //until we reach NULL
- {
- main_buf[buffer_pos] = i_val[q];
- ++buffer_pos;
- }
- ++string_pos;
- ++string_pos;
- break;
- }
- case 'D':
- case 'd':
- {
- int f_val[12];
- itoa(f_val,values[val_index]);
- for ( q = 0; (f_val[q]); ++q )
- {
- main_buf[buffer_pos] = f_val[q];
- ++buffer_pos;
- }
- //TraceS(f_val);
- ++string_pos;
- ++string_pos;
- break;
- }
- default: return;
- }
- //we copied the insertion, so, resume the rest o the string:
- for ( ; s[string_pos] != '%'; ++string_pos ) //Until we reach NULL
- {
- if (!(s[string_pos])) break;
- //copy the rest of the string:
- main_buf[buffer_pos] = s[string_pos];
- ++buffer_pos;
- }
- ++val_index; //increase for overloads
- //we are on a token of %
- }while(val_index < sz);
- TraceS(main_buf); //TraceNL();
- }
- void print(int s, int v1, int v2, int v3, int v4) //what if we use an array literal for the inputs?. No, then we still don't have overloaded strings
- {
- int main_buf[2048];
- int buffer_pos; int string_pos; int q;
- for ( ; s[string_pos] != '%'; ++string_pos )
- {
- main_buf[buffer_pos] = s[string_pos];
- ++buffer_pos;
- }
- int values[]={v1,v2,v3,v4};
- int sz = 4;
- int val_index = 0;
- do
- {
- ++string_pos;
- switch(s[string_pos])
- {
- case 'S':
- case 's':
- {
- int ptr = values[val_index];
- //for ( q = 0; (values[val_index[q]]); ++q ) //until we reach NULL
- for ( q = 0; ptr[q]; ++q ) //until we reach NULL
- {
- main_buf[buffer_pos] = ptr[q];
- //values[val_index[q]]; //copy the string passed as a param
- //over to the buffer
- ++buffer_pos;
- }
- ++string_pos;
- ++string_pos;
- break;
- }
- case 'F':
- case 'f':
- {
- int i_val[12];
- ftoa(i_val,values[val_index]);
- for ( q = 0; (i_val[q]); ++q ) //until we reach NULL
- {
- main_buf[buffer_pos] = i_val[q];
- ++buffer_pos;
- }
- ++string_pos;
- ++string_pos;
- break;
- }
- case 'D':
- case 'd':
- {
- int f_val[12];
- itoa(f_val,values[val_index]);
- for ( q = 0; (f_val[q]); ++q )
- {
- main_buf[buffer_pos] = f_val[q];
- ++buffer_pos;
- }
- //TraceS(f_val);
- ++string_pos;
- ++string_pos;
- break;
- }
- default: return;
- }
- //we copied the insertion, so, resume the rest o the string:
- for ( ; s[string_pos] != '%'; ++string_pos ) //Until we reach NULL
- {
- if (!(s[string_pos])) break;
- //copy the rest of the string:
- main_buf[buffer_pos] = s[string_pos];
- ++buffer_pos;
- }
- ++val_index; //increase for overloads
- //we are on a token of %
- }while(val_index < sz);
- TraceS(main_buf); //TraceNL();
- }
- void print(int s, int v1, int v2, int v3, int v4, int v5) //what if we use an array literal for the inputs?. No, then we still don't have overloaded strings
- {
- int main_buf[2048];
- int buffer_pos; int string_pos; int q;
- for ( ; s[string_pos] != '%'; ++string_pos )
- {
- main_buf[buffer_pos] = s[string_pos];
- ++buffer_pos;
- }
- int values[]={v1,v2,v3,v4,v5};
- int sz = 5;
- int val_index = 0;
- do
- {
- ++string_pos;
- switch(s[string_pos])
- {
- case 'S':
- case 's':
- {
- int ptr = values[val_index];
- //for ( q = 0; (values[val_index[q]]); ++q ) //until we reach NULL
- for ( q = 0; ptr[q]; ++q ) //until we reach NULL
- {
- main_buf[buffer_pos] = ptr[q];
- //values[val_index[q]]; //copy the string passed as a param
- //over to the buffer
- ++buffer_pos;
- }
- ++string_pos;
- ++string_pos;
- break;
- }
- case 'F':
- case 'f':
- {
- int i_val[12];
- ftoa(i_val,values[val_index]);
- for ( q = 0; (i_val[q]); ++q ) //until we reach NULL
- {
- main_buf[buffer_pos] = i_val[q];
- ++buffer_pos;
- }
- ++string_pos;
- ++string_pos;
- break;
- }
- case 'D':
- case 'd':
- {
- int f_val[12];
- itoa(f_val,values[val_index]);
- for ( q = 0; (f_val[q]); ++q )
- {
- main_buf[buffer_pos] = f_val[q];
- ++buffer_pos;
- }
- //TraceS(f_val);
- ++string_pos;
- ++string_pos;
- break;
- }
- default: return;
- }
- //we copied the insertion, so, resume the rest o the string:
- for ( ; s[string_pos] != '%'; ++string_pos ) //Until we reach NULL
- {
- if (!(s[string_pos])) break;
- //copy the rest of the string:
- main_buf[buffer_pos] = s[string_pos];
- ++buffer_pos;
- }
- ++val_index; //increase for overloads
- //we are on a token of %
- }while(val_index < sz);
- TraceS(main_buf); //TraceNL();
- }
- void print(int s, int v1, int v2, int v3, int v4, int v5, int v6) //what if we use an array literal for the inputs?. No, then we still don't have overloaded strings
- {
- int main_buf[2048];
- int buffer_pos; int string_pos; int q;
- for ( ; s[string_pos] != '%'; ++string_pos )
- {
- main_buf[buffer_pos] = s[string_pos];
- ++buffer_pos;
- }
- int values[]={v1,v2,v3,v4,v5,v6};
- int sz = 6;
- int val_index = 0;
- do
- {
- ++string_pos;
- switch(s[string_pos])
- {
- case 'S':
- case 's':
- {
- int ptr = values[val_index];
- //for ( q = 0; (values[val_index[q]]); ++q ) //until we reach NULL
- for ( q = 0; ptr[q]; ++q ) //until we reach NULL
- {
- main_buf[buffer_pos] = ptr[q];
- //values[val_index[q]]; //copy the string passed as a param
- //over to the buffer
- ++buffer_pos;
- }
- ++string_pos;
- ++string_pos;
- break;
- }
- case 'F':
- case 'f':
- {
- int i_val[12];
- ftoa(i_val,values[val_index]);
- for ( q = 0; (i_val[q]); ++q ) //until we reach NULL
- {
- main_buf[buffer_pos] = i_val[q];
- ++buffer_pos;
- }
- ++string_pos;
- ++string_pos;
- break;
- }
- case 'D':
- case 'd':
- {
- int f_val[12];
- itoa(f_val,values[val_index]);
- for ( q = 0; (f_val[q]); ++q )
- {
- main_buf[buffer_pos] = f_val[q];
- ++buffer_pos;
- }
- //TraceS(f_val);
- ++string_pos;
- ++string_pos;
- break;
- }
- default: return;
- }
- //we copied the insertion, so, resume the rest o the string:
- for ( ; s[string_pos] != '%'; ++string_pos ) //Until we reach NULL
- {
- if (!(s[string_pos])) break;
- //copy the rest of the string:
- main_buf[buffer_pos] = s[string_pos];
- ++buffer_pos;
- }
- ++val_index; //increase for overloads
- //we are on a token of %
- }while(val_index < sz);
- TraceS(main_buf); //TraceNL();
- }
- void print(int s, int v1, int v2, int v3, int v4, int v5, int v6, int v7) //what if we use an array literal for the inputs?. No, then we still don't have overloaded strings
- {
- int main_buf[2048];
- int buffer_pos; int string_pos; int q;
- for ( ; s[string_pos] != '%'; ++string_pos )
- {
- main_buf[buffer_pos] = s[string_pos];
- ++buffer_pos;
- }
- int values[]={v1,v2,v3,v4,v5,v6,v7};
- int sz = 7;
- int val_index = 0;
- do
- {
- ++string_pos;
- switch(s[string_pos])
- {
- case 'S':
- case 's':
- {
- int ptr = values[val_index];
- //for ( q = 0; (values[val_index[q]]); ++q ) //until we reach NULL
- for ( q = 0; ptr[q]; ++q ) //until we reach NULL
- {
- main_buf[buffer_pos] = ptr[q];
- //values[val_index[q]]; //copy the string passed as a param
- //over to the buffer
- ++buffer_pos;
- }
- ++string_pos;
- ++string_pos;
- break;
- }
- case 'F':
- case 'f':
- {
- int i_val[12];
- ftoa(i_val,values[val_index]);
- for ( q = 0; (i_val[q]); ++q ) //until we reach NULL
- {
- main_buf[buffer_pos] = i_val[q];
- ++buffer_pos;
- }
- ++string_pos;
- ++string_pos;
- break;
- }
- case 'D':
- case 'd':
- {
- int f_val[12];
- itoa(f_val,values[val_index]);
- for ( q = 0; (f_val[q]); ++q )
- {
- main_buf[buffer_pos] = f_val[q];
- ++buffer_pos;
- }
- //TraceS(f_val);
- ++string_pos;
- ++string_pos;
- break;
- }
- default: return;
- }
- //we copied the insertion, so, resume the rest o the string:
- for ( ; s[string_pos] != '%'; ++string_pos ) //Until we reach NULL
- {
- if (!(s[string_pos])) break;
- //copy the rest of the string:
- main_buf[buffer_pos] = s[string_pos];
- ++buffer_pos;
- }
- ++val_index; //increase for overloads
- //we are on a token of %
- }while(val_index < sz);
- TraceS(main_buf); //TraceNL();
- }
- void print(int s, int v1, int v2, int v3, int v4, int v5, int v6, int v7, int v8) //what if we use an array literal for the inputs?. No, then we still don't have overloaded strings
- {
- int main_buf[2048];
- int buffer_pos; int string_pos; int q;
- for ( ; s[string_pos] != '%'; ++string_pos )
- {
- main_buf[buffer_pos] = s[string_pos];
- ++buffer_pos;
- }
- int values[]={v1,v2,v3,v4,v5,v6,v7,v8};
- int sz = 8;
- int val_index = 0;
- do
- {
- ++string_pos;
- switch(s[string_pos])
- {
- case 'S':
- case 's':
- {
- int ptr = values[val_index];
- //for ( q = 0; (values[val_index[q]]); ++q ) //until we reach NULL
- for ( q = 0; ptr[q]; ++q ) //until we reach NULL
- {
- main_buf[buffer_pos] = ptr[q];
- //values[val_index[q]]; //copy the string passed as a param
- //over to the buffer
- ++buffer_pos;
- }
- ++string_pos;
- ++string_pos;
- break;
- }
- case 'F':
- case 'f':
- {
- int i_val[12];
- ftoa(i_val,values[val_index]);
- for ( q = 0; (i_val[q]); ++q ) //until we reach NULL
- {
- main_buf[buffer_pos] = i_val[q];
- ++buffer_pos;
- }
- ++string_pos;
- ++string_pos;
- break;
- }
- case 'D':
- case 'd':
- {
- int f_val[12];
- itoa(f_val,values[val_index]);
- for ( q = 0; (f_val[q]); ++q )
- {
- main_buf[buffer_pos] = f_val[q];
- ++buffer_pos;
- }
- //TraceS(f_val);
- ++string_pos;
- ++string_pos;
- break;
- }
- default: return;
- }
- //we copied the insertion, so, resume the rest o the string:
- for ( ; s[string_pos] != '%'; ++string_pos ) //Until we reach NULL
- {
- if (!(s[string_pos])) break;
- //copy the rest of the string:
- main_buf[buffer_pos] = s[string_pos];
- ++buffer_pos;
- }
- ++val_index; //increase for overloads
- //we are on a token of %
- }while(val_index < sz);
- TraceS(main_buf); //TraceNL();
- }
- }//end namespace
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement