/* OPEN
* ------------------------------------------------------------------------- */
struct gstor_open_ret
gstor_open(const char * name) {
struct gstor_open_ret ret;
string_t petri_filename = string_concat(name,".petri",0);
if (INVALID_STR(petri_filename)) goto error;
string_t dfile_filename = string_concat(name,".dfile",0);
if (INVALID_STR(dfile_filename)) goto error;
ret.gstor_h = malloc(sizeof(gstor));
ret.gstor_h->index = petri_open(string_tochar(petri_filename));
if (ret.gstor_h->index==0) goto error;
ret.gstor_h->data = dfile_open(string_tochar(dfile_filename));
if (ret.gstor_h->data==0) goto close_and_error;
string_destroy(petri_filename);
string_destroy(dfile_filename);
return ret.result = GSTOR_OKAY, ret;
close_and_error:
petri_close(ret.gstor_h->index);
error:
return ret.result = GSTOR_ERROR, ret;
}
int main(int argc, char** argv)
{
struct string args;
int i;
int j;
int k;
string_init(&args, 1, 1);
string_concatb(&args, "foo", 3);
string_concatb(&args, "b", 1);
printf("%d\n", args._u._s.length);
for (i = 0; i < argc; i++) string_concat(&args, *argv++);
puts(string_get(&args));
string_free(&args);
for (j = 1; j <= 3; j++) {
for (k = 1; k <= 200; k+=50) {
printf("Testing with isize=%d growby=%d\n", j, k);
string_init(&args, j, k);
for (i = 0; i < 100; i++) {
string_concat(&args, "test");
}
printf("100x test == %d len, %d size, %d grow\n", args._u._s.length,
args._u._s.size, args._u._s.growby);
string_free(&args);
}
}
return 0;
}
char *get_path(char **env , char *cmd)
{
char **path;
char *dir_path;
int i;
char **unique_path;
char *concat_path;
char *cmd_path;
for (i = 0; env[i]!= '\0'; i++) /* Loops through each string in env ie each environment variable */
{
if(str_ncomp(env[i], "PATH=", str_len("PATH=")) == 0) /* Looks for a string containing "PATH=" */
{
path = string_split(env[i],'='); /* Separates the string found into 2 strings; "PATH" and what comes after */
dir_path = path[1]; /* The second string ie the whole path is stored */
unique_path = string_split(dir_path, ':'); /* The whole path contained in env var PATH is divided into all possible paths to search for input command */
break; /* Gets the unique_paths */
}
}
for(i = 0; unique_path[i] != '\0'; i++)
{
concat_path = string_concat(unique_path[i],"/"); /* "/" is appended to each unique path */
cmd_path = string_concat(concat_path, cmd); /* Input command is appended to each unique path */
if(find_ex(cmd_path)) /* If path to program to be executed is found */
return cmd_path;
cmd_path = '\0';
}
return NULL; /* If no path found */
}
void cmd_insert (char *cp)
{
Line *line;
String *string;
if (range_single (cp, &cp, &cur_position) < 0) return; /* see where to insert */
if (*cp == ';') /* if ;, insert the remaining string before current line */
{
cur_position.offset = 0;
string = string_create (strlen (cp + 1), cp + 1);
string_concat (string, 1, "\n");
buffer_dirty (cur_position.buffer, 1);
line_insert (cur_position.buffer, cur_position.line, string);
return;
}
if (!eoltest (cp)) return; /* otherwise, that's all there should be */
/* Read tty input until eof into the current buffer just before the current line */
cur_position.offset = 0;
while ((string = jnl_readprompt ("\r\n >")) != NULL)
{
string_concat (string, 1, "\n"); /* put line terminator on string */
buffer_dirty (cur_position.buffer, 1);
line_insert (cur_position.buffer, cur_position.line, string); /* insert line just before current line */
}
}
void StringData::append(const char *s, int len) {
if (len == 0) return;
if (len < 0 || (len & IsMask)) {
throw InvalidArgumentException("len: %d", len);
}
ASSERT(!isStatic()); // never mess around with static strings!
if (!isMalloced()) {
int newlen;
m_data = string_concat(data(), size(), s, len, newlen);
if (isShared()) {
m_shared->decRef();
}
m_len = newlen;
m_hash = 0;
} else if (m_data == s) {
int newlen;
char *newdata = string_concat(data(), size(), s, len, newlen);
releaseData();
m_data = newdata;
m_len = newlen;
} else {
int dataLen = size();
ASSERT((m_data > s && m_data - s > len) ||
(m_data < s && s - m_data > dataLen)); // no overlapping
m_len = len + dataLen;
m_data = (const char*)realloc((void*)m_data, m_len + 1);
memcpy((void*)(m_data + dataLen), s, len);
((char*)m_data)[m_len] = '\0';
m_hash = 0;
}
}
static void debugserver_format_command(const char* prefix, const char* command, const char* arguments, int calculate_checksum, char** buffer, uint32_t* size)
{
char checksum_hash[DEBUGSERVER_CHECKSUM_HASH_LENGTH + 1] = {'#', '0', '0', '\0'};
char* encoded = NULL;
uint32_t encoded_length = 0;
if (arguments) {
/* arguments must be hex encoded */
debugserver_encode_string(arguments, &encoded, &encoded_length);
} else {
encoded = NULL;
}
char* encoded_command = string_concat(command, encoded, NULL);
encoded_length = strlen(encoded_command);
if (calculate_checksum) {
uint32_t checksum = debugserver_get_checksum_for_buffer(encoded_command, encoded_length);
checksum_hash[1] = DEBUGSERVER_HEX_ENCODE_FIRST_BYTE(checksum);
checksum_hash[2] = DEBUGSERVER_HEX_ENCODE_SECOND_BYTE(checksum);
}
*buffer = string_concat(prefix, encoded_command, checksum_hash, NULL);
*size = strlen(prefix) + strlen(encoded_command) + DEBUGSERVER_CHECKSUM_HASH_LENGTH;
debug_info("formatted command: %s size: %d checksum: 0x%s", *buffer, *size, checksum_hash);
if (encoded_command)
free(encoded_command);
if (encoded)
free(encoded);
}
static void rtmsg_dump(const uint8_t *buf, size_t len)
{
char str[80];
size_t i, off = 0;
int k = 0;
for(i=0; i<len; i++)
{
if(k == 20)
{
printerror(0, NULL, __func__, "%s", str);
k = 0;
off = 0;
}
if(k != 0 && (k % 4) == 0)
string_concat(str, sizeof(str), &off, " ");
string_concat(str, sizeof(str), &off, "%02x", buf[i]);
k++;
}
if(k != 0)
printerror(0, NULL, __func__, "%s", str);
return;
}
static char *tcp_pos(char *buf, size_t len, scamper_probe_t *probe)
{
size_t off = 0;
string_concat(buf, len, &off, "%u", probe->pr_tcp_seq);
if(probe->pr_tcp_flags & TH_ACK)
string_concat(buf, len, &off, ":%u", probe->pr_tcp_ack);
return buf;
}
char *charRecognition_getText(struct charRecognition *charReg,
SDL_Surface *surface, char *dic)
{
char *recognized = "";
ImageBlockArray imageBlock = charDetection_blocks(surface);
for (unsigned h = 0; h < imageBlock.size; h++) {
ImageLineArray imageLine = imageBlock.elements[h].lines;
for (unsigned i = 0; i < imageLine.size; i++) {
char *curWord = "";
for (unsigned j = 0;
j < imageLine.elements[i].chars.size; j++) {
struct ImageChar imageChar =
imageLine.elements[i].chars.elements[j];
if (imageChar.space) {
if (strcmp(curWord, "") > 0)
recognized = string_concat(
recognized,
wordCorrector_correct(
dic, curWord));
curWord = "";
recognized =
string_concat(recognized, " ");
continue;
}
SDL_Surface *s = image_scale(
image_extractChar(surface, &imageChar), 16,
16);
imageChar.content =
charRecognition_getChar(charReg, s);
curWord = string_concatChar(
curWord, tolower(charRecognition_getChar(
charReg, s)));
}
if (strcmp(curWord, "") > 0)
recognized = string_concat(
recognized,
wordCorrector_correct(dic, curWord));
recognized = string_concat(recognized, "\n");
}
recognized = string_concat(recognized, "\n");
}
return recognized;
}
static char *tcp_flags(char *buf, size_t len, scamper_probe_t *probe)
{
uint8_t flags = probe->pr_tcp_flags;
uint8_t flag;
size_t off;
int i;
buf[0] = '\0';
if(probe->pr_len != 0)
flags &= ~(TH_ACK);
off = 0;
for(i=0; i<8 && flags != 0; i++)
{
flag = 1 << i;
if((flags & flag) == 0)
continue;
flags &= ~flag;
switch(flag)
{
case TH_SYN:
string_concat(buf, len, &off, " syn");
break;
case TH_RST:
string_concat(buf, len, &off, " rst");
break;
case TH_FIN:
string_concat(buf, len, &off, " fin");
break;
case TH_ACK:
string_concat(buf, len, &off, " ack");
break;
case TH_PUSH:
string_concat(buf, len, &off, " psh");
break;
case TH_URG:
string_concat(buf, len, &off, " urg");
break;
case TH_ECE:
string_concat(buf, len, &off, " ece");
break;
case TH_CWR:
string_concat(buf, len, &off, " cwr");
break;
}
}
return buf;
}
void string_concat_string(string* s, char* chars) {
while(*chars) {
string_concat(s, *chars);
chars++;
}
}
void string_split(string* s, array* a, char c) {
string *current;
int i;
current = (string*)malloc(sizeof(string));
string_init(current);
for(i = 0; i < s->used; i++) {
if(s->data[i] != c)
string_concat(current, s->data[i]);
else if(current->used) {
array_push(a, (int)current);
current = (string*)malloc(sizeof(string));
string_init(current);
}
}
if(current->used)
array_push(a, (int)current);
else
free(current);
}
static struct uri *
proxy_uri(struct uri *uri, unsigned char *proxy,
struct connection_state *error_state)
{
struct string string;
if (init_string(&string)
&& string_concat(&string, "proxy://", proxy, "/",
(unsigned char *) NULL)
&& add_uri_to_string(&string, uri, URI_BASE)) {
/* There is no need to use URI_BASE when calling get_uri()
* because URI_BASE should not add any fragments in the first
* place. */
uri = get_uri(string.source, 0);
/* XXX: Assume the problem is due to @proxy having bad format.
* This is a lot faster easier than checking the format. */
if (!uri)
*error_state = connection_state(S_PROXY_ERROR);
} else {
uri = NULL;
*error_state = connection_state(S_OUT_OF_MEM);
}
done_string(&string);
return uri;
}
int main(void) {
char* a = "hola ";
char* b = "mundo";
printf("%s\n", string_concat(a, b));
getchar();
char* concat = (char*) malloc(mallocSize(sizeof(char), strlen(a), strlen(b), -1));
string_concat_dinamyc(a, b, &concat);
printf("%s\n", concat);
getchar();
char* user = (char*) malloc(mallocSize(sizeof(char), 8, -1));
char* dominio = (char*) malloc(mallocSize(sizeof(char), 40, -1));
char* mail = "*****@*****.**";
mail_split(mail, &user, &dominio);
printf("el user es %s y el dominio es %s", user, dominio);
getchar();
return EXIT_SUCCESS;
}
static int modfile_file( INSTANCE * my, int * params )
{
char buffer[1025] ;
int str = string_new( "" ) ;
file * f ;
int l;
f = file_open( string_get( params[0] ), "rb" ) ;
string_discard( params[0] ) ;
if ( f )
{
while ( !file_eof( f ) )
{
l = file_read( f, buffer, sizeof( buffer ) - 1 ) ;
buffer[l] = '\0' ;
if ( l )
{
string_concat( str, buffer ) ;
buffer[0] = '\0' ;
}
else
break;
}
file_close( f ) ;
}
string_use( str ) ;
return str ;
}
static int out_scan_fbox_dir(s_outbound_callback_data *callback,
const char *path, s_faddr addr, int flavor)
{
DIR *dir;
struct dirent *dirent;
if( (dir = opendir(path)) == NULL )
{
logerr("can't open filebox directory \"%s\"", path);
return -1;
}
while( (dirent = readdir(dir)) )
{
callback->path = string_concat(path, dirent->d_name, NULL);
if( is_regfile(callback->path) )
{
callback->addr = addr;
callback->type = OUTB_TYPE_FBOX;
callback->flavor = flavor;
callback->callback(callback);
}
free(callback->path);
callback->path = NULL;
}
closedir(dir);
return 0;
}
struct charRecognition *charRecognition_learn(char *rootPath,
char chars[], size_t size, size_t variants)
{
struct charRecognition *charReg =
malloc(sizeof(struct charRecognition));
struct NeuralNetwork *myNeuralNetwork =
neuralNetwork_main(256, HIDDEN_LAYER_COUNT, size);
unsignedArray2D input = new_unsignedArray2D(size * variants, 256);
unsignedArray2D output = new_unsignedArray2D(size * variants, size);
unsigned count = 0;
for(unsigned i = 0; i < size; i++) {
for(unsigned j = 0; j < variants; j++) {
char toAscii[15];
sprintf(toAscii, "%d", (int)chars[i]);
char *path = string_concat(rootPath, toAscii);
path = string_concat(path, "/");
char filename[5];
sprintf(filename, "%d", j);
path = string_concat(path, filename);
path = string_concat(path, ".bmp");
SDL_Surface *s = image_scale(
image_crop(image_load(path)),
16, 16);
for (unsigned k = 0; k < 16; k++)
for (unsigned l = 0; l < 16; l++)
input.elements[count].elements[k + l * 16] =
image_getPixelBool(s, k, l);
for(unsigned k = 0; k < size; k++)
output.elements[count].elements[k] = ((count / variants) == k);
count++;
}
}
NeuralNetwork_train(myNeuralNetwork, input, output, 0.05, 0.1,
0.9);
charReg->letters = chars;
charReg->size = size;
charReg->network = myNeuralNetwork;
return charReg;
}
static int out_scan_lbox(s_outbound_callback_data *callback,
const s_falist *mailfor, const char *path)
{
DIR *dir;
struct dirent *dirent;
const s_falist *alst;
s_faddr addr;
char *newpath;
if( (dir = opendir(path)) == NULL )
{
logerr("can't open filebox directory \"%s\"", path);
return -1;
}
while( (dirent = readdir(dir)) )
{
if( out_parse_name_lbox(&addr, dirent->d_name) == 0 )
{
if( mailfor )
{
/* Scan only this fileboxes */
for( alst = mailfor;
alst && ftn_addrcomp(addr, alst->addr);
alst = alst->next );
if( alst )
{
newpath = string_concat(path, dirent->d_name, "/", NULL);
(void)out_scan_fbox_dir(callback, newpath, addr, FLAVOR_HOLD);
free(newpath);
}
}
else
{
/* Scan all fileboxes */
newpath = string_concat(path, dirent->d_name, "/", NULL);
(void)out_scan_fbox_dir(callback, newpath, addr, FLAVOR_HOLD);
free(newpath);
}
}
}
closedir(dir);
return 0;
}
static int do_attach(void)
{
char buf[256];
size_t off = 0;
string_concat(buf, sizeof(buf), &off, "attach");
if((options & OPT_PRIORITY) != 0)
string_concat(buf, sizeof(buf), &off, " priority %d", priority);
string_concat(buf, sizeof(buf), &off, "\n");
if(write_wrap(scamper_fd, buf, NULL, off) != 0)
{
fprintf(stderr, "could not attach to scamper process\n");
return -1;
}
return 0;
}
int main()
{
char *concat;
concat = string_concat("Holberton ", "School");
printf("%s\n", concat);
free(concat);
return (0);
}
int main()
{
char *concat;
concat = string_concat("my name is ", "steven garcia");
printf("%s\n", concat);
free(concat);
return (0);
}
String String::operator+(litstr str) const {
if (empty()) return str;
if (!str || !*str) return *this;
int len;
char *ret = string_concat(data(), size(), str, strlen(str), len);
return NEW(StringData)(ret, len, AttachString);
}
String String::operator+(CStrRef str) const {
if (empty()) return str;
if (str.empty()) return *this;
int len;
char *ret = string_concat(data(), size(), str.data(), str.size(), len);
return NEW(StringData)(ret, len, AttachString);
}
static int
epoch2http(struct string* s, time_t time)
{
char buf[512];
struct tm* tm;
tm = gmtime(&time);
strftime(buf, 512, "%a, %d %b %Y %H:%M:%S GMT", tm);
return(!string_concat(s, buf));
}
static char *header_tostr() {
char buf[512], tmp[128];
size_t off = 0;
string_concat(buf, sizeof(buf), &off, "%s\n",
"version;userID;timestamp;src;dst;method;status;ttl;hopaddr;rtt");
return strdup(buf);
}
void respond_to_request( int sockfd, char *output, size_t output_size ){
//printf( "Request #%d\n", ++x );
/*
char *local_var;
testme( &local_var );
printf( "LocalVar %s\n", local_var );
printf( "Request2 #%d\n", ++x );
*/
//output = "abcd";
//output_size = 4;
//convert the output size message body to a string
char content_length[100];
memset( (void*)content_length, 0, 100 );
snprintf( content_length, 100, "%d", (int)output_size );
//printf( "buffer_size: %s\n", content_length );
//create the response header
char *response_header = NULL;
char *response = NULL;
string_concat( &response_header, "HTTP/1.1 200 OK\r\nContent-Length: ", content_length );
string_concat( &response_header, response_header, "\r\nContent-Type: text/html\r\n\r\n" );
//write both the response header and the message body to the socket
string_concat( &response, response_header, output );
size_t response_length = strlen( response );
//printf( "Content Length: %d, Response Length: %d\n", output_size, response_length );
Writen( sockfd, response, response_length );
free( response_header );
free( response );
}
/* ChapelIO.chpl:267 */
void _writeIt_18503(StringClass _this_18574, _string s, int32_t _ln, _string _fn) {
_string T1;
_string T2;
_string T3;
T1 = (_this_18574->s);
T2 = string_concat(T1, s, _ln, _fn);
T3 = string_copy(T2, _ln, _fn);
_this_18574->s = T3;
return;
}
/* ChapelIO.chpl:383 */
void halt(_string _e0_args, int32_t _ln, _string _fn) {
_tuple_1__string T1;
_string T2;
_string T3;
T1.x1 = _e0_args;
T2 = _tuple2string(&(T1), _ln, _fn);
T3 = string_concat("halt reached - ", T2, _ln, _fn);
chpl_error(T3, _ln, _fn);
return;
}
bool unlink_recursive(const char *path, bool include_self)
{
if (!path) {
return false;
}
DIR *dir;
struct dirent *e;
dir = opendir(path);
if (!dir) {
return false;
}
char *item = NULL;
while ((e = readdir(dir)) != NULL) {
if (!strcmp(e->d_name, ".") || !strcmp(e->d_name, "..")) {
continue;
}
item = string_concat(path, "/", e->d_name, NULL);
if (!item) {
goto fail;
}
if (e->d_type == DT_REG) {
if (unlink(item) != 0) {
goto fail;
}
} else if (e->d_type == DT_DIR) {
if (unlink_recursive(item, true) != 0) {
goto fail;
}
}
free(item);
item = NULL;
}
closedir(dir);
if (include_self && rmdir(path) != 0) {
return false;
}
return true;
fail:
if (item) {
free(item);
}
closedir(dir);
return false;
}
static void halt2(c_string s, int64_t _ln, int32_t _fn) {
#line 688 "ChapelIO.chpl"
c_string_copy call_tmp;
#line 694 "ChapelIO.chpl"
call_tmp = string_concat("halt reached - ", s, _ln, _fn);
#line 694 "ChapelIO.chpl"
chpl_error(call_tmp, _ln, _fn);
#line 693 "ChapelIO.chpl"
return;
#line 693 "ChapelIO.chpl"
}
