text:
Q: Can't locate OAuth.pm in Runtime.pm. Net::Twitter module I have such script: (Script.pl)
#!/usr/bin/perl
use strict;
use warnings;
use encoding 'utf-8';
use FindBin;
use lib "$FindBin::Bin/lib";
use TwitterModule;
use IO::Prompt;

# Read keys from file
open KEYS, "<keys.txt" or die $!;
my ($ckey, $csecret, $atocken, $asecret) = <KEYS>;

# Auth
my $nt = TwitterModule::auth($ckey, $csecret, $atocken, $asecret) ;

# Other code skipped.

and such module: (lib/TwitterModule.pm)
package TwitterModule;
use strict;
use warnings;
use utf8;
use encoding 'utf8';
use base 'Exporter';
use Net::Twitter;

BEGIN {
    use Exporter();

    our $VERSION = '0.01b';
    our @EXPORT_OK = qw(&auth);
    our %EXPORT_TAGS = (
        'functions' => [ qw(&auth) ]
    );

    # add all the other ":class" tags to the ":all" class, deleting duplicates

    my %seen;
    push @{$EXPORT_TAGS{all}},
        grep {!$seen{$_}++} @{$EXPORT_TAGS{$_}} foreach keys %EXPORT_TAGS;
}

### Common variables ###
# Make connection
sub auth {
    my ($ckey, $csecret, $atocken, $asecret) = @_;

    my $cn = Net::Twitter->new(
        traits              => [qw/Oauth API::REST/],
        consumer_key        => $ckey,
        consumer_secret     => $csecret,
        access_tocken       => $atocken,
        access_token_secret => $asecret
    );
    return $cn;
}

# Other code skipped
# return true
1

Then, i execute my script and get it: "Can't locate Net/Twitter/Role/Oauth.pm in @INC (@INC contains: /home/rasmi/work/my_project/lib /usr/lib/perl5/site_perl /usr/share/perl5/site_perl /usr/lib/perl5/vendor_perl /usr/share/perl5/vendor_perl /usr/lib/perl5/core_perl /usr/share/perl5/core_perl .) at /usr/share/perl5/vendor_perl/Module/Runtime.pm line 205,  line 4. at /home/rasmi/work/my_project/lib/TwitterModule.pm line 6"
I have installed Net::Twitter and all necessary utils and tested it at the two machines. If i used Net::Twitter without modules, in one script, everything works fine. File /usr/share/perl5/vendor_perl/Net/Twitter/Role/Oauth.pm exist.
I am very surprised by this behavior and would be very grateful for the help.

A: It looks like it's spelled Net::Twitter::Role::OAuth--note the capital 'A'. You're probably on a case-sensitive filesystem.
Correct the line in your auth subroutine:
traits              => [qw/OAuth API::REST/],

And it will likely start working.


text:
Q: How to install jboss7.1 on centos7? I have used following commands to install java.
 wget --no-cookies --no-check-certificate --header "Cookie: gpw_e24=http%3A%2F%2Fwww.oracle.com%2F; oraclelicense=accept-securebackup-cookie" "http://download.oracle.com/otn-pub/java/jdk/8u112-b15/jdk-8u112-linux-x64.rpm"

After that  yum install jdk-8u112-linux-x64.rpm
Now i downloaded the jboss
wget http://download.jboss.org/jbossas/7.1/jboss-as-7.1.1.Final/jboss-as-7.1.1.Final.zip

after that unziped it
unzip jboss-as-7.1.1.Final.zip
I have placed jboss in /opt/jboss-as-7.1.1.Final directory

after that i have used following commands
 adduser jboss
 chown -fR jboss.jboss /opt/jboss-as-7.1.1.Final/
 su jboss

also i saved that path using the command
export JAVA_HOME=/usr/java/jdk1.8.0_112/
export PATH=$PATH:$JAVA_HOME/bin

Actually i am following these steps from a tutorial and in the last when i am running the standalone.sh file its showing following lines and not moving beyond this, please help
its is not moving beyond this
    [jboss@centos_pc2 bin]$ ./standalone.sh
=========================================================================

  JBoss Bootstrap Environment

  JBOSS_HOME: /opt/jboss-as

  JAVA: /usr/java/jdk1.8.0_112//bin/java

  JAVA_OPTS:  -server -XX:+UseCompressedOops -XX:+TieredCompilation -Xms64m -Xmx1024m -XX:MaxPermSize=512m -Djava.net.preferIPv4Stack=true -Dorg.jboss.resolver.warning=true -Dsun.rmi.dgc.client.gcInterval=3600000 -Dsun.rmi.dgc.server.gcInterval=3600000 -Djboss.modules.system.pkgs=org.jboss.byteman -Djava.awt.headless=true -Djboss.server.default.config=standalone.xml

=========================================================================

Java HotSpot(TM) 64-Bit Server VM warning: ignoring option MaxPermSize=512m; support was removed in 8.0
12:47:33,368 INFO  [org.jboss.modules] JBoss Modules version 1.1.1.GA
12:47:33,608 INFO  [org.jboss.msc] JBoss MSC version 1.0.2.GA
12:47:33,679 INFO  [org.jboss.as] JBAS015899: JBoss AS 7.1.1.Final "Brontes" starting

A: All you need is to change to Java version 7 or 6 and then try to start JBoss again.

redpajama_set_name: RedPajamaStackExchange


text:
Q: PHP table (Date) dynamic color change based on validity

 Client_Contract_Number
Currently_Using
MBPS_EAM_Number_RIGT
Model_and_Type
LFour_Yearly
Six_Monthly
One_Yearly
One_and_Half_Yearly
Two_Yearly
Two_and_Half_Yearly
Three_Yearly
Three_and_Half_Yearly
Four_Yearly
Remarks

<?php
while($rows=mysql_fetch_array($result)){
?>

 <? echo $rows['Client_Contract_Number']; ?>
 <? echo $rows['Currently_Using']; ?>
 <? echo $rows['MBPS_EAM_Number_RIGT']; ?>
 <? echo $rows['Model_and_Type']; ?>
 <? echo $rows['LFour_Yearly']; ?>
 <? echo $rows['Six_Monthly']; ?>
 <? echo $rows['One_Yearly']; ?>
 <? echo $rows['One_and_Half_Yearly']; ?>
 <? echo $rows['Two_Yearly']; ?>
 <? echo $rows['Two_and_Half_Yearly']; ?>
 <? echo $rows['Three_Yearly']; ?>
 <? echo $rows['Three_and_Half_Yearly']; ?>
 <? echo $rows['Four_Yearly']; ?>
 <? echo $rows['Remarks']; ?>

    <?php
     }
     ?>

Below is my table, it is to track the validity of certificates, columns from Lfour yearly till Fouryearly are date fields, i would like to conditional color format these fields based on validity... Like If valid - Green, Expired - Red.

A: Since PHP >= 5.2.0 you can use the DateTime class as such:
if (new DateTime() > new DateTime("2010-05-15 16:00:00")) {
    # current time is greater than 2010-05-15 16:00:00
    # in other words, 2010-05-15 16:00:00 has passed
}

The string passed to the DateTime constructor is parsed according to these rules.
Here is an example with your code:
<td class="exdate" style="color:<?php echo (new DateTime() > new DateTime($rows['Six_Monthly'])) ? 'red' : 'green'; ?>;" ><? echo $rows['Six_Monthly']; ?>


text:
Q: Get workflow associated list items I have one requirement to get all the list items which has associated with a particular workflow in SharePoint 2013. Like, I have a designer 2013 workflow with name "Test Workflow" which is added in a custom list. Tis workflow associated with around 70 items. In the same list I've added another workflow with name "Test Workflow 2". I need to fetch the ID of all the list items which are associated with the first workflow (all the 70 items ID).

A: I suppose a query can be built filtering
taskItem["WorkflowListId"]
taskItem["WorkflowItemId"]

as discussed in this social technet article


text:
Q: Persisting data in sklearn I'm using scikit-learn to cluster text documents. I'm using the classes CountVectorizer, TfidfTransformer and MiniBatchKMeans to help me do that.
New text documents are added to the system all the time, which means that I need to use the classes above to transform the text and predict a cluster. My question is: how should I store the data on disk?
Should I simply pickle the vectorizer, transformer and kmeans objects?
Should I just save the data? If so, how do I add it back to the vectorizer, transformer and kmeans objects?
Any help would be greatly appreciated

A: It depends on what you want to do.
If you want to find some fixed cluster centers on a training set and then re-use them later to compute cluster assignments for new data then pickling the models (or just saving the vocabulary of the vectorizer and the other models constructors parameters and the cluster center positions) is ok.
If what you want is doing clustering with new data, you might want to retrain the whole pipeline using the union of the new data + the old data to make it possible for the vocabulary of the vectorizer to build new features (dimensions) for the new words and let the clustering algorithm find cluster centers that better match the structure of the complete dataset.
Note that in the future we will provide hashing vectorizers (see for instance this pull request on hashing transformers as a first building block), hence storing the vocabulary won't be necessary any more (but you will loose the ability to introspect the "meaning" of the feature dimensions).
As for pickling the models vs using your own representation for their parameters I have answered this part in your previous question here:  Persist Tf-Idf data

A: Yeah, I think the general answer with sk-learn is to pickle and pray.
It seems to me that this is super fragile, compared to have a documented serialization format that doesn't depend on implementation details.  But maybe they know this, and won't make backwards incompatible changes to their classes?


text:
Q: Why simple prompt in a function doesn't work? In this page javascript prompt works only if directly called in body section, if we try to call functions show() or showIN(), the first in head section, the second in body section, the var is undefined. Why ?
<!DOCTYPE html>

<button id = "one" onClick = "show();">show</button>

<button id = "two" onClick = "showIN();">showIN</button>

A:

<!DOCTYPE html>

<button id = "one" onClick = "show();">show</button>

<button id = "two" onClick = "showIN();">showIN</button>

You need to place script inside of Body not Head. Please check snippet.


text:
Q: Split string with delimiters in C How do I write a function to split and return an array for a string with delimiters in the C programming language?
char* str = "JAN,FEB,MAR,APR,MAY,JUN,JUL,AUG,SEP,OCT,NOV,DEC";
str_split(str,',');

A: I think strsep is still the best tool for this:
while ((token = strsep(&str, ","))) my_fn(token);

That is literally one line that splits a string.
The extra parentheses are a stylistic element to indicate that we're intentionally testing the result of an assignment, not an equality operator ==.
For that pattern to work, token and str both have type char *. If you started with a string literal, then you'd want to make a copy of it first:
// More general pattern:
const char *my_str_literal = "JAN,FEB,MAR";
char *token, *str, *tofree;

tofree = str = strdup(my_str_literal);  // We own str's memory now.
while ((token = strsep(&str, ","))) my_fn(token);
free(tofree);

If two delimiters appear together in str, you'll get a token value that's the empty string. The value of str is modified in that each delimiter encountered is overwritten with a zero byte - another good reason to copy the string being parsed first.
In a comment, someone suggested that strtok is better than strsep because strtok is more portable. Ubuntu and Mac OS X have strsep; it's safe to guess that other unixy systems do as well. Windows lacks strsep, but it has strbrk which enables this short and sweet strsep replacement:
char *strsep(char **stringp, const char *delim) {
  if (*stringp == NULL) { return NULL; }
  char *token_start = *stringp;
  *stringp = strpbrk(token_start, delim);
  if (*stringp) {
    **stringp = '\0';
    (*stringp)++;
  }
  return token_start;
}

Here is a good explanation of strsep vs strtok. The pros and cons may be judged subjectively; however, I think it's a telling sign that strsep was designed as a replacement for strtok.

A: In the above example, there would be a way to return an array of null terminated strings (like you want) in place in the string. It would not make it possible to pass a literal string though, as it would have to be modified by the function:
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

