@@ -47,46 +47,46 @@
* \brief 'Parse a changeset'. It's more like pointing to the correct
position.
*
* The changeset could be found on buff pointer. To not duplicate the data
I
- * choose to point every log_entry field to the right position.
- * \param buff The pointer where changeset could be found.
- * \param le The log_entry_t structure where the changeset will be parse.
+ * choose to point every hg_cset_entry field to the right position.
+ * \param cset The pointer where changeset could be found.
+ * \param ce The hg_cset_entry structure where the changeset will be
parse.
* \retval 0 if successful.
* */
-int parse_changeset(char *cset, hg_log_entry_t *le)
+int parse_changeset(char *cset, hg_cset_entry *ce)
{
char *position = cset;
/* set pointer for revision position */
- le->rev = cset;
+ ce->rev = cset;
position = strstr(position, "\n");
cset[position - cset] = '\0';
/* set pointer for node position */
- le->node = position + 1;
+ ce->node = position + 1;
position = strstr(position + 1, "\n");
cset[position - cset] = '\0';
/* set pointer for tag position */
- le->tags = position + 1;
+ ce->tags = position + 1;
position = strstr(position + 1, "\n");
cset[position - cset] = '\0';
/* set pointer for branch position */
- le->branch = position + 1;
+ ce->branch = position + 1;
position = strstr(position + 1, "\n");
cset[position - cset] = '\0';
/* set pointer for author position */
- le->author = position + 1;
+ ce->author = position + 1;
position = strstr(position + 1, "\n");
cset[position - cset] = '\0';
/* set pointer for data position */
- le->date = position + 1;
+ ce->date = position + 1;
position = strstr(position + 1, "\n");
cset[position - cset] = '\0';
/* set pointer for description position */
- le->desc = position + 1;
+ ce->desc = position + 1;
/* */
return 0;
}
@@ -177,82 +177,82 @@
}
/* The high level log command for hglib API. */
-hg_cset_iterator *hg_log(hg_handle *handle, char *option[])
+hg_logadata_buffer *hg_log(hg_handle *handle, char *option[])
{
- hg_cset_iterator *iterator = malloc(sizeof(hg_cset_iterator));
+ hg_logadata_buffer *lbuf = malloc(sizeof(hg_logadata_buffer));
- iterator->handle = handle;
- iterator->command = cmdbuilder("log", option, CHANGESET);
+ lbuf->handle = handle;
+ lbuf->command = cmdbuilder("log", option, CHANGESET);
- if(hg_rawcommand(handle, iterator->command) < 0){
+ if(hg_rawcommand(handle, lbuf->command) < 0){
return NULL;
}
- iterator->cset = NULL;
- iterator->cset_size = 0;
- iterator->cset_send = 0;
+ lbuf->buffer = NULL;
+ lbuf->buf_size = 0;
+ lbuf->is_sent = 0;
- return iterator;
+ return lbuf;
}
/* The iterator next step. Getting the next changeset. */
-int hg_fetch_cset_entry(hg_cset_iterator *iter, hg_cset_entry_t *le)
+int hg_fetch_cset_entry(hg_logadata_buffer *lbuf, hg_cset_entry *centry)
{
- hg_header head = hg_head(iter->handle);
+ hg_header head = hg_head(lbuf->handle);
int exitcode;
char *get_data;
int read_size;
/* Erase the first cset from cset pointer.
* This cset was already pass to user.*/
- if(iter->cset_send && iter->cset_size){
- iter->cset_size = erase_cset(&iter->cset, iter->cset_size,
- iter->top_cset_size);
- iter->cset_send = 0;
+ if(lbuf->is_sent && lbuf->buf_size){
+ lbuf->buf_size = erase_cset(&lbuf->cset, lbuf->buf_size,
+ lbuf->first_cset_size);
+ lbuf->is_sent = 0;
}
while(head.channel != 'r'){
/* If there is a cset in cset pointer, then parse it and send
* it to user.*/
- if(iter->cset && strlen(iter->cset + 1) < iter->cset_size -1){
- iter->top_cset_size = strlen(iter->cset + 1) + 1;
- parse_changeset(iter->cset + 1, le);
- iter->cset_send = 1;
+ if(lbuf->buffer && strlen(lbuf->buffer + 1) < lbuf->buf_size -1){
+ lbuf->first_cset_size = strlen(lbuf->buffer + 1) + 1;
+ parse_buffer(lbuf->buffer + 1, centry);
+ lbuf->is_sent = 1;
return head.length;
}
else{
/* Getting the next data from cmdserver and put on the
* end of the cset pointer. */
get_data = malloc(head.length + 1);
- if(read_size = hg_rawread(iter->handle, get_data,
+ if(read_size = hg_rawread(lbuf->handle, get_data,
head.length), read_size < 0){
return -1;
}
- adding_data(&iter->cset, get_data, iter->cset_size,
+ adding_data(&lbuf->cset, get_data, lbuf->buf_size,
read_size);
- iter->cset_size += read_size;
+ lbuf->buf_size += read_size;
free(get_data);
}
}
/* After, receiveing the last message, there still could be some
* csets on cset pointer. */
- if(iter->cset && strlen(iter->cset + 1) == iter->cset_size -1){
- iter->top_cset_size = strlen(iter->cset + 1) + 1;
- parse_changeset(iter->cset + 1, le);
- iter->cset_size = 0;
- iter->cset_send = 1;
+ if(lbuf->buffer && strlen(lbuf->buffer + 1) == lbuf->buf_size -1){
+ lbuf->first_cset_size = strlen(lbuf->buffer + 1) + 1;
+ parse_buffer(lbuf->buffer + 1, centry);
+ lbuf->buf_size = 0;
+ lbuf->is_sent = 1;
return head.length;
/* Parse first cset from the remaining data. */
- }else if(iter->cset_size && iter->cset_send){
- iter->top_cset_size = strlen(iter->cset + 1) + 1;
- parse_changeset(iter->cset + 1, le);
- iter->cset_send = 1;
+ }else if(lbuf->buf_size && lbuf->is_sent){
+ lbuf->first_cset_size = strlen(lbuf->buffer + 1) + 1;
+ parse_buffer(lbuf->buffer + 1, centry);
+ lbuf->is_sent = 1;
return head.length;
}
- exitcode = hg_exitcode(iter->handle);
- free(iter->command);
- free(iter->cset);
- free(iter);
+ exitcode = hg_exitcode(lbuf->handle);
+ free(lbuf->command);
+ free(lbuf->buffer);
+ free(lbuf);
return exitcode;
}
@@ -69,16 +69,16 @@
char *debug_data;
} hg_handle;
-typedef struct hg_cset_iterator{
+typedef struct hg_logdata_buffer{
hg_handle *handle;
char **command;
- char *changeset;
- int cset_size;
- int cset_send;
- int top_cset_size;
-}hg_cset_iterator;
+ char *buffer;
+ int buf_size;
+ int is_sent;
+ int first_cset_size;
+}hg_logdata_buffer;
-typedef struct hg_cset_entry_t{
+typedef struct hg_cset_entry{
char *author;
char *branch;
char *date;
@@ -86,7 +86,7 @@
char *node;
char *rev;
char *tags;
-}hg_cset_entry_t;
+}hg_cset_entry;
/**
* \brief Open the connection with the mercurial command server.
@@ -289,16 +289,16 @@
* errno can be:
* - hg_rawcommand errors
* */
-hg_cset_iterator *hg_log(hg_handle *handle, char *option[]);
+hg_logdata_buffer *hg_log(hg_handle *handle, char *option[]);
/**
* \brief The iterator step. Getting the next changeset.
*
* The revision history could have a huge mass of data. You can pass the
entire
* history in one call, so we use an iterator-like mechanism. Calling the
- * hg_fetch_log_entry, the next changeset will be read from cmd-server,
parse
- * and pass to hg_log_entry_t structure.
- * The log_entry structure will handle a changeset with the following
string
+ * hg_fetch_cset_entry, the next changeset will be read from cmd-server,
parse
+ * and pass to hg_cset_entry structure.