예제 #1
0
파일: zfl_config.c 프로젝트: mkoppanen/zfl
zfl_config_t *
zfl_config_load (char *filename)
{
    //  Open file as specified and make sure we can read it
    FILE *file;
    if (streq (filename, "-"))
        file = stdin;           //  "-" means read from stdin
    else {
        file = fopen (filename, "r");
        if (!file)
            return NULL;        //  File missing or not readable
    }
    //  Load file data into a memory blob
    zfl_blob_t *blob = zfl_blob_new (NULL, 0);
    assert (blob);
    assert (zfl_blob_load (blob, file));
    fclose (file);

    //  Autodetect whether it's JSON or ZPL text
    char *data = (char *) zfl_blob_data (blob);
    while (isspace (*data))
        data++;

    zfl_config_t *self;
    if (*data == '{')
        self = zfl_config_json ((char *) zfl_blob_data (blob));
    else
        self = zfl_config_zpl ((char *) zfl_blob_data (blob));

    zfl_blob_destroy (&blob);
    return self;
}
예제 #2
0
파일: zfl_blob.c 프로젝트: thijsterlouw/zfl
//  --------------------------------------------------------------------------
//  Selftest
//
int
zfl_blob_test (Bool verbose)
{
    zfl_blob_t
        *blob;
    char
        *string = "This is a string";
    FILE
        *file;

    printf (" * zfl_blob: ");
    blob = zfl_blob_new (NULL, 0);
    assert (blob);
    assert (zfl_blob_size (blob) == 0);

    file = fopen ("zfl_blob.c", "r");
    assert (file);
    assert (zfl_blob_load (blob, file));
    fclose (file);

    assert (zfl_blob_size (blob) > 0);
    zfl_blob_set_data (blob, string, strlen (string));
    assert (zfl_blob_size (blob) == strlen (string));
    assert (streq ((char *) (zfl_blob_data (blob)), string));

    zfl_blob_destroy (&blob);
    assert (blob == NULL);

    printf ("OK\n");
    return 0;
}
예제 #3
0
파일: zfl_config.c 프로젝트: mkoppanen/zfl
char *
zfl_config_string (zfl_config_t *self)
{
    assert (self);
    if (self->blob)
        return (char *) zfl_blob_data (self->blob);
    else
        return "";
}
예제 #4
0
파일: zfl_config.c 프로젝트: mkoppanen/zfl
int
zfl_config_set_value (zfl_config_t *self, zfl_blob_t *blob)
{
    assert (self);
    zfl_blob_destroy (&self->blob);
    if (blob)
        self->blob = zfl_blob_new (zfl_blob_data (blob), zfl_blob_size (blob));
    return 0;
}
예제 #5
0
파일: zfl_tree.c 프로젝트: thijsterlouw/zfl
//  --------------------------------------------------------------------------
//  Returns tree string value
//
char *
zfl_tree_string (zfl_tree_t *self)
{
    assert (self);
    if (self->blob)
        return zfl_blob_data (self->blob);
    else
        return "";
}
예제 #6
0
파일: zdevice.c 프로젝트: INNOAUS/zdevices
//  Starts a device as configured by a full ZDCF config file
//
static void
s_start_configured_device (char *filename)
{
    FILE *file;                 //  JSON config file stream
    if (streq (filename, "-"))
        file = stdin;           //  "-" means read from stdin
    else {
        file = fopen (filename, "rb");
        if (!file) {
            printf ("E: '%s' doesn't exist or can't be read\n", filename);
            exit (EXIT_FAILURE);
        }
    }
    //  Load config data into blob
    zfl_blob_t *blob = zfl_blob_new ();
    assert (blob);
    zfl_blob_load (blob, file);
    fclose (file);

    //  Create a new config from the blob data
    zfl_config_t *config = zfl_config_new (zfl_blob_data (blob));
    assert (config);

    //  Find first device
    char *device = zfl_config_device (config, 0);
    if (!*device) {
        printf ("E: No device specified, please read http://rfc.zeromq.org/spec:3\n");
        exit (EXIT_FAILURE);
    }
    //  Process device type
    char *type = zfl_config_device_type (config, device);

    int device_type;            //  0MQ defined type
    int frontend_type;          //  Socket types depending
    int backend_type;           //    on the device type
    s_parse_device_type (type, &device_type, &frontend_type, &backend_type);

    //  Create and configure sockets
    void *frontend = zfl_config_socket (config, device, "frontend", frontend_type);
    assert (frontend);
    void *backend = zfl_config_socket (config, device, "backend", backend_type);
    assert (backend);

    //  Start the device now
    if (zfl_config_verbose (config))
        printf ("I: Starting device...\n");

    //  Will not actually ever return
    zmq_device (device_type, frontend, backend);

    zfl_config_destroy (&config);
}
예제 #7
0
파일: zfl_tree.c 프로젝트: thijsterlouw/zfl
//  --------------------------------------------------------------------------
//  Dump tree to stdout in ZPL format
//
static int
s_tree_dump (zfl_tree_t *self, void *context, int level)
{
    assert (self);
    if (level > 0) {
        if (self->blob)
            printf ("%*s%s = %s\n", (level - 1) * 4, "",
                self->name? self->name: "(Unnamed)",
                (char *) zfl_blob_data (self->blob));
        else
            printf ("%*s%s\n", (level - 1) * 4, "",
                self->name? self->name: "(Unnamed)");
    }
    return 0;
}
예제 #8
0
파일: zfl_config.c 프로젝트: mkoppanen/zfl
static int
s_config_save (zfl_config_t *self, void *arg, int level)
{
    assert (self);
    assert (arg);

    FILE *file = (FILE *) arg;
    if (level > 0) {
        if (self->blob)
            fprintf (file, "%*s%s = %s\n", (level - 1) * 4, "",
                self->name? self->name: "(Unnamed)",
                (char *) zfl_blob_data (self->blob));
        else
            fprintf (file, "%*s%s\n", (level - 1) * 4, "",
                self->name? self->name: "(Unnamed)");
    }
    return 0;
}