static void request_init(struct Request *req, const struct URI *uri) {
req->host = strcopy(uri->host, uri->hostlen);
req->port = uri->port;
req->path = strcopy(uri->path, uri->pathlen);
req->hostport = strcopy(uri->hostport, uri->hostportlen);
req->stream_id = -1;
}
void ffw_reencode_raw2(char ** mapping, int mapping_len, int force)
{
Encoding * enc = calloc(1, sizeof(Encoding));
enc->enc_name = strcopy("");
enc->char_cnt = mapping_len;
enc->unicode = (int32_t*)malloc(mapping_len * sizeof(int32_t));
enc->psnames = (char**)calloc(mapping_len, sizeof(char*));
int i;
for(i = 0; i < mapping_len; ++i)
{
if(mapping[i])
{
enc->unicode[i] = UniFromName(mapping[i], ui_none, &custom);
enc->psnames[i] = strcopy(mapping[i]);
}
else
{
enc->unicode[i] = -1;
}
}
enc->next = enc_head;
enc_head = enc;
ffw_do_reencode(enc, force);
}
/*
* Parse header field.
* Fill .value in headertable.
*/
static void parsefield (char *field)
{
register i;
register char *name, *value;
if (! strncmp (field, "From ", 5)) {
value = field + 5;
while (*value==' ' || *value=='\t')
++value;
for (name=value; *name && *name!=' '; ++name);
*name = 0;
if (*value)
h_from_ = strcopy (value);
return;
}
name = field;
for (value=field; *value && *value!=':'; ++value);
if (! *value)
return;
*value++ = 0;
while (*value==' ' || *value=='\t')
++value;
if (! *value)
return;
for (i=0; headertable[i].name; ++i)
if (!strcasecmp (name, headertable[i].name)) {
*headertable[i].value = strcopy (value);
break;
}
}
my_hostent(const hostent * hent)
{
h_addrtype = hent->h_addrtype;
h_length = hent->h_length;
// Hostname
h_name = strcopy(hent->h_name);
// Host aliases
h_aliases = NULL;
if (hent->h_aliases != NULL)
{
int aliasCount = 0;
for (char ** c = hent->h_aliases; *c != NULL; c++)
aliasCount++;
aliasCount++;
h_aliases = new char*[aliasCount];
memset(h_aliases, 0, sizeof(char *) * aliasCount);
int i = 0;
for (char ** c = hent->h_aliases; *c != NULL; i++, c++)
{
h_aliases[i] = strcopy(*c);
}
}
// Address list
h_addr_list = NULL;
if (hent->h_addr_list != NULL)
{
int addrCount = 0;
for (char ** c = hent->h_addr_list; *c != NULL; c++)
addrCount++;
addrCount += 2;
h_addr_list = new char*[addrCount];
memset(h_addr_list, 0, sizeof(char *) * addrCount);
// Insert our fake address
h_addr_list[addrCount-2] = new char[h_length];
u_long * pAddr = (u_long *)h_addr_list[addrCount-2];
*pAddr = LocalAddress().S_un.S_addr;
int i = 0;
for (char ** c = hent->h_addr_list; *c != NULL; i++,c++)
{
h_addr_list[i] = new char[h_length];
memcpy(h_addr_list[i], *c, h_length);
}
}
}
static track_t *track_create(const char *path,
AVFormatContext *avctx,
int track_index)
{
track_t *track;
char *tmp;
/*av_dump_format(avctx, 0, NULL, 0);*/
/* For each metadata first try container-level metadata. If no value is
* found, try stream-specific metadata.
*/
track = track_new();
track->file = strcopy(path);
track->title = copy_metadata(avctx, "title") ? : copy_metadata(avctx, "song");
if (!track->title) {
/* No title in metadata, use plain filename (no basename, it's crap). */
for (tmp = (char *)path + strlen(path);
tmp > path && *(tmp - 1) != '/';
--tmp) { }
track->title = strcopy(tmp);
}
track->trackindex = track_index;
tmp = get_metadata(avctx, "track");
if (tmp) {
sscanf(tmp, "%d", &track->track);
} else {
track->track = track_index;
}
track->artist = copy_metadata(avctx, "artist") ? : copy_metadata(avctx, "author");
track->album = copy_metadata(avctx, "album") ? : copy_metadata(avctx, "game");
track->albumartist = copy_metadata(avctx, "albumartist");
if (avctx->duration > 0) {
track->duration = avctx->duration / (double)AV_TIME_BASE;
} else {
track->duration =
avctx->streams[0]->duration * av_q2d(avctx->streams[0]->time_base);
}
if (track->duration <= 0) {
track_free(track);
track = NULL;
}
return track;
}
static struct output_descriptor*
output_descriptor_create(const char* driver_name,
const char* server_name)
{
struct output_descriptor* od = malloc(sizeof(*od));
od->id.driver_name = strcopy(driver_name);
od->id.server_name = strcopy(server_name);
// printf("created '%s:%s'\n", driver_name, server_name);
od->drv = 0;
od->ref_count = 0;
return od;
}
void ffw_save(const char * filename)
{
char * _filename = strcopy(filename);
char * _ = strcopy("");
int r = GenerateScript(cur_fv->sf, _filename
, _, -1, -1, NULL, NULL, cur_fv->map, NULL, ly_fore);
free(_);
free(_filename);
if(!r)
err("Cannot save font to %s\n", filename);
}
/**
* @todo FIXME More or less ugly value duplication.
*/
track_t *library_track_by_id(int64_t id)
{
sqlite3_stmt *stmt;
track_t *track;
int result;
static const char *sql =
"SELECT rowid AS id, fileid, file, cuefileid, cuefile, track, title, artistid, artist, albumid, album, start, duration, trackindex FROM tracks WHERE rowid = ?";
if (sqlite3_prepare_v2(db_handle(), sql, -1, &stmt, NULL) != SQLITE_OK) {
musicd_log(LOG_ERROR, "library", "can't prepare '%s': %s", sql,
db_error());
return NULL;
}
sqlite3_bind_int(stmt, 1, id);
result = sqlite3_step(stmt);
if (result == SQLITE_DONE) {
return NULL;
} else if (result != SQLITE_ROW) {
musicd_log(LOG_ERROR, "library", "library_track_by_id: sqlite3_step failed");
return NULL;
}
track = track_new();
track->id = sqlite3_column_int64(stmt, 0);
track->fileid = sqlite3_column_int64(stmt, 1);
track->file = strcopy((const char *)sqlite3_column_text(stmt, 2));
track->cuefileid = sqlite3_column_int64(stmt, 3);
track->cuefile = strcopy((const char *)sqlite3_column_text(stmt, 4));
track->track = sqlite3_column_int(stmt, 5);
track->title = strcopy((const char *)sqlite3_column_text(stmt, 6));
track->artistid = sqlite3_column_int64(stmt, 7);
track->artist = strcopy((const char *)sqlite3_column_text(stmt, 8));
track->albumid = sqlite3_column_int64(stmt, 9);
track->album = strcopy((const char *)sqlite3_column_text(stmt, 10));
track->start = sqlite3_column_double(stmt, 11);
track->duration = sqlite3_column_double(stmt, 12);
track->trackindex = sqlite3_column_double(stmt, 13);
/*musicd_log(LOG_DEBUG, "library", "%" PRId64 " %s %s %d %s %s %s %lf %lf",
track->id, track->file, track->cuefile, track->track, track->title, track->artist,
track->album, track->start, track->duration);*/
sqlite3_finalize(stmt);
return track;
}
static int init_slot(int slot, const struct passwd* pw)
{
struct slot* s;
s = &slots[slot];
if (!strcopy(&s->pw.pw_name, pw->pw_name))
return 0;
s->pw.pw_passwd = 0;
s->pw.pw_uid = pw->pw_uid;
s->pw.pw_gid = pw->pw_gid;
s->pw.pw_gecos = 0;
if (!strcopy(&s->pw.pw_dir, pw->pw_dir))
return 0;
s->pw.pw_shell = 0;
return 1;
}
/* Todo functions */
todo_t *dummy_todos(date_t start, date_t end)
{
todo_t *last = &todo;
for (int i = 0; i < 6; i++) {
last->next = new0(event_t);
last->next->cal = todo.cal;
last->next->name = strcopy(todo.name);
last->next->desc = strcopy(todo.desc);
last->next->due = todo.due;
last->next->status = todo.status;
last = last->next;
last->next = NULL;
}
return enable ? todo.next : 0;
}
int iSpiSend(char *str)
{
int ErrCode;
int Loop;
long lStartMsec, lTemp;
gSpiRxFlag = FALSE;
ErrCode=0;
lStartMsec = lGetMsec();
// wait for finishing last command string
while(Loop) {
if (gSpiRxFlag == TRUE) Loop = FALSE;
lTemp = lGetDelayMsec(lStartMsec);
if ( lTemp > 100) Loop = False;
}
// if not error Send Spi Command String
if( gSpiRxFlag )
{
strcopy(gSpiTxBuf,Str);
gSpiRxFlag = FALSE;
lStartMsec = lGetMsec();
while(Loop) {
if (gSpiRxFlag == TRUE) Loop = FALSE;
if ( lGetDelayMSec( lStartMsec) > 100) Loop = False;
}
}
if(gSpiRxFlag == FALSE ) {
strcpy(str,"- Off Line -");
ErrCode = ERR_SPI_CONNECT;
}
else {
strcopy(str,gSpiRxBuf);
if(str[0] == 'E') ErrCode = 1;
}
return ErrCode;
}
void valeur_elt(t_personne* v)
/* Renvoie dans e la veleur de l'elt courant */
{
if(!hors_liste())
v->sexe= liste[ec].sexe;
strcopy(v->prenom,liste[ec].prenom);
}
static lyrics_t *handle_lyrics_page(const char *page_name)
{
char *url, *page, *lyrics;
lyrics_t *result;
url = url_escape_location("http://lyrics.wikia.com", page_name);
page = url_fetch(url);
if (!page) {
musicd_log(LOG_ERROR, "lyrics", "can't fetch lyrics page");
free(url);
return NULL;
}
lyrics = parse_lyrics_page(page);
free(page);
if (!lyrics) {
free(url);
return NULL;
}
result = lyrics_new();
result->lyrics = lyrics;
result->provider = strcopy("LyricWiki");
result->source = url;
return result;
}
int main()
{
int t,n,i,j,k;
char ans[MaxPL];
freopen("poj3080.txt","r",stdin);
freopen("poj3080ans.txt","w",stdout);
scanf("%d",&t);
while (t--)
{
scanf("%d",&n);
for (i=0;i<n;i++) scanf("%s",s[i]);
ans[0]='\0';
for (i=60;i>=3;i--) if (i>=strlen(ans))
{
for (j=0;j<=60-i;j++)
{
strcopy(s[0],pat,j,j+i-1);
for (k=1;k<n;k++)
{
KMP(pat,s[k],res);
if (res[0]==0) break;
}
if (k<n) continue; //当前子串不符合
if (strlen(ans)==0) strcpy(ans,pat);
else if (strcmp(ans,pat)>0) strcpy(ans,pat);
}
}
if (strlen(ans)==0) printf("no significant commonalities\n");
else printf("%s\n",ans);
}
return 0;
}
char *library_image_path(int64_t image)
{
static const char *sql =
"SELECT files.path AS path FROM images JOIN files ON images.fileid = files.rowid WHERE images.rowid = ?";
sqlite3_stmt *query;
int result;
char *path = NULL;;
if (!prepare_query(sql, &query)) {
return NULL;
}
sqlite3_bind_int64(query, 1, image);
result = sqlite3_step(query);
if (result != SQLITE_DONE && result != SQLITE_ROW) {
musicd_log(LOG_ERROR, "library", "sqlite3_step failed for '%s'", sql);
}
if (result == SQLITE_ROW) {
path = strcopy((const char *)sqlite3_column_text(query, 0));
}
sqlite3_finalize(query);
return path;
}
char *library_directory_path(int64_t directory)
{
static const char *sql =
"SELECT path FROM directories WHERE rowid = ?";
sqlite3_stmt *query;
int result;
char *path = NULL;;
if (!prepare_query(sql, &query)) {
return NULL;
}
sqlite3_bind_int64(query, 1, directory);
result = sqlite3_step(query);
if (result != SQLITE_DONE && result != SQLITE_ROW) {
musicd_log(LOG_ERROR, "library", "sqlite3_step failed for '%s'", sql);
}
if (result == SQLITE_ROW) {
path = strcopy((const char *)sqlite3_column_text(query, 0));
}
sqlite3_finalize(query);
return path;
}
static int tksh_cmd_split(int argc, char *argv[], Shbltin_t *context)
{
int i, size=0;
char **newargv;
char *newptr;
TkshArgcArgv *args = (TkshArgcArgv *)context->ptr;
for (i=1; i < argc; i++)
size += strlen(argv[i]);
newargv = (char **) malloc(size + argc * (sizeof(char *) + 1) );
newptr = (char *) (newargv + argc);
for (i=1; i < argc; i++)
{
newargv[i-1] = newptr;
newptr = strcopy(newptr, argv[i]) + 1;
}
newargv[argc-1]= (char*) 0;
*(args->argcPtr) = argc-1;
*(args->argvPtr) = newargv;
return 0;
}
void show (DIR* dir_ptr,char *dirname,int flag)
{
int Flag,cout=0,l;
struct dirent *direntp;
struct stat buf;
l=strlen(dirname);
dirname[l]='/';
dirname[l+1]='\0';
while((direntp=readdir(dir_ptr))!=NULL)
{
char fullname[4096];
strcopy(fullname,dirname,direntp->d_name);
if(((flag%A)!=0)&&(direntp->d_name[0]=='.'))
continue;
if(flag%U==0)
Flag=true;
if(flag%L==0)
{
display_l(fullname,Flag);
printf("\t%s\n",direntp->d_name);
}
else
{
display(direntp->d_name);
cout++;
if(cout%5==0)
printf("\n");
}
}
printf("\n");
}
/*
* strtok - function to tokenize a string
*
* inputs - str - the string
* result - the resulting string
* delim - the delimeter
*
* returns location of delimeter
*/
void strtoken(char *str, char *result, char delim)
{
static char data[200] = {0};
static int index = 0;
int i = 0;
//Copy over string
if (str != NULL)
{
strcopy(str, data);
index = 0;
}
//Loop through for delimeter
while (data[index] != '\0')
{
//Found delimeter
if (data[index] == delim)
{
result[i] = '\0';
index++;
return;
}
result[i++] = data[index];
index++;
}
result[i] = NULL;
return;
}
void GetGroupCText(int Code, char * str)
{
char st[21];
st[20]=0;
switch(Code){
// C11~ C13 속도지령 방법 외
case ADDR_CMD_INPUT_SET : strcpy(st,"Select CMD In Type") ; break;
case ADDR_CTRL_TYPE_SET : strcpy(st,"Select CTRL Type") ; break;
case ADDR_CHANGE_DIRECTION : strcpy(st,"Direction Change") ; break;
// C21~C24 가감속 시간 설정
case ADDR_ACCEL1_TIME : srtcpy(st,"Accel Ramp1 sec") ; break;
case ADDR_DECEL1_TIME : strcpy(st,"Decel Ramp1 sec") ; break;
case ADDR_ACCEL2_TIME : strcpy(st,"Accel Ramp2 sec") ; break;
case ADDR_DECEL2_TIME : strcpy(st,"Decel Ramp2 sec") ; break;
// C31~C38 다단 속도 설정
case ADDR_JOG_SPEED : strcpy(st,"Jog Speed Hz") ; break;
case ADDR_DIN_SPEED2 : strcpy(st,"DIN Speed2 Hz") ; break;
case ADDR_DIN_SPEED3 : strcpy(st,"DIN Speed3 Hz") ; break;
case ADDR_DIN_SPEED4 : strcpy(st,"DIN Speed4 Hz") ; break;
case ADDR_DIN_SPEED5 : strcpy(st,"DIN Speed5 Hz") ; break;
case ADDR_DIN_SPEED6 : strcpy(st,"DIN Speed6 Hz") ; break;
case ADDR_DIN_SPEED7 : strcpy(st,"DIN Speed7 Hz") ; break;
case ADDR_DIN_SPEED8 : strcpy(st,"DIN Speed8 Hz") ; break;
}
strcopy(str,st);
}
/******************************************************************************
*
* I N S T A L L _ A B B R E V S (char *name, node *n)
*
* Install a name as a hidden procedure with all the abbreviations implied by
* specifications of the form: COM(MAND)
*
* With DEFPROC or DEFSTRING one can specify the new command or procedure
* using COM(MAND) meaning that COM, COMM, COMMA, COMMAN and COMMAND are all
* suitable forms of the command. This routine generates all the
* abbreviations and adds each as a HIDDEN_PROC to the global
* symbol table with the value "n".
*
* WILL FAIL GIVEN COMM() ie empty optional part!!
*
******************************************************************************
*/
value
install_abbrevs(char *name, node * n)
{
value val;
node *nw;
char *p;
if ((name = strcopy(name)) == CHARNIL)
return exception("SYSERR memory exhausted in install_abbrevs()");
if ((p = strchr(name, '(')) != CHARNIL) {
do {
*p = '\0';
if ((nw = nodecopy(n)) == NODENIL)
return exception(
"SYSERR memory exhausted in install_abbrevs()");
if (isexc(val = store_symbol(name, SYM_DEFINED, nw)))
return (val);
else {
*p = p[1];
p++;
}
}
while (*p && *p != ')');
return trueval;
} else
return (store_symbol(name, SYM_DEFINED, n));
}
tree* new_node(char* s){
tree* tmp = (tree*)malloc(sizeof(tree));
tmp->s = (char*)malloc(MAX*sizeof(char));
strcopy(s,tmp->s);
tmp->child = NULL;
tmp->sibling = NULL;
return tmp;
}
void modif_elt(t_personne v)
/* Affecte v à l'elt courant */
{
if(!hors_liste())
liste[ec].sexe=v.sexe;
strcopy(liste[ec].prenom,v.prenom);
}
void patches(void){
//Change version string
for(int i = 0; i < 0x600000; i+=4){
if(strcomp((void*)0x27B00000 - i, (void*)L"Ver.", 4)){
if(strcomp((void*)0x27B00000 - i + 0x28, (void*)"T_ver_00", 4)) strcopy((void*)0x27B00000 - i, (void*)L"\uE024Rei", 4);
}
}
}
meta_t create_meta(cache_t cache, _key_t key, uint32_t val_size)
{
meta_t next_meta = malloc(sizeof(meta_obj));
strcopy(key, next_meta->key);
next_meta->size = val_size;
next_meta->allocated = 1;
next_meta->timer = 0;
}
Constante* ConstanteFactory::getConstante(const QString &str) {
QString strcopy(str.toUpper());
/* Teste si la chaine correspond à l'expression régulière ^'.+'$
càd si c'est une suite de caractères entre simples quotes.
Dans ce cas, on renvoie un objet de type Expression. */
if((QRegExp("^'\.+'$").indexIn(strcopy))!=-1) {
return new Expression(strcopy);
}
// Fake readline function
char* readline(char* prompt) {
fputs(prompt, stdout)
fgets(buffer, 2048, stdin);
char* cpy = malloc(strlen(buffer)+1);
strcopy(cpy, buffer);
cpy[strlen(cpy)-1] = '\0';
return cpy;
}
void patches(void){
//Change version string
for(int i = 0; i < 0x600000; i+=4){
if(strcomp((void*)0x27B00000 - i, (void*)L"Ver.", 4)){
if(strcomp((void*)0x27B00000 - i + 0x0A, (void*)L"%d.%d.%d-%d", 11)) strcopy((void*)0x27B00000 - i, (void*)L"\uE024Rei", 4);
}
}
}
int main() {
char *str = "string";
char *wrd = "word";
char src[] = "source";
char dest[] = "destination";
char concat[ strlength(dest) + strlength(src) ];
char empty[100];
char a[] = "abc";
char b[] = "ab";
int i = 1;
printf( "Testing strlength with string: %s\n", str );
printf( "String length: %d \n", strlength( str ) );
printf( "Testing strlength with string: %s\n", wrd );
printf( "String length: %d\n", strlength( wrd ) );
printf( "\n" );
printf( "Testing strcopy with string: %s\n", src );
printf( "Testing strcopy with string: %s\n", empty );
strcopy( empty, src );
printf("Empty string is now: %s\n", empty );
printf( "\n" );
printf( "Testing strconcat with string: %s\n", src );
printf( "Testing strconcat with string: %s\n", dest );
printf( "Appends the first: %d character(s) \n", i );
strconcatn( concat, dest, src, i );
printf( "Concatenated string: %s\n", concat );
printf( "\n" );
printf( "Testing strcomp with string: abc and ab \n" );
printf( "%d\n", strcomp( a, b ) );
printf( "Testing strcomp with string: abc and abc \n" );
printf( "%d\n", strcomp( a, a ) );
printf( "This answer is wrong! Still working on it." );
printf( "\n" );
printf( "Testing strchar with string: %s. Return place if found -1 if not found\n", src );
printf( "Looking for s \n" );
printf( "%d\n", strchar( src, 's' ) );
printf( "Looking for 1 \n" );
printf( "%d\n", strchar( src, '1' ) );
printf( "Looking for e \n" );
printf( "%d\n", strchar( src, 'e' ) );
printf( "\n" );
printf( "Testing strstring with strings %s and %s. Return 1 if found -1 if not found \n", a, b );
printf( "%d This answer is wrong! I used my strcomp (broken method for now) in this method which is why it churned out the wrong answer. \n", strstring( a, b ) );
return 0;
}
void main()
{
char a[10]="hello";
printf("%d\n",strlength(a));
char b[strlength(a)];
strcopy(b,a);
printf("%s\n",b);
}