char** str_split( char* str, char delim, int* numSplits )
{
    char** ret;
    int retLen;
    char* c;

    if ( ( str == NULL ) ||
        ( delim == '\0' ) )
    {
        /* Either of those will cause problems */
        ret = NULL;
        retLen = -1;
    }
    else
    {
        retLen = 0;
        c = str;

        /* Pre-calculate number of elements */
        do
        {
            if ( *c == delim )
            {
                retLen++;
            }

            c++;
        } while ( *c != '\0' );

        ret = malloc( ( retLen + 1 ) * sizeof( *ret ) );
        ret[retLen] = NULL;

        c = str;
        retLen = 1;
        ret[0] = str;

        do
        {
            if ( *c == delim )
            {
                ret[retLen++] = &c[1];
                *c = '\0';
            }

            c++;
        } while ( *c != '\0' );
    }

    if ( numSplits != NULL )
    {
        *numSplits = retLen;
    }

    return ret;
}

int main( int argc, char* argv[] )
{
    const char* str = "JAN,FEB,MAR,APR,MAY,JUN,JUL,AUG,SEP,OCT,NOV,DEC";

    char* strCpy;
    char** split;
    int num;
    int i;

    strCpy = malloc( strlen( str ) * sizeof( *strCpy ) );
    strcpy( strCpy, str );

    split = str_split( strCpy, ',', &num );

    if ( split == NULL )
    {
        puts( "str_split returned NULL" );
    }
    else
    {
        printf( "%i Results: \n", num );

        for ( i = 0; i < num; i++ )
        {
            puts( split[i] );
        }
    }

    free( split );
    free( strCpy );

    return 0;
}

There is probably a neater way to do it, but you get the idea.

A: #include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <errno.h>

/**
 *  splits str on delim and dynamically allocates an array of pointers.
 *
 *  On error -1 is returned, check errno
 *  On success size of array is returned, which may be 0 on an empty string
 *  or 1 if no delim was found.
 *
 *  You could rewrite this to return the char ** array instead and upon NULL
 *  know it's an allocation problem but I did the triple array here.  Note that
 *  upon the hitting two delim's in a row "foo,,bar" the array would be:
 *  { "foo", NULL, "bar" }
 *
 *  You need to define the semantics of a trailing delim Like "foo," is that a
 *  2 count array or an array of one?  I choose the two count with the second entry
 *  set to NULL since it's valueless.
 *  Modifies str so make a copy if this is a problem
 */
int split( char * str, char delim, char ***array, int *length ) {
  char *p;
  char **res;
  int count=0;
  int k=0;

  p = str;
  // Count occurance of delim in string
  while( (p=strchr(p,delim)) != NULL ) {
    *p = 0; // Null terminate the deliminator.
    p++; // Skip past our new null
    count++;
  }

  // allocate dynamic array
  res = calloc( 1, count * sizeof(char *));
  if( !res ) return -1;

  p = str;
  for( k=0; k<count; k++ ){
    if( *p ) res[k] = p;  // Copy start of string
    p = strchr(p, 0 );    // Look for next null
    p++; // Start of next string
  }

  *array = res;
  *length = count;

  return 0;
}

char str[] = "JAN,FEB,MAR,APR,MAY,JUN,JUL,AUG,SEP,OCT,NOV,DEC,";

int main() {
  char **res;
  int k=0;
  int count =0;
  int rc;

  rc = split( str, ',', &res, &count );
  if( rc ) {
    printf("Error: %s errno: %d \n", strerror(errno), errno);
  }

  printf("count: %d\n", count );
  for( k=0; k<count; k++ ) {
    printf("str: %s\n", res[k]);
  }

  free(res );
  return 0;
}

A: I think the following solution is ideal:

*

*Doesn't destroy the source string

*Re-entrant - i.e., you can safely call it from anywhere in one or more threads

*Portable

*Handles multiple separators correctly

*Fast and efficient

Explanation of the code:

*

*Define a structure token to store the address and lengths of the tokens

*Allocate enough memory for these in the worst case, which is when
str is made up entirely of separators so there are strlen(str) + 1
tokens, all of them empty strings

*Scan str recording the address and length of every token

*Use this to allocate the output array of the correct size, including an extra space for a NULL sentinel value

*Allocate, copy, and add the tokens using the start and length
information - use memcpy as it's faster than strcpy and we know
the lengths

*Free the token address and length array

*Return the array of tokens

typedef struct {
    const char *start;
    size_t len;
} token;

char **split(const char *str, char sep)
{
    char **array;
    unsigned int start = 0, stop, toks = 0, t;
    token *tokens = malloc((strlen(str) + 1) * sizeof(token));
    for (stop = 0; str[stop]; stop++) {
        if (str[stop] == sep) {
            tokens[toks].start = str + start;
            tokens[toks].len = stop - start;
            toks++;
            start = stop + 1;
        }
    }
    /* Mop up the last token */
    tokens[toks].start = str + start;
    tokens[toks].len = stop - start;
    toks++;
    array = malloc((toks + 1) * sizeof(char*));
    for (t = 0; t < toks; t++) {
        /* Calloc makes it nul-terminated */
        char *token = calloc(tokens[t].len + 1, 1);
        memcpy(token, tokens[t].start, tokens[t].len);
        array[t] = token;
    }
    /* Add a sentinel */
    array[t] = NULL;
    free(tokens);
    return array;
}
Note malloc checking omitted for brevity.
In general, I wouldn't return an array of char * pointers from a split function like this as it places a lot of responsibility on the caller to free them correctly. An interface I prefer is to allow the caller to pass a callback function and call this for every token, as I have described here: Split a String in C.

A: String tokenizer this code should put you in the right direction.
int main(void) {
  char st[] ="Where there is will, there is a way.";
  char *ch;
  ch = strtok(st, " ");
  while (ch != NULL) {
    printf("%s\n", ch);
    ch = strtok(NULL, " ,");
  }
  getch();
  return 0;
}

A: My version:
int split(char* str, const char delimeter, char*** args) {
    int cnt = 1;
    char* t = str;

    while (*t == delimeter) t++;

    char* t2 = t;
    while (*(t2++))
        if (*t2 == delimeter && *(t2 + 1) != delimeter && *(t2 + 1) != 0) cnt++;

    (*args) = malloc(sizeof(char*) * cnt);

    for(int i = 0; i < cnt; i++) {
        char* ts = t;
        while (*t != delimeter && *t != 0) t++;

        int len = (t - ts + 1);
        (*args)[i] = malloc(sizeof(char) * len);
        memcpy((*args)[i], ts, sizeof(char) * (len - 1));
        (*args)[i][len - 1] = 0;

        while (*t == delimeter) t++;
    }

    return cnt;
}

A: This function takes a char* string and splits it by the deliminator.  There can be multiple deliminators in a row.  Note that the function modifies the orignal string.  You must make a copy of the original string first if you need the original to stay unaltered.  This function doesn't use any cstring function calls so it might be a little faster than others.  If you don't care about memory allocation, you can allocate sub_strings at the top of the function with size strlen(src_str)/2 and (like the c++ "version" mentioned) skip the bottom half of the function.  If you do this, the function is reduced to O(N), but the memory optimized way shown below is O(2N).
The function:
char** str_split(char *src_str, const char deliminator, size_t &num_sub_str){
  //replace deliminator's with zeros and count how many
  //sub strings with length >= 1 exist
  num_sub_str = 0;
  char *src_str_tmp = src_str;
  bool found_delim = true;
  while(*src_str_tmp){
    if(*src_str_tmp == deliminator){
      *src_str_tmp = 0;
      found_delim = true;
    }
    else if(found_delim){ //found first character of a new string
      num_sub_str++;
      found_delim = false;
      //sub_str_vec.push_back(src_str_tmp); //for c++
    }
    src_str_tmp++;
  }
  printf("Start - found %d sub strings\n", num_sub_str);
  if(num_sub_str <= 0){
    printf("str_split() - no substrings were found\n");
    return(0);
  }

  //if you want to use a c++ vector and push onto it, the rest of this function
  //can be omitted (obviously modifying input parameters to take a vector, etc)

  char **sub_strings = (char **)malloc( (sizeof(char*) * num_sub_str) + 1);
  const char *src_str_terminator = src_str_tmp;
  src_str_tmp = src_str;
  bool found_null = true;
  size_t idx = 0;
  while(src_str_tmp < src_str_terminator){
    if(!*src_str_tmp) //found a NULL
      found_null = true;
    else if(found_null){
      sub_strings[idx++] = src_str_tmp;
      //printf("sub_string_%d: [%s]\n", idx-1, sub_strings[idx-1]);
      found_null = false;
    }
    src_str_tmp++;
  }
  sub_strings[num_sub_str] = NULL;

  return(sub_strings);
}

How to use it:
  char months[] = "JAN,FEB,MAR,APR,MAY,JUN,JUL,AUG,SEP,OCT,NOV,DEC";
  char *str = strdup(months);
  size_t num_sub_str;
  char **sub_strings = str_split(str, ',', num_sub_str);
  char *endptr;
  if(sub_strings){
    for(int i = 0; sub_strings[i]; i++)
      printf("[%s]\n", sub_strings[i]);
  }
  free(sub_strings);
  free(str);

A: This is a string splitting function that can handle multi-character delimiters. Note that if the delimiter is longer than the string that is being split, then buffer and stringLengths will be set to (void *) 0, and numStrings will be set to 0.
This algorithm has been tested, and works. (Disclaimer: It has not been tested for non-ASCII strings, and it assumes that the caller gave valid parameters)
void splitString(const char *original, const char *delimiter, char ** * buffer, int * numStrings, int * * stringLengths){
    const int lo = strlen(original);
    const int ld = strlen(delimiter);
    if(ld > lo){
        *buffer = (void *)0;
        *numStrings = 0;
        *stringLengths = (void *)0;
        return;
    }

    *numStrings = 1;

    for(int i = 0;i < (lo - ld);i++){
        if(strncmp(&original[i], delimiter, ld) == 0) {
            i += (ld - 1);
            (*numStrings)++;
        }
    }

    *stringLengths = (int *) malloc(sizeof(int) * *numStrings);

    int currentStringLength = 0;
    int currentStringNumber = 0;
    int delimiterTokenDecrementCounter = 0;
    for(int i = 0;i < lo;i++){
        if(delimiterTokenDecrementCounter > 0){
            delimiterTokenDecrementCounter--;
        } else if(i < (lo - ld)){
            if(strncmp(&original[i], delimiter, ld) == 0){
                (*stringLengths)[currentStringNumber] = currentStringLength;
                currentStringNumber++;
                currentStringLength = 0;
                delimiterTokenDecrementCounter = ld - 1;
            } else {
                currentStringLength++;
            }
        } else {
            currentStringLength++;
        }

        if(i == (lo - 1)){
            (*stringLengths)[currentStringNumber] = currentStringLength;
        }
    }

    *buffer = (char **) malloc(sizeof(char *) * (*numStrings));
    for(int i = 0;i < *numStrings;i++){
        (*buffer)[i] = (char *) malloc(sizeof(char) * ((*stringLengths)[i] + 1));
    }

    currentStringNumber = 0;
    currentStringLength = 0;
    delimiterTokenDecrementCounter = 0;
    for(int i = 0;i < lo;i++){
        if(delimiterTokenDecrementCounter > 0){
            delimiterTokenDecrementCounter--;
        } else if(currentStringLength >= (*stringLengths)[currentStringNumber]){
            (*buffer)[currentStringNumber][currentStringLength] = 0;
            delimiterTokenDecrementCounter = ld - 1;
            currentStringLength = 0;
            currentStringNumber++;
        } else {
            (*buffer)[currentStringNumber][currentStringLength] = (char)original[i];
            currentStringLength++;
        }
    }
    buffer[currentStringNumber][currentStringLength] = 0;
}

Sample code:
int main(){
    const char *string = "STRING-1 DELIM string-2 DELIM sTrInG-3";
    char **buffer;
    int numStrings;
    int * stringLengths;

    splitString(string, " DELIM ", &buffer, &numStrings, &stringLengths);

    for(int i = 0;i < numStrings;i++){
        printf("String: %s\n", buffer[i]);
    }
}

Libraries:
#include <stdlib.h>
#include <string.h>
#include <stdio.h>

A: This optimized method create (or update an existing) array of pointers in *result and returns the number of elements in *count.
Use "max" to indicate the maximum number of strings you expect (when you specify an existing array or any other reaseon), else set it to 0
To compare against a list of delimiters, define delim as a char* and replace the line:
if (str[i]==delim) {

with the two following lines:
 char *c=delim; while(*c && *c!=str[i]) c++;
 if (*c) {

Enjoy
#include <stdlib.h>
#include <string.h>

char **split(char *str, size_t len, char delim, char ***result, unsigned long *count, unsigned long max) {
  size_t i;
  char **_result;

  // there is at least one string returned
  *count=1;

  _result= *result;

  // when the result array is specified, fill it during the first pass
  if (_result) {
    _result[0]=str;
  }

  // scan the string for delimiter, up to specified length
  for (i=0; i<len; ++i) {

    // to compare against a list of delimiters,
    // define delim as a string and replace
    // the next line:
    //     if (str[i]==delim) {
    //
    // with the two following lines:
    //     char *c=delim; while(*c && *c!=str[i]) c++;
    //     if (*c) {
    //
    if (str[i]==delim) {

      // replace delimiter with zero
      str[i]=0;

      // when result array is specified, fill it during the first pass
      if (_result) {
        _result[*count]=str+i+1;
      }

      // increment count for each separator found
      ++(*count);

      // if max is specified, dont go further
      if (max && *count==max)  {
        break;
      }

    }
  }

  // when result array is specified, we are done here
  if (_result) {
    return _result;
  }

  // else allocate memory for result
  // and fill the result array

  *result=malloc((*count)*sizeof(char*));
  if (!*result) {
    return NULL;
  }
  _result=*result;

  // add first string to result
  _result[0]=str;

  // if theres more strings
  for (i=1; i<*count; ++i) {

    // find next string
    while(*str) ++str;
    ++str;

    // add next string to result
    _result[i]=str;

  }

  return _result;
}

Usage example:
#include <stdio.h>

int main(int argc, char **argv) {
  char *str="JAN,FEB,MAR,APR,MAY,JUN,JUL,AUG,SEP,OCT,NOV,DEC";
  char **result=malloc(6*sizeof(char*));
  char **result2=0;
  unsigned long count;
  unsigned long count2;
  unsigned long i;

  split(strdup(str),strlen(str),',',&result,&count,6);
  split(strdup(str),strlen(str),',',&result2,&count2,0);

  if (result)
  for (i=0; i<count; ++i) {
    printf("%s\n",result[i]);
  }

  printf("\n");

  if (result2)
  for (i=0; i<count2; ++i) {
    printf("%s\n", result2[i]);
  }

  return 0;

}

A: Below is my strtok() implementation from zString library.
zstring_strtok() differs from standard library's strtok() in the way it treats consecutive delimiters.
Just have a look at the code below,sure that you will get an idea about how it works (I tried to use as many comments as I could)
char *zstring_strtok(char *str, const char *delim) {
    static char *static_str=0;      /* var to store last address */
    int index=0, strlength=0;       /* integers for indexes */
    int found = 0;                  /* check if delim is found */

    /* delimiter cannot be NULL
    * if no more char left, return NULL as well
    */
    if (delim==0 || (str == 0 && static_str == 0))
        return 0;

    if (str == 0)
        str = static_str;

    /* get length of string */
    while(str[strlength])
        strlength++;

    /* find the first occurance of delim */
    for (index=0;index<strlength;index++)
        if (str[index]==delim[0]) {
            found=1;
            break;
        }

    /* if delim is not contained in str, return str */
    if (!found) {
        static_str = 0;
        return str;
    }

    /* check for consecutive delimiters
    *if first char is delim, return delim
    */
    if (str[0]==delim[0]) {
        static_str = (str + 1);
        return (char *)delim;
    }

    /* terminate the string
    * this assignmetn requires char[], so str has to
    * be char[] rather than *char
    */
    str[index] = '\0';

    /* save the rest of the string */
    if ((str + index + 1)!=0)
        static_str = (str + index + 1);
    else
        static_str = 0;

        return str;
}

Below is an example usage...
  Example Usage
      char str[] = "A,B,,,C";
      printf("1 %s\n",zstring_strtok(s,","));
      printf("2 %s\n",zstring_strtok(NULL,","));
      printf("3 %s\n",zstring_strtok(NULL,","));
      printf("4 %s\n",zstring_strtok(NULL,","));
      printf("5 %s\n",zstring_strtok(NULL,","));
      printf("6 %s\n",zstring_strtok(NULL,","));

  Example Output
      1 A
      2 B
      3 ,
      4 ,
      5 C
      6 (null)

The library can be downloaded from Github
https://github.com/fnoyanisi/zString

A: You can use the strtok() function to split a string (and specify the delimiter to use). Note that strtok() will modify the string passed into it. If the original string is required elsewhere make a copy of it and pass the copy to strtok().
EDIT:
Example (note it does not handle consecutive delimiters, "JAN,,,FEB,MAR" for example):
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>

char** str_split(char* a_str, const char a_delim)
{
    char** result    = 0;
    size_t count     = 0;
    char* tmp        = a_str;
    char* last_comma = 0;
    char delim[2];
    delim[0] = a_delim;
    delim[1] = 0;

    /* Count how many elements will be extracted. */
    while (*tmp)
    {
        if (a_delim == *tmp)
        {
            count++;
            last_comma = tmp;
        }
        tmp++;
    }

    /* Add space for trailing token. */
    count += last_comma < (a_str + strlen(a_str) - 1);

    /* Add space for terminating null string so caller
       knows where the list of returned strings ends. */
    count++;

    result = malloc(sizeof(char*) * count);

    if (result)
    {
        size_t idx  = 0;
        char* token = strtok(a_str, delim);

        while (token)
        {
            assert(idx < count);
            *(result + idx++) = strdup(token);
            token = strtok(0, delim);
        }
        assert(idx == count - 1);
        *(result + idx) = 0;
    }

    return result;
}

int main()
{
    char months[] = "JAN,FEB,MAR,APR,MAY,JUN,JUL,AUG,SEP,OCT,NOV,DEC";
    char** tokens;

    printf("months=[%s]\n\n", months);

    tokens = str_split(months, ',');

    if (tokens)
    {
        int i;
        for (i = 0; *(tokens + i); i++)
        {
            printf("month=[%s]\n", *(tokens + i));
            free(*(tokens + i));
        }
        printf("\n");
        free(tokens);
    }

    return 0;
}

Output:
$ ./main.exe
months=[JAN,FEB,MAR,APR,MAY,JUN,JUL,AUG,SEP,OCT,NOV,DEC]

month=[JAN]
month=[FEB]
month=[MAR]
month=[APR]
month=[MAY]
month=[JUN]
month=[JUL]
month=[AUG]
month=[SEP]
month=[OCT]
month=[NOV]
month=[DEC]

A: Method below will do all the job (memory allocation, counting the length) for you. More information and description can be found here - Implementation of Java String.split() method to split C string
int split (const char *str, char c, char ***arr)
{
    int count = 1;
    int token_len = 1;
    int i = 0;
    char *p;
    char *t;

    p = str;
    while (*p != '\0')
    {
        if (*p == c)
            count++;
        p++;
    }

    *arr = (char**) malloc(sizeof(char*) * count);
    if (*arr == NULL)
        exit(1);

    p = str;
    while (*p != '\0')
    {
        if (*p == c)
        {
            (*arr)[i] = (char*) malloc( sizeof(char) * token_len );
            if ((*arr)[i] == NULL)
                exit(1);

            token_len = 0;
            i++;
        }
        p++;
        token_len++;
    }
    (*arr)[i] = (char*) malloc( sizeof(char) * token_len );
    if ((*arr)[i] == NULL)
        exit(1);

    i = 0;
    p = str;
    t = ((*arr)[i]);
    while (*p != '\0')
    {
        if (*p != c && *p != '\0')
        {
            *t = *p;
            t++;
        }
        else
        {
            *t = '\0';
            i++;
            t = ((*arr)[i]);
        }
        p++;
    }

    return count;
}

How to use it:
int main (int argc, char ** argv)
{
    int i;
    char *s = "Hello, this is a test module for the string splitting.";
    int c = 0;
    char **arr = NULL;

    c = split(s, ' ', &arr);

    printf("found %d tokens.\n", c);

    for (i = 0; i < c; i++)
        printf("string #%d: %s\n", i, arr[i]);

    return 0;
}

A: Here is my two cents:
int split (const char *txt, char delim, char ***tokens)
{
    int *tklen, *t, count = 1;
    char **arr, *p = (char *) txt;

    while (*p != '\0') if (*p++ == delim) count += 1;
    t = tklen = calloc (count, sizeof (int));
    for (p = (char *) txt; *p != '\0'; p++) *p == delim ? *t++ : (*t)++;
    *tokens = arr = malloc (count * sizeof (char *));
    t = tklen;
    p = *arr++ = calloc (*(t++) + 1, sizeof (char *));
    while (*txt != '\0')
    {
        if (*txt == delim)
        {
            p = *arr++ = calloc (*(t++) + 1, sizeof (char *));
            txt++;
        }
        else *p++ = *txt++;
    }
    free (tklen);
    return count;
}

Usage:
char **tokens;
int count, i;
const char *str = "JAN,FEB,MAR,APR,MAY,JUN,JUL,AUG,SEP,OCT,NOV,DEC";

count = split (str, ',', &tokens);
for (i = 0; i < count; i++) printf ("%s\n", tokens[i]);

/* freeing tokens */
for (i = 0; i < count; i++) free (tokens[i]);
free (tokens);

A: Try use this.
char** strsplit(char* str, const char* delim){
    char** res = NULL;
    char*  part;
    int i = 0;

    char* aux = strdup(str);

    part = strdup(strtok(aux, delim));

    while(part){
        res = (char**)realloc(res, (i + 1) * sizeof(char*));
        *(res + i) = strdup(part);

        part = strdup(strtok(NULL, delim));
        i++;
    }

    res = (char**)realloc(res, i * sizeof(char*));
    *(res + i) = NULL;

    return res;
}

A: Explode & implode - initial string remains intact, dynamic memory allocation
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>

typedef struct
{
    uintptr_t   ptr;
    int         size;
} token_t;

int explode(char *str, int slen, const char *delimiter, token_t **tokens)
{
    int i = 0, c1 = 0, c2 = 0;

    for(i = 0; i <= slen; i++)
    {
            if(str[i] == *delimiter)
            {
                c1++;
            }
    }

    if(c1 == 0)
    {
            return -1;
    }

    *tokens = (token_t*)calloc((c1 + 1), sizeof(token_t));
    ((*tokens)[c2]).ptr = (uintptr_t)str;

    i = 0;
    while(i <= slen)
    {
        if((str[i] == *delimiter) || (i == slen))
        {
                ((*tokens)[c2]).size = (int)((uintptr_t)&(str[i]) - (uintptr_t)(((*tokens)[c2]).ptr));
                if(i < slen)
                {
                    c2++;
                    ((*tokens)[c2]).ptr = (uintptr_t)&(str[i + 1]);
                }
        }
        i++;
    }
    return (c1 + 1);
}

char* implode(token_t *tokens, int size, const char *delimiter)
{
    int     i, len = 0;
    char    *str;

    for(i = 0; i < len; i++)
    {
        len += tokens[i].size + 1;
    }

    str = (char*)calloc(len, sizeof(char));

    len = 0;
    for(i = 0; i < size; i++)
    {
        memcpy((void*)&str[len], (void*)tokens[i].ptr, tokens[i].size);
        len += tokens[i].size;
        str[(len++)] = *delimiter;
    }

    str[len - 1] = '\0';

    return str;
}

Usage:
int main(int argc, char **argv)
{
    int         i, c;
    char        *exp = "JAN,FEB,MAR,APR,MAY,JUN,JUL,AUG,SEP,OCT,NOV,DEC";
    token_t     *tokens;
    char        *imp;

    printf("%s\n", exp);

    if((c = explode(exp, strlen(exp), ",", &tokens)) > 0)
    {
        imp = implode(tokens, c, ",");
        printf("%s\n", imp);

        for(i = 0; i < c; i++)
        {
            printf("%.*s, %d\n", tokens[i].size, (char*)tokens[i].ptr, tokens[i].size);
        }
    }

    free((void*)tokens);
    free((void*)imp);
    return 0;
}

A: If you are willing to use an external library, I can't recommend bstrlib enough.  It takes a little extra setup, but is easier to use in the long run.
For example, split the string below, one first creates a bstring with the bfromcstr() call.  (A bstring is a wrapper around a char buffer).
Next, split the string on commas, saving the result in a struct bstrList, which has fields qty and an array entry, which is an array of bstrings.
bstrlib has many other functions to operate on bstrings
Easy as pie...
#include "bstrlib.h"
#include <stdio.h>
int main() {
  int i;
  char *tmp = "Hello,World,sak";
  bstring bstr = bfromcstr(tmp);
  struct bstrList *blist = bsplit(bstr, ',');
  printf("num %d\n", blist->qty);
  for(i=0;i<blist->qty;i++) {
    printf("%d: %s\n", i, bstr2cstr(blist->entry[i], '_'));
  }

}

A: Late to the party I know, but here's 2 more functions to play with and probably further adjust to your needs (source code at the bottom of the post)
See also the Implementation Notes, further below, to decide which function suits your needs better.
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
#include <stdbool.h>  // C99

// tokenize destructively
char **str_toksarray_alloc(
    char **strp,       /* InOut: pointer to the source non-constant c-string */
    const char *delim, /* c-string containing the delimiting chars */
    size_t *ntoks,     /* InOut: # of tokens to parse/parsed (NULL or *ntoks==0 for all tokens) */
    bool keepnulls     /* false ignores empty tokens, true includes them */
    );

// tokenize non-destructively
char **str_toksarray_alloc2(
   const char *str,    /* the source c-string */
   const char *delim,
   size_t *ntoks,
   bool keepnulls
   );

Usage Notes
Their prototypes are almost identical, except for the source-string (strp and str, respectively).
strp (pointer to string) is the address of an already allocated, non-constant c-string, to be tokenized in-place. str is a c-string which is not altered (it can even be a string-literal). By c-string I mean a nul-terminated buffer of chars. The rest of the arguments are the same for both functions.
To parse all available tokens, mute ntoks (meaning set it to 0 before passing it to any of the functions or pass it as a NULL pointer). Else the functions parse up to *ntoks tokens, or until there are no more tokens (whichever comes first). In any case, when ntoks is non-NULL it gets updated with the count of successfully parsed tokens.
Note also that a non-muted ntoks determines how many pointers will be allocated. Thus if the source string contains say 10 tokens and we set ntoks to 1000, we'll end up with 990 needlessly allocated pointers. On the other hand, if the source-string contains say 1000 tokens but we only need the first 10, setting ntoks to 10 sounds like a much wiser choice.
Both functions allocate and return an array of char-pointers, but str_toksarray_alloc() makes them point to the tokens in the modified source-string itself, while str_toksarray_alloc2() makes them point to dynamically allocated copies of the tokens (that 2 at the end of its name indicates the 2-levels of allocation).
The returned array is appended with a NULL sentinel pointer, which is not taken into account in the passed-back value of ntoks (put otherwise, when non-NULL, ntoks passes-back to the caller the length of the returned array, not its 1st level size).
When keepnulls is set to true, the resulting tokens are similar to what we'd expect from the strsep() function. Mostly meaning that consecutive delimiters in the source-string produce empty tokens (nulls), and if delim is an empty c-string or none of its contained delimiter-chars were found in the source string, the result is just 1 token: the source string. Contrary to strsep(), empty tokens can be ignored by setting keepnulls to false.
Failed calls of the functions can be identified by checking their return value against NULL, or by checking the passed-back value of ntoks against 0 (provided ntoks was non-NULL). I suggest always checking against failure before attempting to access the returned array, because the functions include sanity checks which can postpone otherwise immediate crashes (for example, passing a NULL pointer as the source string).
On success, the caller should free the array when they're done with it.
For str_toksarray_alloc(), a simple free() is enough. For str_toksarray_alloc2() a loop is involved, due to the 2nd level of allocation. The NULL sentinel (or the passed-back value of a non-NULL ntoks) makes this trivial, but I'm also providing a toksarray_free2() function below, for all the lazy bees out there :)
Simplified examples using both functions follow.
Prep:
const char *src = ";b,test,Tèst,;;cd;ελληνικά,nørmälize,;string to";
const char *delim = ";,";
bool keepnulls = true;
size_t ntoks = 0;

str_toksarray_alloc():
// destructive (use copy of src)

char *scopy = strdup( src );
if (!scopy) { ... };          // handle strdup failure

printf( "%s\n", src );
char **arrtoks = str_toksarray_alloc( &scopy, delim, &ntoks, keepnulls );
printf( "%lu tokens read\n", ntoks );
if ( arrtoks ) {
    for (int i=0; arrtoks[i]; i++) {
        printf( "%d: %s\n", i, arrtoks[i] );
    }
}
free( scopy );
free( arrtoks );

/* OUTPUT
;b,test,Tèst,;;cd;ελληνικά,nørmälize,;string to
11 tokens read
0:
1: b
2: test
3: Tèst
4:
5:
6: cd
7: ελληνικά
8: nørmälize
9:
10: string to
 */

str_toksarray_alloc2():
// non-destructive

keepnulls = false;    // reject empty tokens

printf( "%s\n", src );
arrtoks = str_toksarray_alloc2( src, delim, &ntoks, keepnulls );
printf( "%lu tokens read\n", ntoks );
if ( arrtoks ) {
    for (int i=0; arrtoks[i]; i++) {
        printf( "%d: %s\n", i, arrtoks[i] );
    }
}
toksarray_free2( arrtoks );                     // dangling arrtoks
// or: arrtoks = toksarray_free2( arrtoks );    // non-dangling artoks

/* OUTPUT
;b,test,Tèst,;;cd;ελληνικά,nørmälize,;string to
7 tokens read
0: b
1: test
2: Tèst
3: cd
4: ελληνικά
5: nørmälize
6: string to
*/

Implementation Notes
Both functions use strsep() for the tokenization which makes them thread-safe, but it's not a standard function. If not provided, you can always use an open-source implementation (like GNU's or Apple's for example). Same goes for the function strdup() which is used in str_toksarray_alloc2() (its implementation is trivial but again here's GNU's and Apple's for example).
A side-effect of using strsep() in str_toksarray_alloc() is that the starting pointer of the source-string keeps moving to the next token in every step of the parsing loop. This means that the caller won't be able to free the parsed string, unless they had saved the starting address to an extra pointer. We save them the hassle, by doing that locally in the function, using the strpSaved pointer. str_toksarray_alloc2() is not affected by this, because it doesn't touch the source-string.
A main difference between the 2 functions is that str_toksarray_alloc() does not allocate memory for the found tokens. It rather allocates space just for the array pointers and sets them pointing directly into the source-string. This works because strsep() nul-terminates the found tokens in-place. This dependency can complicate your supporting code, but with big strings it can also make a big difference in performance. If preserving the source-string is not important, it can make a big difference in memory footprint too.
On the other hand, str_toksarray_alloc2() allocates and returns a self sustained array of dynamically allocated copies of the tokens, without further dependencies. It does so firstly by creating the array from a local duplicate of the source-string, and secondly by duplicating the actual tokens contents into the array. This is a lot slower and leaves a much bigger memory footprint compared to str_toksarray_alloc(), but it has no further dependencies, and sets no special requirements for the nature of the source-string. This makes it easier to write simpler (hence better maintainable) supporting code.
Another difference between the 2 functions is the 1st level of allocation (the array pointers) when ntoks is muted. They both parse all available tokens, but they take quite different approaches. str_toksarray_alloc() uses alloc-ahead with an initial size of 16 (char-pointers), doubling it on demand in the parsing loop. str_toksarray_alloc2() makes a 1st pass counting all available tokens, then it allocates that many char-pointers just once. That 1st pass is done with a helper function str_toksfound() which uses the standard functions strpbrk() and strchr(). I'm providing the source-code of that function too, further below.
Which approach is better is really up to you to decide, depending on the needs of your project. Feel free to adjust the code of each function to either approach and take it from there.
I'd say that on average and for really big strings alloc-ahead is much faster, especially when the initial size and grow factor are fine tuned on a per-case basis (making them function parameters for example). Saving that extra pass with all those strchr()'s and strpbrk()'s can make a difference there. However, with relatively small strings which is pretty much the norm, allocing-ahead just a bunch of char-pointers is just an overkill. It doesn't hurt but it does clutter the code for no good reason in this case. Anyway, feel free to choose whichever suits you best.
Same goes for these 2 functions. I'd say in most cases str_toksarray_alloc2() is much simpler to cope with, since memory and performance are rarely an issue with small to medium strings. If you have to deal with huge strings, then consider using str_toksarray_alloc() (though in those cases you should roll a specialized string parsing function, close to the needs of your project and the specs of your input).
Oh boy, I think that was a bit more than just 2 cents (lol).
Anyway, here is the code of the 2 functions and the helper ones (I've removed most of their description comments, since I've covered pretty much everything already).
Source Code
str_toksarray_alloc():
// ----------------------------------------
// Tokenize destructively a nul-terminated source-string.
// Return a dynamically allocated, NULL terminated array of char-pointers
// each pointing to each token found in the source-string, or NULL on error.
//
char **str_toksarray_alloc(char **strp, const char *delim, size_t *ntoks, bool keepnulls)
{
    // sanity checks
    if ( !strp || !*strp || !**strp || !delim ) {
        goto failed;
    }

    char *strpSaved = *strp;                    // save initial *strp pointer
    bool ntoksOk = (ntoks && *ntoks);           // false when ntoks is muted
    size_t _ntoks = (ntoksOk ? *ntoks : 16);    // # of tokens to alloc-ahead

    // alloc array of char-pointers (+1 for NULL sentinel)
    char **toksarr = malloc( (_ntoks+1) * sizeof(*toksarr) );
    if ( !toksarr ) {
        goto failed;
    }

    // Parse *strp tokens into the array
    size_t i = 0;           // # of actually parsed tokens
    char *tok;
    while ( (tok = strsep(strp, delim)) ) {
        // if requested, ignore empty tokens
        if ( *tok == '\0' && !keepnulls ) {
            continue;
        }
        // non-muted ntoks reached? we are done
        if ( ntoksOk && i == _ntoks ) {
            *ntoks = i;
            break;
        }
        // muted ntoks & ran out of space? double toksarr and keep parsing
        if ( !ntoksOk && i == _ntoks ) {
            _ntoks *= 2;
            char **tmparr = realloc( toksarr, (_ntoks+1) * sizeof(*tmparr) );
            if ( !tmparr ) {
                *strp = strpSaved;
                free( toksarr );
                goto failed;
            }
            toksarr = tmparr;
        }
        toksarr[i++] = tok; // get token address
    }
    toksarr[i] = NULL;      // NULL sentinel

    *strp = strpSaved;      // restore initial *strp pointer
    if (ntoks) *ntoks = i;  // pass to caller # of parsed tokens
    return toksarr;

failed:
    if (ntoks) *ntoks = 0;
    return NULL;
}

str_toksarray_alloc2():
// ----------------------------------------
// Tokenize non-destructively a nul-terminated source-string.
// Return a dynamically allocated, NULL terminated array of dynamically
// allocated and nul-terminated string copies of each token found in the
// source-string. Return NULL on error.
// The 2 at the end of the name means 2-levels of allocation.
//
char **str_toksarray_alloc2( const char *str, const char *delim, size_t *ntoks, bool keepnulls )
{
    // sanity checks
    if ( !str || !*str || !delim ) {
        if (ntoks) *ntoks = 0;
        return NULL;
    }

    // make a copy of str to work with
    char *_str = strdup( str );
    if ( !_str ) {
        if (ntoks) *ntoks = 0;
        return NULL;
    }

    // if ntoks is muted we'll allocate str_tokscount() tokens, else *ntoks
    size_t _ntoks = (ntoks && *ntoks) ? *ntoks : str_tokscount(_str, delim, keepnulls);
    if ( _ntoks == 0 ) {        // str_tokscount() failed
        goto fail_free_str;
    }

    // alloc the array of strings (+1 for an extra NULL sentinel)
    char **toksarr = malloc( (_ntoks+1) * sizeof(*toksarr) );
    if ( !toksarr ) {
        goto fail_free_str;
    }

    // Parse str tokens and duplicate them into the array
    size_t i = 0;           // # of actually parsed tokens
    char *tok;
    while ( i < _ntoks && (tok = strsep(&_str, delim)) ) {
        // if requested, skip empty tokens
        if ( *tok == '\0' && !keepnulls ) {
            continue;
        }
        // duplicate current token into the array
        char *tmptok = strdup( tok );
        if ( !tmptok ) {
            goto fail_free_arr;
        }
        toksarr[i++] = tmptok;
    }
    toksarr[i] = NULL;      // NULL sentinel

    free( _str );           // release the local copy of the source-string
    if (ntoks) *ntoks = i;  // pass to caller the # of parsed tokens
    return toksarr;

// cleanup before failing
fail_free_arr:
    for (size_t idx=0; idx < i; idx++) {
        free( toksarr[idx] );
    }
    free( toksarr );

fail_free_str:
    free( _str );
    if (ntoks) *ntoks = 0;
    return NULL;
}

str_tokscount() - helper function, used by str_toksarr_alloc2():
// ----------------------------------------
// Return the count of tokens present in a nul-terminated source-string (str),
// based on the delimiting chars contained in a 2nd nul-terminated string (delim).
// If the boolean argument is false, empty tokens are excluded.
//
// To stay consistent with the behavior of strsep(), the function returns 1 if
// delim is an empty string or none of its delimiters is found in str (in those
// cases the source-string is considered a single token).
// 0 is returned when str or delim are passed as NULL pointers, or when str is
// passed as an empty string.
//
size_t str_tokscount( const char *str, const char *delim, bool keepnulls )
{
    // sanity checks
    if ( !str || !*str || !delim ) {
        return 0;
    }

    const char *tok = str;
    size_t nnulls = strchr(delim, *str) ? 1 : 0;
    size_t ntoks = 1;   // even when no delims in str, str counts as 1 token
    for (; (str = strpbrk(tok, delim)); ntoks++ ) {
        tok = ++str;
        if ( strchr(delim, *str) ) {
            nnulls++;
        }
    }

    return keepnulls ? ntoks : (ntoks - nnulls);
}

toksarray_free2() - use it on the array returned by str_toksarr_alloc2():
// ----------------------------------------
// Free a dynamically allocated, NULL terminated, array of char-pointers
// with each such pointer pointing to its own dynamically allocated data.
// Return NULL, so the caller has the choice of assigning it back to the
// dangling pointer. The 2 at the end of the name means 2-levels of deallocation.
//
// NULL terminated array means ending with a NULL sentinel.
//      e.g.: toksarr[0] = tok1, ..., toksarr[len] = NULL
//
char **toksarray_free2( char **toksarr )
{
    if ( toksarr ) {
        char **toks = toksarr;
        while ( *toks ) {   // walk until NULL sentinel
            free( *toks++ );
        }
        free( toksarr );
    }

    return NULL;
}

A: Both strtok() and strsep() modify the input string. We can write a function to split the string based on delimiters using strspn() and strpbrk().
Algorithm:

*

*If the input string is not empty, go to step 2 else return null.

*Skip separator, if any at the start of string, and record start position of word (using strspn() for this), call it start.

*Find next separator position (or end of string if no more separator exists) from the current start found in previous step (using strpbrk() for this), call it end.

*Allocate memory and copy string from start to end in that memory.

*Return token.

Advantage:

*

*Thread safe.

*Handles multiple delimiters.

*Portable.

*Doesn't modify the input string, like strtok() and strsep() does.

Implementation:
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

/*
 * alloc_str function allocates memory and copy substring
 * to allocated memory.
 */

static char * alloc_str (const char * start, const char * end) {
    if (!start || !end || (start >= end)) {
        return NULL;
    }

    char * tmp = malloc (end - start + 1);
    if (tmp) {
        memcpy (tmp, start, end - start);
        tmp[end - start] = '\0';
    } else {
        fprintf (stderr, "Failed to allocate memory\n");
        exit (EXIT_FAILURE);
    }

    return tmp;
}

/*
 * str_split function returns the next token which is sequences of contiguous
 * characters separated by any of the characters that are part of delimiters.
 *
 * Parameters:
 * p_str : Address of pointer to the string that you want to split.
 * sep : A set of characters that delimit the pieces in the string.
 *
 * Behaviour is undefined if sep is not a pointer to a null-terminated string.
 *
 * Return :
 * Returns the pointer to dynamically allocated memory where the token is copied.
 * If p_str is NULL or empty string, NULL is returned.
 */

char * str_split (char ** p_str, const char * sep) {
    char * token = NULL;

    if (*p_str && **p_str) {
        char * p_end;

        // skip separator
        *p_str += strspn(*p_str, sep);

        p_end = *p_str;

        // find separator
        p_end = strpbrk (p_end, sep);

        // strpbrk() returns null pointer if no such character
        // exists in the input string which is part of sep argument.
        if (!p_end) {
            p_end = *p_str + strlen (*p_str);
        }

        token = alloc_str (*p_str, p_end);
        *p_str = p_end;
    }

    return token;
}

/*==================================================*/
/*==================================================*/

/*
 * Just a helper function
 */

void token_helper (char * in_str, const char * delim) {
    printf ("\nInput string : ");

    if (in_str) printf ("\"%s\"\n", in_str);
    else printf ("NULL\n");

    if (delim) printf ("Delimiter : \"%s\"\n", delim);

    char * ptr = in_str;
    char * token = NULL;

    printf ("Tokens:\n");
    while ((token = str_split(&ptr, delim)) != NULL) {
        printf ("-> %s\n", token);
        /* You can assign this token to a pointer of an array of pointers
         * and return that array of pointers from this function.
         * Since, this is for demonstration purpose, I am
         * freeing the allocated memory now.
         */
        free (token);
    }
}

/*
 * Driver function
 */

int main (void) {
    /* test cases */

    char string[100] = "hello world!";
    const char * delim = " ";
    token_helper (string, delim);

    strcpy (string, " hello world,friend of mine!");
    delim = " ,";
    token_helper (string, delim);

    strcpy (string, "Another string");
    delim = "-!";
    token_helper (string, delim);

    strcpy (string, "   one  more   -- string  !");
    delim = "- !";
    token_helper (string, delim);

    strcpy (string, "");
    delim = " ";
    token_helper (string, delim);

    token_helper (NULL, "");

    strcpy (string, "hi");
    delim = " -$";
    token_helper (string, delim);

    strcpy (string, "Give papa a cup of proper coffee in a copper coffee cup.");
    delim = "cp";
    token_helper (string, delim);

    strcpy (string, "JAN,FEB,MAR,APR,MAY,JUN,JUL,AUG,SEP,OCT,NOV,DEC");
    delim = ",";
    token_helper (string, delim);

    return 0;
}

Output:
# ./a.out

Input string : "hello world!"
Delimiter : " "
Tokens:
-> hello
-> world!

Input string : " hello world,friend of mine!"
Delimiter : " ,"
Tokens:
-> hello
-> world
-> friend
-> of
-> mine!

Input string : "Another string"
Delimiter : "-!"
Tokens:
-> Another string

Input string : "   one  more   -- string  !"
Delimiter : "- !"
Tokens:
-> one
-> more
-> string

Input string : ""
Delimiter : " "
Tokens:

Input string : NULL
Delimiter : ""
Tokens:

Input string : "hi"
Delimiter : " -$"
Tokens:
-> hi

Input string : "Give papa a cup of proper coffee in a copper coffee cup."
Delimiter : "cp"
Tokens:
-> Give
-> a
-> a a
-> u
->  of
-> ro
-> er
-> offee in a
-> o
-> er
-> offee
-> u
-> .

Input string : "JAN,FEB,MAR,APR,MAY,JUN,JUL,AUG,SEP,OCT,NOV,DEC"
Delimiter : ","
Tokens:
-> JAN
-> FEB
-> MAR
-> APR
-> MAY
-> JUN
-> JUL
-> AUG
-> SEP
-> OCT
-> NOV
-> DEC

A: My approach is to scan the string and let the pointers point to every character after the deliminators(and the first character), at the same time assign the appearances of deliminator in string to '\0'.
First make a copy of original string(since it's constant), then get the number of splits by scan it pass it to pointer parameter len. After that, point the first result pointer to the copy string pointer, then scan the copy string: once encounter a deliminator, assign it to '\0' thus the previous result string is terminated, and point the next result string pointer to the next character pointer.
char** split(char* a_str, const char a_delim, int* len){
    char* s = (char*)malloc(sizeof(char) * strlen(a_str));
    strcpy(s, a_str);
    char* tmp = a_str;
    int count = 0;
    while (*tmp != '\0'){
        if (*tmp == a_delim) count += 1;
        tmp += 1;
    }
    *len = count;
    char** results = (char**)malloc(count * sizeof(char*));
    results[0] = s;
    int i = 1;
    while (*s!='\0'){
        if (*s == a_delim){
            *s = '\0';
            s += 1;
            results[i++] = s;
        }
        else s += 1;
    }
    return results;
}

A: My code (tested):
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int dtmsplit(char *str, const char *delim, char ***array, int *length ) {
  int i=0;
  char *token;
  char **res = (char **) malloc(0 * sizeof(char *));

  /* get the first token */
   token = strtok(str, delim);
   while( token != NULL )
   {
        res = (char **) realloc(res, (i + 1) * sizeof(char *));
        res[i] = token;
        i++;
      token = strtok(NULL, delim);
   }
   *array = res;
   *length = i;
  return 1;
}

int main()
{
    int i;
    int c = 0;
    char **arr = NULL;

    int count =0;

    char str[80] = "JAN,FEB,MAR,APR,MAY,JUN,JUL,AUG,SEP,OCT,NOV,DEC";
    c = dtmsplit(str, ",", &arr, &count);
    printf("Found %d tokens.\n", count);

    for (i = 0; i < count; i++)
        printf("string #%d: %s\n", i, arr[i]);

   return(0);
}

Result:
Found 12 tokens.
string #0: JAN
string #1: FEB
string #2: MAR
string #3: APR
string #4: MAY
string #5: JUN
string #6: JUL
string #7: AUG
string #8: SEP
string #9: OCT
string #10: NOV
string #11: DEC

A: Two issues surrounding this question are memory management and thread safety.  As you can see from the numerous posts,
this isn't an easy task to accomplish seamlessly in C.  I desired a solution that is:

*

*Thread safe.  (strtok is not thread safe)

*Does not employ malloc or any of it's derivatives (to avoid memory management issues)

*Checks array bounds on the individual fields (to avoid segment faults on unknown data)

*Works with multi-byte field separators (utf-8)

*ignores extra fields in the input

*provides soft error routine for invalid field lengths

The solution I came up meets all of these criteria.  It's probably a little more work to setup
than some other solutions posted here, but I think that in practice, the extra work is worth
it in order to avoid the common pitfalls of other solutions.
#include <stdio.h>
#include <string.h>

struct splitFieldType {
    char *field;
    int   maxLength;
};

typedef struct splitFieldType splitField;

int strsplit(splitField *fields, int expected, const char *input, const char *fieldSeparator, void (*softError)(int fieldNumber,int expected,int actual))  {
    int i;
    int fieldSeparatorLen=strlen(fieldSeparator);
    const char *tNext, *tLast=input;

    for (i=0; i<expected && (tNext=strstr(tLast, fieldSeparator))!=NULL; ++i) {
        int len=tNext-tLast;
        if (len>=fields[i].maxLength) {
            softError(i,fields[i].maxLength-1,len);
            len=fields[i].maxLength-1;
        }
        fields[i].field[len]=0;
        strncpy(fields[i].field,tLast,len);
        tLast=tNext+fieldSeparatorLen;
    }
    if (i<expected) {
        if (strlen(tLast)>fields[i].maxLength) {
            softError(i,fields[i].maxLength,strlen(tLast));
        } else {
            strcpy(fields[i].field,tLast);
        }
        return i+1;
    } else {
        return i;
    }
}

void monthSplitSoftError(int fieldNumber, int expected, int actual) {
    fprintf(stderr,"monthSplit: input field #%d is %d bytes, expected %d bytes\n",fieldNumber+1,actual,expected);
}

int main() {
  const char *fieldSeparator=",";
  const char *input="JAN,FEB,MAR,APRI,MAY,JUN,JUL,AUG,SEP,OCT,NOV,DEC,FOO,BAR";

  struct monthFieldsType {
    char field1[4];
    char field2[4];
    char field3[4];
    char field4[4];
    char field5[4];
    char field6[4];
    char field7[4];
    char field8[4];
    char field9[4];
    char field10[4];
    char field11[4];
    char field12[4];
  } monthFields;

  splitField inputFields[12] = {
    {monthFields.field1,  sizeof(monthFields.field1)},
    {monthFields.field2,  sizeof(monthFields.field2)},
    {monthFields.field3,  sizeof(monthFields.field3)},
    {monthFields.field4,  sizeof(monthFields.field4)},
    {monthFields.field5,  sizeof(monthFields.field5)},
    {monthFields.field6,  sizeof(monthFields.field6)},
    {monthFields.field7,  sizeof(monthFields.field7)},
    {monthFields.field8,  sizeof(monthFields.field8)},
    {monthFields.field9,  sizeof(monthFields.field9)},
    {monthFields.field10, sizeof(monthFields.field10)},
    {monthFields.field11, sizeof(monthFields.field11)},
    {monthFields.field12, sizeof(monthFields.field12)}
  };

  int expected=sizeof(inputFields)/sizeof(splitField);

  printf("input data: %s\n", input);
  printf("expecting %d fields\n",expected);

  int ct=strsplit(inputFields, expected, input, fieldSeparator, monthSplitSoftError);

  if (ct!=expected) {
    printf("string split %d fields, expected %d\n", ct,expected);
  }

  for (int i=0;i<expected;++i) {
    printf("field %d: %s\n",i+1,inputFields[i].field);
  }

  printf("\n");
  printf("Direct structure access, field 10: %s", monthFields.field10);
}

Below is an example compile and output.  Note that in my example, I purposefully spelled out "APRIL" so that you can see how the soft error works.
$ gcc strsplitExample.c && ./a.out
input data: JAN,FEB,MAR,APRIL,MAY,JUN,JUL,AUG,SEP,OCT,NOV,DEC,FOO,BAR
expecting 12 fields
monthSplit: input field #4 is 5 bytes, expected 3 bytes
field 1: JAN
field 2: FEB
field 3: MAR
field 4: APR
field 5: MAY
field 6: JUN
field 7: JUL
field 8: AUG
field 9: SEP
field 10: OCT
field 11: NOV
field 12: DEC

Direct structure access, field 10: OCT

Enjoy!

A: Here is another implementation that will operate safely to tokenize a string-literal matching the prototype requested in the question returning an allocated pointer-to-pointer to char (e.g. char **). The delimiter string can contain multiple characters, and the input string can contain any number of tokens. All allocations and reallocations are handled by malloc or realloc without POSIX strdup.
The initial number of pointers allocated is controlled by the NPTRS constant and the only limitation is that it be greater than zero. The char ** returned contains a sentinel NULL after the last token similar to *argv[] and in the form usable by execv, execvp and execve.
As with strtok() multiple sequential delimiters are treated as a single delimiter, so "JAN,FEB,MAR,APR,MAY,,,JUN,JUL,AUG,SEP,OCT,NOV,DEC" will be parsed as if only a single ',' separates "MAY,JUN".
The function below is commented in-line and a short main() was added splitting the months. The initial number of pointers allocated was set at 2 to force three reallocation during tokenizing the input string:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define NPTRS 2     /* initial number of pointers to allocate (must be > 0) */

/* split src into tokens with sentinel NULL after last token.
 * return allocated pointer-to-pointer with sentinel NULL on success,
 * or NULL on failure to allocate initial block of pointers. The number
 * of allocated pointers are doubled each time reallocation required.
 */
char **strsplit (const char *src, const char *delim)
{
    int i = 0, in = 0, nptrs = NPTRS;       /* index, in/out flag, ptr count */
    char **dest = NULL;                     /* ptr-to-ptr to allocate/fill */
    const char *p = src, *ep = p;           /* pointer and end-pointer */

    /* allocate/validate nptrs pointers for dest */
    if (!(dest = malloc (nptrs * sizeof *dest))) {
        perror ("malloc-dest");
        return NULL;
    }
    *dest = NULL;   /* set first pointer as sentinel NULL */

    for (;;) {  /* loop continually until end of src reached */
        if (!*ep || strchr (delim, *ep)) {  /* if at nul-char or delimiter char */
            size_t len = ep - p;            /* get length of token */
            if (in && len) {                /* in-word and chars in token */
                if (i == nptrs - 1) {       /* used pointer == allocated - 1? */
                    /* realloc dest to temporary pointer/validate */
                    void *tmp = realloc (dest, 2 * nptrs * sizeof *dest);
                    if (!tmp) {
                        perror ("realloc-dest");
                        break;  /* don't exit, original dest still valid */
                    }
                    dest = tmp;             /* assign reallocated block to dest */
                    nptrs *= 2;             /* increment allocated pointer count */
                }
                /* allocate/validate storage for token */
                if (!(dest[i] = malloc (len + 1))) {
                    perror ("malloc-dest[i]");
                    break;
                }
                memcpy (dest[i], p, len);   /* copy len chars to storage */
                dest[i++][len] = 0;         /* nul-terminate, advance index */
                dest[i] = NULL;             /* set next pointer NULL */
            }
            if (!*ep)                       /* if at end, break */
                break;
            in = 0;                         /* set in-word flag 0 (false) */
        }
        else {  /* normal word char */
            if (!in)                        /* if not in-word */
                p = ep;                     /* update start to end-pointer */
            in = 1;                         /* set in-word flag 1 (true) */
        }
        ep++;   /* advance to next character */
    }

    return dest;
}

int main (void) {

    char *str = "JAN,FEB,MAR,APR,MAY,,,JUN,JUL,AUG,SEP,OCT,NOV,DEC",
        **tokens;                           /* pointer to pointer to char */

    if ((tokens = strsplit (str, ","))) {   /* split string into tokens */
        for (char **p = tokens; *p; p++) {  /* loop over filled pointers */
            puts (*p);
            free (*p);      /* don't forget to free allocated strings */
        }
        free (tokens);      /* and pointers */
    }
}

Example Use/Output
$ ./bin/splitinput
JAN
FEB
MAR
APR
MAY
JUN
JUL
AUG
SEP
OCT
NOV
DEC

Let me know if you have any further questions.

A: #include <cstring>
#include <cstdio>
int main()
{
    char buf[] = "This is Luke Skywalker    here!";
    for( char* tok = strtok( buf, " ");
         tok != nullptr;
         tok = strtok( nullptr, " ")) {
        puts( tok);
    }
}

Outputs
This
is
Luke
Skywalker
here!

A: I tried to make a very simple one. I am also showing example in the main().
#include <stdio.h>
#include <string.h>

void split(char* inputArr, char** outputArr, char* delim) {

        char *temp;
        temp = strtok(inputArr, delim);

        for(int i = 0; temp != NULL; i++) {
            outputArr[i] = temp;
            temp = strtok(NULL, delim);
        }
}

int main(int argc, char **argv){

    /* check for proper arguments */

    if(argc != 2){
        printf("One Argument Expected\n");
    } else {

        printf("\n");
        /*---------main code starts here----------*/
        FILE * myScriptFile;
        myScriptFile = fopen(argv[1], "r");

        /* read txt file and split into array like java split() */

        int bufferLen = 100;
        char buffer[bufferLen];

        char *splitArr[100];

        while(fgets(buffer, bufferLen, myScriptFile) != NULL){

            split(buffer, splitArr, " ");

            printf("Index 0 String: %s\n", splitArr[0]);
            printf("Index 1 String: %s\n", splitArr[1]);
            printf("Index 2 String: %s\n", splitArr[2]);
            printf("Index 3 String: %s\n", splitArr[3]);
        }
        fclose(myScriptFile);
    }
    printf("\nProgram-Script Ended\n");
    return 0;
}

Assume a .txt file has
Hello this is test
Hello2 this is test2

running it with a .txt file as a parameter would give
Index 0 String: Hello
Index 1 String: this
Index 2 String: is
Index 3 String: test

Index 0 String: Hello2
Index 1 String: this
Index 2 String: is
Index 3 String: test2

A: Came across this looking for a simple solution.
I am fascinated by all of the options but dissatisfied for my own use case/taste (which may be terrible).
I have created a somewhat unique solution that aims to clearly behave for its user, not re-allocate any memory, and be human readable + with comments.
Uploaded to gist.github here: https://gist.github.com/RepComm/1e89f7611733ce0e75c8476d5ef66093
Example:
#include "./strutils.c"

struct str_split_info info;
info.source = " SPLIT ME hello SPLIT ME world SPLIT ME whats SPLIT ME going SPLIT ME on SPLIT ME today";
info.delimiter = " SPLIT ME ";

str_split_begin(&info);

char * substr;

for (int i=0; i<info.splitStringsCount; i++) {
  substr = info.splitStrings[i];
  printf("substring: '%s'\n", substr);
}

str_split_end(&info);

Output:
$ ./test
substring: ''
substring: 'hello'
substring: 'world'
substring: 'whats'
substring: 'going'
substring: 'on'
substring: 'today'

Full source of strutils.c
#ifndef STRUTILS_C
#define STRUTILS_C 1

#ifndef str
#define str char *
#endif

#include <stdlib.h>
#include <stdbool.h>
#include <string.h>

#include <stdio.h>

struct str_split_info {
  /* The string to be split
  * Provided by caller of str_split_begin function
  */
  str source;
  /* The string that cuts the source string, all occurances of
  * this string will be removed from the source string

  * Provided by caller of str_split_begin function
  */
  str delimiter;

  /* Array of strings split by delimiter
  * Provided and allocated by str_split_begin function
  * Must be garbage collected by str_split_end function
  */
  str * splitStrings;

  /* Array of string lengths split by delimiter
    * Provided and allocated by str_split_begin function
    * Must be garbage collected by str_split_end function
    */
  int * splitStringsLengths;

  /* Number of strings split by delimiter contained in splitStrings
  * Provided by str_split_begin function
  */
  int splitStringsCount;
};
#define str_split_infop struct str_split_info *

/* Split a string by a delimiting string
*
* The caller is responsible only for calling str_split_end
* when finished with the results in 'info'
*/
void str_split_begin (str_split_infop info) {
  info->splitStringsCount = 0;

  int sourceLength = strlen(info->source);
  int sourceOffset = 0;
  char sourceChar;

  int delimiterLength = strlen(info->delimiter);
  int delimiterOffset = 0;
  char delimiterChar;

  //first pass, simply count occurances so we can allocate only once
  for (sourceOffset = 0; sourceOffset<sourceLength; sourceOffset++) {
    sourceChar = info->source[sourceOffset];
    delimiterChar = info->delimiter[delimiterOffset];

    if (sourceChar == delimiterChar) {
      delimiterOffset++;

      if (delimiterOffset >= delimiterLength) {
        delimiterOffset = 0;
        //increment count
        info->splitStringsCount ++;
      }
    } else {
      delimiterOffset = 0;
    }
  }
  info->splitStringsCount++;

  //allocate arrays since we know the count
  //this one is an array of strings, which are each char arrays
  info->splitStrings = (str *) malloc(sizeof (str *) * info->splitStringsCount);
  //this one is an array of ints
  info->splitStringsLengths = (int*) malloc(sizeof(int) *info->splitStringsCount);

  int stringBegin = 0;
  int stringEnd = 0;
  int splitIndex = 0;
  int splitLength = 0;

  //second pass, fill the arrays
  for (sourceOffset = 0; sourceOffset<sourceLength; sourceOffset++) {
    sourceChar = info->source[sourceOffset];
    delimiterChar = info->delimiter[delimiterOffset];

    if (sourceChar == delimiterChar) {
      delimiterOffset++;

      //if we've reached the end of the delimiter
      if (delimiterOffset >= delimiterLength) {

        //don't worry about delimiter trailing null, strlen doesn't count those
        stringEnd = sourceOffset - delimiterLength;

        //char count of substring we want to split
        splitLength = stringEnd - stringBegin + 1;

        //allocate for our substring split
        info->splitStrings[splitIndex] = (str) malloc(
          //+1 for trailing null for c-string
          sizeof(char) * splitLength + 1
        );

        //copy substring from source into splitStrings array
        memcpy(
          info->splitStrings[splitIndex],
          info->source + stringBegin,
          splitLength
        );
        //explicitly set the last char of this split to a NULL just for fun
        info->splitStrings[splitIndex][splitLength] = 0x00;

        //conveniently put the substring split size for the
        //user of str_split_begin :)
        info->splitStringsLengths[splitIndex] = splitLength;

        //move to next split index
        splitIndex ++;

        //reset delimiter offset so we look for new occurances of it
        delimiterOffset = 0;

        //next substring split should occur after the current delimiter
        stringBegin = sourceOffset+1;
      }
    } else {
      //reset delimiter offset so we look for new occurances of it
      delimiterOffset = 0;
    }
  }

  //handle edge case of last substring after last delimiter
  if (stringEnd != stringBegin) {
    stringEnd = sourceLength-1;

    splitLength = stringEnd - stringBegin + 1;

    //allocate for our substring split
    info->splitStrings[splitIndex] = (str) malloc(
      //+1 for trailing null for c-string
      sizeof(char) * splitLength + 1
    );

    //copy substring from source into splitStrings array
    memcpy(
      info->splitStrings[splitIndex],
      info->source + stringBegin,
      splitLength
    );

  }
}
int str_split_count (str_split_infop info) {
  return info->splitStringsCount;
}

void str_split_get (str_split_infop info, str * out) {
  for (int i=0; i < info->splitStringsCount; i++) {
    strcpy(out[i], info->splitStrings[i]);
  }
}

void str_split_end (str_split_infop info) {
  if (info->splitStringsCount > 0 && info->splitStrings != NULL) {
    //free each string allocated
    for (int i=0; i < info->splitStringsCount; i++) {
      free(info->splitStrings[i]);
    }
    //free string array pointer
    free (info->splitStrings);

    //free string lengths array pointer
    free(info->splitStringsLengths);

    info->splitStringsCount = 0;
  }
}

void str_split_test () {
  char * source = "hello world this is a test";
  str delimiter = " ";

  struct str_split_info info;

  info.source = source;
  info.delimiter = delimiter;

  str_split_begin (&info);

  //iterate thru split substrings
  //NOTE: removed/memory cleanup after str_split_end
  for (int i=0; i<info.splitStringsCount; i++) {
    // info.splitStrings[i];
  }

  str_split_end(&info);
}

#endif


text:
Q: Can I embed a message-properties-transformer in an outbound-endpoint? In an effort to clean up my mule message flow (visually), I'm trying to embed as many of the small transformations and such in my outbound endpoints, among other things.  Is it possible to embed a message-properties-transformer in an outbound endpoint?  According to this document, I thought it would be possible:  http://www.mulesoft.org/documentation/display/current/Endpoint+Configuration+Reference.
However, my flow seems to ignore the transformer when I nest it inside my endpoint like so:
    <https:outbound-endpoint exchange-pattern="request-response"
        host="...." port="...."
        path="...." method="GET"
        connector-ref="...." mimeType="application/json"
        contentType="application/json" doc:name="HTTP">
          <message-properties-transformer
            doc:name="Authorization">
            <add-message-property key="Authorization"
                value="....." />
          </message-properties-transformer>
          <response>
            <byte-array-to-string-transformer
                doc:name="Byte Array to String" />
          </response>
    </https:outbound-endpoint>

The transformer inside the  element works fine, but the message-properties-transformer does not.

A: It should work fine. Both as transformer embedded inside the endpoint or as transformer-refs. I'm not sure why is being ignored. Which version of Mule are you using?
Perhaps if you use the set-property transformer rather than the deprecated message-property-transformer?


text:
Q: É uma boa ideia mapear URLs que deletam entradas em GET? Estou estudando Django e me perguntei se é realmente uma boa prática configurar URL's de remoções via GET, por exemplo: http://meusite.com.br/usuario/deletar?id=10.
Essa é realmente uma boa prática? Tendo em vista que alguma biblioteca de acesso HTTP pode, de repente, ser utilizada para fazer um loop e apagar várias entradas baseado nesse modelo de URL.
Sei que existem os cookies para registrar guardar os dados da sessão e que talvez é imprudente permitir a deleção leviana de itens sem nenhum controle, mas não sei como fazer isso.
O Django provê alguma proteção quanto a esse modelo de mapeamento? Caso seja uma má ideia mapear dessa maneira, qual uma boa prática para fazer uma remoção de objetos mais segura?

A: Isso é uma má ideia
O GET deve ser seguro, tal como especificado pela W3C na RFC 2616 (dê uma olhada no capítulo 9):

9.1.1 Safe Methods
Implementors should be aware that the software represents the user in
    their interactions over the Internet, and should be careful to allow
    the user to be aware of any actions they might take which may have an
    unexpected significance to themselves or others.
In particular, the convention has been established that the GET and
    HEAD methods SHOULD NOT have the significance of taking an action
    other than retrieval. These methods ought to be considered "safe".
    This allows user agents to represent other methods, such as POST, PUT
    and DELETE, in a special way, so that the user is made aware of the
    fact that a possibly unsafe action is being requested.
Naturally, it is not possible to ensure that the server does not
    generate side-effects as a result of performing a GET request; in
    fact, some dynamic resources consider that a feature. The important
    distinction here is that the user did not request the side-effects,
    so therefore cannot be held accountable for them.

Traduzindo para o português (minha tradução):

9.1.1 Métodos seguros
Implementadores devem saber que o software representa o usuário em suas interações na Internet, e devem ser cuidadosos em deixar que o usuário perceba quaisquer ações que eles realizem que possam ter um significado inesperado para si ou para outros.
Em particular, a convenção que foi estabelecida é que os métodos GET e HEAD NÃO DEVEM ter outra ação de significância além de obtenção. Estes métodos serão considerados "seguros". Isto permite que agentes do usuário possam representar outros métodos, tais como POST, PUT e DELETE, de uma forma especial, para que então os usuários percebam o fato de que uma ação possivelmente insegura está sendo solicitada.
Naturalmente, não é possível assegurar-se que o servidor não gerará efeitos colaterais como resultado da execução da requisição GET; de fato, alguns recursos dinâmicos consideram isso uma funcionalidade. A distinção importante aqui é que o usuário não solicitou os efeitos colaterais, e portanto não pode ser responsabilizado por eles.

Vamos enfatizar o segundo parágrafo. Um método GET (ou HEAD) não deve significar outra coisa além da obtenção de um recurso. Isto claramente vai contra a ideia de ter uma requisição GET que exclua um usuário. Além disso, tal como falado no terceiro parágrafo, quando o usuário executa um GET (normalmente através do navegador), ele não espera que essa ação tenha efeitos colaterais*, ainda mais um efeito colateral tal como deletar um usuário.
(*) Alguns efeitos colaterais simples, tal como aumentar o contador de visitas, estão ok, desde que sejam inofensivos. O mesmo vale para questões internas do servidor que são invisíveis ao usuário, tal como cache e logging.
Ah sim, e antes que alguém pergunte, o "seguro" neste contexto refere-se ao sentido de "a ação não causar nenhum efeito possivelmente danoso" (tal como a criação, alteração ou exclusão de recursos). Isso não significa ser seguro no sentido de evitar vazamento de informações ou de evitar o acesso indevido a recursos, isso já é outra coisa.
Quais são os potenciais riscos?
Essa URL poderia ser compartilhada aonde não deveria. Por exemplo, eu poderia enviá-la por e-mail ou postar em algum lugar qualquer na internet como aqui no StackOverflow com a finalidade de ludibriar o usuário e induzí-lo a fazer algo que não era o que ele queria, tal como no link abaixo (observe a URL do link):

Clique aqui para ver as fotos da festa!

O resultado disso é óbvio. Ao clicar na URL, o usuário acaba por realizar uma ação que não pretendia realizar. A navegação normal do usuário pelo site não deveria causar efeitos colaterais indesejados.
Além dissso, esta URL pode acabar por ser encontrada por robôs de busca que poderão tentar navegar por ela (o exemplo mais óbvio é o Google). O marcus deu um exemplo anedótico neste comentário demonstrando o perigo que isso representa:

Já me contaram a história de um caso onde uma equipe achava que seus servidores estavam sendo invadidos mas era só um buscador "indexando" os /deletar (e conseqüentemente apagando tudo que encontrava!). Se algum tutorial usou esse exemplo, seria bom enviar um bug report, não se deve ensinar uma coisa dessas!

Como proceder?
Utilizar o método GET não é a forma correta. O ideal é usar o método DELETE que serve exatamente para esta finalidade (destruir, invalidar ou apagar um recurso web). Entretanto em alguns casos, você pode ficar limitado somente a usar POST ou GET, e neste caso a solução é óbvia (por eliminação): utilize o POST.
Quanto as questões de segurança (no sentido de evitar acessos indevidos), vale utilizar HTTPS se pertinente e adotar medidas de proteção contra CSRF, XSS e outros possíveis problemas. Para isso vale verificar dados de sessão, cookies, autenticação e autorização, entre outros.


text:
Q: Foreach Loop Container For Data Flow Task I want to import nearly 12 million records from oracle DB but beacuse of the SSIS memory buffer problem i need to iterate my Data Flow Task for each year i.e 2005 to 2012 (7 times). How can i use foreach my oracle query to fetch the data year wise.
Query
SELECT * FROM EMP_RECORDS_DETAILS WHERE to_char(JOIN_DT,'YYYY')=2005

A: I have solved the above problem using Sql Server . So only thing which you need to change is the Select query

*

*First Create a variable to store the date for each year .
 Name: TimeValue  DataType=Int32

*Use a ForEach Loop and select Foreach Item enumerator in the collection tab

*Click on the Columns tab and create a new column of datatype int

*In the variable mapping map the variable created above .

*Inside the dataflow use an oledb destination and in the data access mode select sql command .The query in the where clause should be  changed  and try to select the columns instead of giving *.

*Click on the parameters tab map the parameter created for the foreach loop

In case if the values of date are not known before then you can use execute sql task before foreach loop and select only the dateTime column values from the table and store it in a variable and in the foreach loop use Foreach from variable enumerator in the collection tab and select the variable created in the above execute sql task .
Hope this helps u.


text:
Q: How to identify hung queries, their importance, and then take action using command line? From a production support perspective, how can we find hung queries and then find how important they are and then how to deal with them?
I tried only processlist which gives currently running queries but how to decide their importance and then act accordingly?
We don't have any MySQL performance tool with UI in existence in our environment, so how can I do this using command line?

A: There are two utilities that you may want to look at:
1) mytop
2) innotop
They are, as their names imply, the MySQL equivalent of the "top" system utility.
They won't help you figure out how "important" a query is because this requires deep knowledge of the system issuing the queries.
For a deeper, longer term (rather than real-time, catch-it-while-it's-running) insight, you can capture the slow log (adjust long_query_time appropriately to your opinion on what is problematic), and analyze the slow log using one of the following two tools:
1) mysqldumpslow
2) pt-query-digest
These will give you insight into which query "templates" are the ones consuming the largest amount of the server's CPU time.
When you outgrow the capabilities of the command line tools and you find you need a deeper long-term insight, I suggest you look at PMM (Percona Monitoring and Management), it is an extremely useful took for identifying performance issues on database (and not just database) servers.


text:
Q: Invalid Binary with Invalid Signature I am in the process of submitting my first Ionic application to the store. However I am receiving an error every single time that I try to submit my binary to the store:
Invalid Signature - A sealed resource is missing or invalid. The binary at path [Who Paid Last?.app/Who Paid Last?] contains an invalid signature. Make sure you have signed your application with a distribution certificate, not an ad hoc certificate or a development certificate....
I have verified that my certificates are correct. I have even tried moving my .git folder outside of the directory, but still no luck. I have tried about 7 different configurations and still the same result time and time again.
The crazy thing is that after my archive has been built, I validate using XCode's validator. The validator says that my .ipa has zero errors and that it is ready for submission, but iTunes Connect says differently.
I have also tried following this tutorial on troubleshooting but without any luck.

A: The issue had to do with the name of my app. The name of my application is Who Paid Last?, and come to find out, the "?" in the name is what was causing the issue. As soon as I removed it, the app was submitted just fine with out any issues.

A: I had a similar issue, but my error message was "Invalid Signature. Code object is not signed at all. The binary at path [myApp.app/www/js/02_jshint.js] contains an invalid signature...."
Deleting the #!/usr/bin/env directive from the top of my 02_jshint.js file, then building the iOS version of your project from the CLI worked for me.


text:
Q: How do I choose: ini or registry? What is the difference may be in the possession of the settings in the .Ini file and stored in the system registry? What are the pros and cons?

A: INI files were a Windows version 3.x artifact.  Windows contains heavy appcompat for them in order to allow Windows 3.x programs to still execute on modern Windows versions.  This appcompat is extraordinary expensive, reading a single setting from an .ini file costs 50 milliseconds.
There is also a very serious problem with text encoding, Windows can only assume that the .ini file text was encoded in a legacy code page, it assumes the default system code page.  With the significant problem that your .ini file content turns into garbage when it contains non-ASCII text and runs on another machine that's not close to yours.  Very hard to troubleshoot, next to impossible to fix.
Do not use INI files.

A: Refering to https://stackoverflow.com/a/9610086/1289469 from esnyder:

The registry is designed for persistent data storage with fast performance. Writing to and reading from the registry is safe. While a
  "corrupted registry" is certainly one of those on-going pseudo-myths,
  storing data in the registry doesn't necessarily "make all the
  computers explode all of the things." There is generally something
  very, VERY wrong if you're having registry issues today. It isn't only
  Windows that uses a registry - you can also check into Gnome's gconf.
  Mac uses a Property List (I think? I'm not a big Mac person....) and
  there are many other "registry-like" mechanisms.

A: It depends on what kind of settings you want to store, and what they're used for, but to answer quickly:
If you want to store settings that can be easily edited by the the user, you can store them in a file (but not in a ini, xml files are far better for that),
if you want to store settings that shouldn't be visible or edited by the standard user, store them in the registry.

A: Well the registry provides configuration/settings per user/local machine etc. where the ini file doest not. Although you can store the ini file in appdata for the current user. The pros of having an ini file is that it is easy configurable in comparison of using regedit to edit the registry. I would say it depends on what type of information you want to store.

A: Do you have to use .ini or registry? Maybe app.config is a better choice. It also depends on the type of settings you want to save.

Cons of Registry:
* You have to remove saved settings when uninstalling the program.
* It is not that easy to move settings to another machine.

Pros of Registry:
* Easier to have per-user settings.
* When saving an .ini-file in Program Files usually only administrator can edit it.
* Other application can access the settings saved in registry.


text:
Q: von Neumann on the Hamiltonian I'm reading von Neumann's book on QM and I'm slightly confused by a simple point. He writes,

"The energy is a given function of the coordinates and their time derivatives: $E = L(q_1,..,q_k;\dot{q}_1,...,\dot{q}_k) = H(q_1,...,q_k;p_1,...,p_k)$. (This $H$ is the Hamiltonian function.)

This quote comes from chapter 1. Does $L(....)$ denote the Lagrangian? Why does the second equality hold?

A: No, L does not stand for the Lagrangian $\cal L$: it stands for the "energy function" , ("as a rule, a quadratic function of the $\dot{q}$s"), an evident constant of the motion,
$$
L(q_i, \dot{q}_i) = \frac{\partial \cal{L}}{\partial\dot{q}_i}\dot{q}_i - \cal{L},
$$
so, basically, $\sim {\cal L} + 2V(q)$ for the quadratic function he is considering, a deeply unfortunate convention, ipso facto... (the energy function in the Lagrangian formalism), is all.
The momenta p are then the same gradients of $\cal L$ or L !   Storm in a teacup. Are you overthinking it?
The equality $L(q,\dot{q})=H(q,p)$ holds as usual in the Legendre transform transition from Lagrangian to Hamiltonian mechanics.
PS. von Neumann was famously too quick to imagine he'd have to explain things fully, preferring to rely on his proverbial well-meaning intelligent reader. Wait until you get to III.5.F, which has victimized generations of readers, and required a famous theorem to be declared confusing, after all.


text:
Q: memory not aligned properly? I'm trying to use aligned operations in SSE and I'm having an issue (surprise).
typedef struct _declspec(align(16)) Vec4 {
    float x;
    float y;
    float z;
    float w;
};

Vec4 SSE_Add(const Vec4 &a, const Vec4 &b) {
    _declspec(align(16)) Vec4 return_val;

    _asm {
        MOV EAX, a                    // Load pointers into CPU regs
        MOV EBX, b

        MOVAPS XMM0, [EAX]            // Move unaligned vectors to SSE regs
        MOVAPS XMM1, [EBX]

        ADDPS XMM0, XMM1              // Add vector elements
        MOVAPS [return_val], XMM0     // Save the return vector
    }

    return return_val;
}

I get an access violation at return return_val. Is this an alignment issue? How can I correct this?

A: I found out that the problem is with EBX register. If you push/pop EBX, then it works. I'm not sure why though, so if anyone can explain this - please do.
Edit: I've looked into the disassembly and at the beginning of a function it stores stack pointer in the EBX:
mov ebx, esp
So you better make sure not to lose it.

A: This is a bit compiler dependent... Isn't the correct thing to write:
    movaps return_val, xmm0
Why don't you show us the generated code?
The way you are writing this is a lot worse than if you let the compiler do it on its own.

*

*This function should be inlinable and translate to a single instruction in the best case, if you write it like this it cannot be inlined.

*This function could receive its arguments in registers in Intel 64 and return its result in a register, if you write it like this you force using the stack.

*This function could use return value optimization, writing it like this forces you to write xmm0 to the return_val variable which will have to be copied a second time.

So... aligned versus unaligned MOVPS is your least concern.
Why not just, in portable code, write:
inline void add(const float *__restrict__ a, const float *__restrict__ b, float *__restrict__ r)
{
    for (int i = 0; i != 4; ++i) r[i] = a[i] + b[i];
}


text:
Q: How to secure PHP Services that are using in HYBRID Mobile App?? Explain in Clearly.I am new to PHP.Simply I created Services Like How to secure PHP Services that are using in HYBRID Mobile App?? Explain in Briefly.I am new to PHP, I just want to learn how to create secured services in
PHP and want to use them in Mobile App.Simply I created Services Like Below
<?php
    header('Access-Control-Allow-Origin: *');
    header('Content-Type:Application/Json',false);
    include("functions.php");
    if(!empty($_GET['view']))
    {
        $view = $_GET['view'];
        $employees = getDetails();
        if(empty($employees))
        {
            deliver_response(200,"data not found",NULL);
        }
        else
        {
            deliver_response(200,"data found",$employees);
        }
    }
    else
    {
        deliver_response(400,"invalid request",NULL);
    }
    function deliver_response($status,$status_message,$data)
    {
            header("HTTP/1.1 $status $status_message");

            $response['status']=$status;
            $response['status_message']=$status_message;
            $response['data']=$data;
            if($status_message=="data found")
        {
                $json_response=json_encode($data);
        }
        else
        {
            $json_response=json_encode($response);

        }
        echo $json_response;
    }
?>


text:
Q: How to render multiple AmCharts (version 3) Serial chart on same page? I need a page with several charts (render multiple aspects of same dataset).

*

*I use the same dataset

*with the same chartConfig (cloned by $.extend

*2 charts

*all are serial type

Here is the problem code http://jsfiddle.net/mZ2Gq/227/
var chart1 = AmCharts.makeChart("chart1div", $.extend(true, AMCHART_SERIAL_CONFIG, { "theme": "dark" }) );
var chart2 = AmCharts.makeChart("chart2div", $.extend(true, AMCHART_SERIAL_CONFIG, { "theme": "light" }) );

It only can render the last chart propertly. How can I work-around this issue?

A: The problem is that you're using the same configuration object for both charts. This does not work.
You can solve this by using an empty object {} as target in the $.extend method.
Just like this:
AmCharts.makeChart("chart", $.extend(true, {}, AMCHART_SERIAL_CONFIG, {theme: "dark"}));

Here's your updated fiddle.
Note: You should avoid using deep merge if not necessary. It slows your code.


text:
Q: Sorting column based on number of occurences in R I have a dataset which has a column named 'customername'.
Sample dataset:
+==================================+===============+==+==+===============================+==+
 |          Customer Name           | Customer code |  |  |         Invoice Type          |  |
+==================================+===============+==+==+===============================+==+
 | ALECTRONA ENERGY PRIVATE LIMITED | IMA281        |  |  | In-Bonding Invoice            |  |
+----------------------------------+---------------+--+--+-------------------------------+--+
| A P SRINIVASAN AND SONS          | CHA061        |  |  | In-Bonding Invoice            |  |
+----------------------------------+---------------+--+--+-------------------------------+--+
| MOLEX INDIA PVT LTD              | IMM098        |  |  | Import Final Delivery Invoice |  |
+----------------------------------+---------------+--+--+-------------------------------+--+

Required:
Based on frequency I need to sort the dataset. Ex. If I have name as 'Hogg' it needs to print how many times 'hogg" occured and sort the whole dataset which has maximum occurence.
For this I used below command,
arrangedone = sort(table(data$`Customer Name`),decreasing = TRUE)

Which gives customer name with max appearance, based on this I need to sort the whole dataset.
And I arranged or sorted by using arrange command.
arrange(data,arrangedone).

It throws an error as
     "Error in arrange_impl(.data, dots):incorrect size (2243) at position 1, expecting : 28898

Can I have any other option/command to overcome this?
Thanks

A: If you are looking to sort a dataset using a variable, and display how many occurrences there were you may want to try the add_count() function from the dplyr package. I have created a small reproducible example below to demonstrate. Using the sort = TRUE parameter will sort the data set based on the count of occurrences.
library(dplyr)
#>
#> Attaching package: 'dplyr'
#> The following objects are masked from 'package:stats':
#>
#>     filter, lag
#> The following objects are masked from 'package:base':
#>
#>     intersect, setdiff, setequal, union

custs <- tibble::tribble(
  ~customername, ~customercode,
          "Bob",         1234L,
         "Jane",         4567L,
        "Alice",         5487L,
      "Michael",         7891L,
          "Bob",         1234L,
         "Jane",         4567L,
      "Michael",         7891L,
          "Bob",         1234L
  )

custs %>%
  add_count(customername, sort = TRUE)
#> # A tibble: 8 x 3
#>   customername customercode     n
#>   <chr>               <int> <int>
#> 1 Bob                  1234     3
#> 2 Bob                  1234     3
#> 3 Bob                  1234     3
#> 4 Jane                 4567     2
#> 5 Michael              7891     2
#> 6 Jane                 4567     2
#> 7 Michael              7891     2
#> 8 Alice                5487     1

Created on 2019-01-11 by the reprex package (v0.2.1)