int para_compare(keys_t *keys, const para_t *a, const para_t *b)
{
int r = 0;
for (size_t i = 0; i < keys->nks; i++) {
char * af = get_field_as(a, keys->keys[i].field_inx);
char * bf = get_field_as(b, keys->keys[i].field_inx);
if (af == 0 || bf == 0) fatal_enomem(0);
switch (keys->keys[i].type) {
case FT_STRING:
r = strcmp(af, bf);
break;
case FT_VERSION:
;
struct versionrevision ar, br;
bool aok = parse_version(&ar, af, strlen(af));
bool bok = parse_version(&br, bf, strlen(bf));
if (!aok || !bok) {
message(L_IMPORTANT, 0,
_("Parse error in field."));
free(af);
free(bf);
return aok ? (bok ? 0 : 1) : (bok ? -1 : 0);
}
r = versioncompare(&ar, &br);
break;
}
debug("cmp: a = %s, b = %s, verdict is %d", af, bf, r);
free(af);
free(bf);
if (keys->keys[i].reverse) r = -r;
if (r != 0) break;
}
return r;
}
static gint
string_versions_compare (const gchar *version1,
const gchar *version2)
{
glong vmajor1 = 0, vminor1 = 0, vmicro1 = 0, vmajor2 = 0, vminor2 = 0, vmicro2 = 0;
parse_version (version1, &vmajor1, &vminor1, &vmicro1);
parse_version (version2, &vmajor2, &vminor2, &vmicro2);
return ((vmajor1 != vmajor2) ? (vmajor1 > vmajor2 ? +1 : -1) :
(vminor1 != vminor2) ? (vminor1 > vminor2 ? +1 : -1) :
(vmicro1 < vmicro2 ? -1 : vmicro1 > vmicro2));
}
static int compare_version(pool *p, char *version_str, char **error) {
char *server_version_str;
unsigned int version_status = 0, server_version_status = 0;
unsigned int version[3] = { 0, 0, 0 }, server_version[3] = { 0, 0, 0 };
int res;
res = parse_version(version_str, version, &version_status);
if (res < 0) {
*error = pstrcat(p, "badly formatted configured version '", version_str,
"'", NULL);
return -1;
}
server_version_str = pstrdup(p, pr_version_get_str());
res = parse_version(server_version_str, server_version,
&server_version_status);
if (res < 0) {
*error = pstrcat(p, "badly formatted server version '", server_version_str,
"'", NULL);
return -1;
}
*error = NULL;
if (server_version[0] > version[0]) {
return 1;
} else if (server_version[0] < version[0]) {
return -1;
} else if (server_version[1] > version[1]) {
return 1;
} else if (server_version[1] < version[1]) {
return -1;
} else if (server_version[2] > version[2]) {
return 1;
} else if (server_version[2] < version[2]) {
return -1;
} else if (server_version_status > version_status) {
return 1;
} else if (server_version_status < version_status) {
return -1;
}
/* Appear to be the same versions. */
return 0;
}
w_err_t parse_line(char *buff,pack_info_s *info)
{
w_int32_t cnt;
char *str[2];
cnt = wind_strsplit(buff,'=',str,2);
WIND_ASSERT_RETURN(cnt == 2,W_ERR_FAIL);
if(wind_strcmp(str[0],"arch") == 0)
{
wind_strcpy(info->arch_name,str[1]);
wind_notice("arch : %s",info->arch_name);
}
else if(wind_strcmp(str[0],"cpu") == 0)
{
wind_strcpy(info->cpu_name,str[1]);
wind_notice("cpu : %s",info->cpu_name);
}
else if(wind_strcmp(str[0],"board") == 0)
{
wind_strcpy(info->board_name,str[1]);
wind_notice("board : %s",info->board_name);
}
else if(wind_strcmp(str[0],"hardversion") == 0)
{
parse_version(&info->hw_version,str[1]);
wind_notice("hard_version : %d.%d.%d",DWORD_HBYTE2(info->hw_version),
DWORD_HBYTE3(info->hw_version),DWORD_HBYTE4(info->hw_version));
}
else if(wind_strcmp(str[0],"softversion") == 0)
{
parse_version(&info->sw_version,str[1]);
wind_notice("soft_version : %d.%d.%d",DWORD_HBYTE2(info->sw_version),
DWORD_HBYTE3(info->sw_version),DWORD_HBYTE4(info->sw_version));
}
//else if(wind_strcmp(str[0],"encrypt") == 0)
// parse_encrypt_type(info,str[1]);
//else if(wind_strcmp(str[0],"encryptkey") == 0)
// parse_encrypt_key(info,str[1]);
else if(wind_strcmp(str[0],"inputfile") == 0)
{
parse_input_file(info,str[1]);
}
else if(wind_strcmp(str[0],"outputfile") == 0)
{
wind_strcpy(info->output_file,str[1]);
wind_notice("outputfile : %s",info->output_file);
}
return W_ERR_OK;
}
void GET_CURRENT_VERSION_OP::handle_reply(int http_op_retval) {
char buf[256], new_version[256];
if (http_op_retval) {
error_num = http_op_retval;
return;
}
gstate.new_version_check_time = gstate.now;
FILE* f = boinc_fopen(GET_CURRENT_VERSION_FILENAME, "r");
if (!f) return;
while (fgets(buf, 256, f)) {
if (match_tag(buf, "<version>")) {
if (parse_version(f, new_version)) {
msg_printf(0, MSG_USER_ALERT,
"A new version of BOINC (%s) is available",
new_version
);
msg_printf(0, MSG_USER_ALERT,
"Visit %s to download it",
config.client_download_url.c_str()
);
gstate.newer_version = string(new_version);
break;
}
}
}
fclose(f);
}
int version_constraints_satisfied(depend_t * depends, pkg_t * pkg)
{
pkg_t *temp;
int comparison;
if (depends->constraint == NONE)
return 1;
temp = pkg_new();
parse_version(temp, depends->version);
comparison = pkg_compare_versions(pkg, temp);
free(temp->version);
free(temp);
if ((depends->constraint == EARLIER) && (comparison < 0))
return 1;
else if ((depends->constraint == LATER) && (comparison > 0))
return 1;
else if ((depends->constraint == EQUAL) && (comparison == 0))
return 1;
else if ((depends->constraint == LATER_EQUAL) && (comparison >= 0))
return 1;
else if ((depends->constraint == EARLIER_EQUAL) && (comparison <= 0))
return 1;
return 0;
}
/* Read some fields under the <os/> node. */
static int
read_os_node (guestfs_h *g, xmlXPathContextPtr xpathCtx,
xmlNodePtr os_node, struct osinfo *osinfo)
{
xmlNodePtr child;
for (child = os_node->children; child; child = child->next) {
if (STREQ ((const char *) child->name, "name"))
osinfo->product_name = (char *) xmlNodeGetContent (child);
else if (STREQ ((const char *) child->name, "version")) {
if (parse_version (g, child, osinfo) == -1)
return -1;
}
else if (STREQ ((const char *) child->name, "family")) {
if (parse_family (g, child, osinfo) == -1)
return -1;
}
else if (STREQ ((const char *) child->name, "distro")) {
if (parse_distro (g, child, osinfo) == -1)
return -1;
}
}
return 0;
}
int gleswInit(void)
{
open_libgl();
load_procs();
close_libgl();
return parse_version();
}
G_MODULE_EXPORT gboolean on_compatibility_change(GtkWidget *widget, gtk_widgets_t *data)
{
_version = parse_version(gtk_menu_item_get_label((GtkMenuItem *)widget));
const char *v = get_version_string(_version);
update_config(CONF_VERSION, v);
return (void)data, TRUE;
}
int compareVersion(string version1, string version2) {
vector<string> version1_level=parse_version(version1);
vector<string> version2_level=parse_version(version2);
if(version1_level.empty()||version2_level.empty())
return 0;
for(int i=0;i<version1_level.size()&&i<version2_level.size();i++){
if(stoi(version1_level[i])>stoi(version2_level[i]))
return 1;
else if(stoi(version1_level[i])<stoi(version2_level[i]))
return -1;
}
if(version1_level.size()>version2_level.size())
return 1;
else if (version1_level.size()<version2_level.size())
return -1;
else
return 0;
}
int gl3wInit2(GL3WGetProcAddressProc proc)
{
int res = open_libgl();
if (res)
return res;
atexit(close_libgl);
load_procs(proc);
return parse_version();
}
/*
====================================================================
Get version and current update of levelset: x.x
Will reset the file pointer to beginning.
====================================================================
*/
void levelset_get_version( FILE *file, int *version, int *update )
{
char buffer[1024];
*version = 1; *update = 0;
fseek( file, 0, SEEK_SET );
next_line( file, buffer );
if ( strlen( buffer ) > 8 && !strncmp( buffer, "Version:", 8 ) )
parse_version( buffer + 8, version, update );
else
fseek( file, 0, SEEK_SET );
}
TEST(database, list_packages){
char* argz=0;
size_t argz_len=0;
TEST_ASSERT_EQUAL(SQLITE_ROW,list_packages(&argz,&argz_len,"Gcc"));
char* entry=0;
entry=argz_next(argz,argz_len,entry);
TEST_ASSERT_EQUAL_STRING(package.name, entry);
entry=argz_next(argz,argz_len,entry);
TEST_ASSERT_EQUAL_STRING(package.description, entry);
entry=argz_next(argz,argz_len,entry);
TEST_ASSERT_EQUAL(package.version, parse_version(entry));
}
/* mport_version_cmp(version1, version2)
*
* Compare two given version strings. Returns 0 if the versions
* are the same, -1 if version1 is less than version2, 1 otherwise.
*/
MPORT_PUBLIC_API int mport_version_cmp(const char *astr, const char *bstr)
{
struct version a;
struct version b;
int result;
parse_version(astr, &a);
parse_version(bstr, &b);
/* remember that a.version/b.version are useless after calling
cmp_versions (but astr and bstr are unchanged.) */
if ((result = cmp_ints(a.epoch, b.epoch)) == 0) {
if ((result = cmp_versions(a.version, b.version)) == 0) {
result = cmp_ints(a.revision, b.revision);
}
}
free(a.version);
free(b.version);
return result;
}
int main(int argc, char **argv) {
struct version_tuple older = VERSION_TUPLE(1,8,34), newer = VERSION_TUPLE(1,8,46);
const char *old_s="1.8.34", *new_s="1.8.46";
const char *vs = "1.8.37";
struct version_tuple version = {0};
parse_version(vs, &version, ".");
printf("%s cmp %s = %d\n", vs, str_version(&older,'.'), compare_versions(&version, &older));
printf("%s cmp %s = %d\n", vs, str_version(&newer,'.'), compare_versions(&version, &newer));
printf("%s cmp %s = %d\n", old_s, new_s, compare_versions(&older, &newer));
printf("%s cmp %s = %d\n", new_s, old_s, compare_versions(&newer, &older));
vs = "1.8.46.0";
parse_version(vs, &version, ".");
printf("%s cmp %s = %d\n", vs, str_version(&older,'.'), compare_versions(&version, &older));
printf("%s cmp %s = %d\n", vs, str_version(&newer,'.'), compare_versions(&version, &newer));
return 0;
}
gssize
_web_socket_util_parse_status_line (const gchar *data,
gsize length,
guint *status,
gchar **reason)
{
const gchar *at;
const gchar *end;
gsize n;
guint64 num;
gchar *ep;
/*
* Here we parse a line like:
*
* HTTP/1.1 101 Switching protocols
*/
at = data;
end = memchr (at, '\n', length);
if (end == NULL)
return 0; /* need more data */
n = parse_version (at, (end - at));
if (n == 0 || at[n] != ' ')
return -1;
at += n;
/* Extra spaces */
at = strskip (at, ' ', end);
/* First check for space after status */
if (memchr (at, ' ', (end - at)) == NULL)
return -1;
/* This will stop at above space */
num = g_ascii_strtoull (at, &ep, 10);
if (num == 0 || num > G_MAXUINT || *ep != ' ')
return -1;
at = strskip (ep, ' ', end);
if (reason)
{
*reason = g_strndup (at, (end - at));
g_strstrip (*reason);
}
if (status)
*status = (guint)num;
return (end - data) + 1;
}
void *my_generate_key(const void *data)
{
const char *line = data;
size_t l;
char *s, *p;
char *string;
struct beeversion *v;
string = strdup(line);
if(!string) {
perror("calloc(s)");
return NULL;
}
s = string;
l = strlen(s);
p = s+l-1;
while (p > s && (*p == ' ' || *p == '\t' || *p == '\n' || *p == '\r'))
*(p--) = 0;
while (*s && (*s == ' ' || *s == '\t'))
s++;
if(p < s) {
free(string);
errno = EINVAL;
return NULL;
}
v = calloc(1, sizeof(*v));
if(!v) {
perror("calloc(beeversion)");
free(string);
return NULL;
}
if(parse_version(s, v) != 0) {
free(v->string);
init_version(s, v);
v->pkgname = v->string;
}
free(string);
return v;
}
static void
gob2_configure (void)
{
const char *minversion_string;
Version minversion;
char *error = NULL;
minversion_string = jb_variable_get_string("gob2-minversion");
if (! parse_version(minversion_string, &minversion))
g_error("invalid gob2-minversion \"%s\"", minversion_string);
if (jb_check_program("gob2"))
{
char *output;
gboolean result = FALSE;
jb_message_checking("for gob2 >= %s", minversion_string);
if (jb_exec_expand(NULL, &output, "$gob2 --version", NULL))
{
char *version_string;
Version version;
if (parse_gob2_version_output(output, &version_string, &version))
{
if (version_to_int(&version) >= version_to_int(&minversion))
result = TRUE;
else
error = g_strdup_printf("One or more .gob source files were modified but the version of gob2 (%s) is too old. Please install gob2 >= %s and run configure again.",
version_string,
minversion_string);
}
else
error = get_gob2_not_found_error(minversion_string);
}
else
error = get_gob2_not_found_error(minversion_string);
g_free(output);
jb_message_result_bool(result);
}
else
error = get_gob2_not_found_error(minversion_string);
jb_variable_set_string("gob2-error", error);
g_free(error);
}
/* Parses expected server response to CFdDVK command: should be four newline
* terminated numbers and a version string. */
static bool parse_archive_parameters(const char **string)
{
return
parse_double(string, &sample_frequency) &&
parse_char(string, '\n') &&
parse_uint(string, &first_decimation) &&
parse_char(string, '\n') &&
parse_uint(string, &second_decimation) &&
parse_char(string, '\n') &&
parse_version(string) &&
parse_char(string, '\n') &&
parse_uint(string, &fa_entry_count) &&
parse_char(string, '\n') &&
parse_uint(string, &continuous_decimation) &&
parse_char(string, '\n');
}
void
connection_warnings(bool in_startup)
{
if (!pset.quiet && !pset.notty)
{
int client_ver = parse_version(PG_VERSION);
if (pset.sversion != client_ver)
{
const char *server_version;
char server_ver_str[16];
/* Try to get full text form, might include "devel" etc */
server_version = PQparameterStatus(pset.db, "server_version");
if (!server_version)
{
snprintf(server_ver_str, sizeof(server_ver_str),
"%d.%d.%d",
pset.sversion / 10000,
(pset.sversion / 100) % 100,
pset.sversion % 100);
server_version = server_ver_str;
}
printf(_("%s (%s, server %s)\n"),
pset.progname, PG_VERSION, server_version);
}
/* For version match, only print psql banner on startup. */
else if (in_startup)
printf("%s (%s)\n", pset.progname, PG_VERSION);
if (pset.sversion / 100 != client_ver / 100)
printf(_("WARNING: %s version %d.%d, server version %d.%d.\n"
" Some psql features might not work.\n"),
pset.progname, client_ver / 10000, (client_ver / 100) % 100,
pset.sversion / 10000, (pset.sversion / 100) % 100);
#ifdef WIN32
checkWin32Codepage();
#endif
printSSLInfo();
}
}
void GET_CURRENT_VERSION_OP::handle_reply(int http_op_retval) {
char buf[256], new_version[256];
if (http_op_retval) {
error_num = http_op_retval;
return;
}
gstate.new_version_check_time = gstate.now;
FILE* f = boinc_fopen(GET_CURRENT_VERSION_FILENAME, "r");
if (!f) return;
while (fgets(buf, 256, f)) {
if (match_tag(buf, "<version>")) {
if (parse_version(f, new_version)) {
show_newer_version_msg();
gstate.newer_version = string(new_version);
break;
}
}
}
fclose(f);
}
extern void set_compatibility_menu(gtk_widgets_t *data, char *version)
{
GSList *g = NULL;
version_e v = parse_version(version);
for (version_e i = VERSION_CURRENT; i > VERSION_UNKNOWN; i--)
{
const char *t = get_version_string(i);
GtkWidget *m = gtk_radio_menu_item_new_with_label(g, t);
g = gtk_radio_menu_item_get_group((GtkRadioMenuItem *)m);
gtk_menu_shell_append((GtkMenuShell *)data->compat_menu, m);
g_signal_connect(G_OBJECT(m), "toggled", G_CALLBACK(on_compatibility_change), data);
gtk_widget_show(m);
if (i == v || i == VERSION_CURRENT)
{
gtk_check_menu_item_set_active((GtkCheckMenuItem *)m, TRUE);
_version = i;
}
}
return;
}
static gboolean
parse_gob2_version_output (char *str,
char **version_string,
Version *version)
{
char *space;
char *_version_string;
space = strrchr(str, ' ');
if (space == NULL)
return FALSE;
_version_string = space + 1;
if (parse_version(_version_string, version))
{
*version_string = _version_string;
return TRUE;
}
return FALSE;
}
bool request_header::start_line_found(const char* start, const char* end)
{
assert(start != end);
tools::substring method_text;
tools::substring rest;
if ( !tools::split(start, end, ' ', method_text, rest) )
return false;
// simple, linear search
const header_desc* header_entry = tools::begin(valid_headers);
for ( ; header_entry != tools::end(valid_headers) && method_text != header_entry->name; ++header_entry )
;
if ( header_entry == tools::end(valid_headers) )
return false;
method_ = header_entry->code;
tools::substring version;
return tools::split(rest, ' ', uri_, version) && parse_version(version);
}
/*
* Make a database connection with the given parameters. An
* interactive password prompt is automatically issued if required.
*
* If fail_on_error is false, we return NULL without printing any message
* on failure, but preserve any prompted password for the next try.
*/
static PGconn *
connectDatabase(const char *dbname, const char *pghost, const char *pgport,
const char *pguser, bool require_password, bool fail_on_error)
{
PGconn *conn;
bool need_pass = false;
const char *remoteversion_str;
int my_version;
static char *password = NULL;
if (require_password && !password)
password = simple_prompt("Password: "******"%s: could not connect to database \"%s\"\n"),
progname, dbname);
exit(1);
}
if (PQstatus(conn) == CONNECTION_BAD &&
strcmp(PQerrorMessage(conn), PQnoPasswordSupplied) == 0 &&
!feof(stdin))
{
PQfinish(conn);
need_pass = true;
if (password)
free(password);
password = NULL;
password = simple_prompt("Password: "******"%s: could not connect to database \"%s\": %s\n"),
progname, dbname, PQerrorMessage(conn));
exit(1);
}
else
{
PQfinish(conn);
return NULL;
}
}
remoteversion_str = PQparameterStatus(conn, "server_version");
if (!remoteversion_str)
{
fprintf(stderr, _("%s: could not get server version\n"), progname);
exit(1);
}
server_version = parse_version(remoteversion_str);
if (server_version < 0)
{
fprintf(stderr, _("%s: could not parse server version \"%s\"\n"),
progname, remoteversion_str);
exit(1);
}
my_version = parse_version(PG_VERSION);
if (my_version < 0)
{
fprintf(stderr, _("%s: could not parse version \"%s\"\n"),
progname, PG_VERSION);
exit(1);
}
if (my_version != server_version
&& (server_version < 70000 /* we can handle back to 7.0 */
|| server_version > my_version))
{
fprintf(stderr, _("server version: %s; %s version: %s\n"),
remoteversion_str, progname, PG_VERSION);
if (ignoreVersion)
fprintf(stderr, _("proceeding despite version mismatch\n"));
else
{
fprintf(stderr, _("aborting because of version mismatch (Use the -i option to proceed anyway.)\n"));
exit(1);
}
}
/*
* On 7.3 and later, make sure we are not fooled by non-system schemas in
* the search path.
*/
if (server_version >= 70300)
executeCommand(conn, "SET search_path = pg_catalog");
return conn;
}
int gl3wInit2(GL3WGetProcAddressProc proc)
{
load_procs(proc);
return parse_version();
}
bool os_release_load(struct release* release,
const char* path,
const char* errpath)
{
memset(release, 0, sizeof(*release));
FILE* fp = fopen(path, "r");
if ( !fp )
{
if ( errno != ENOENT )
warn("%s", errpath);
return false;
}
bool failure = false;
bool success = false;
bool found_id = false;
bool found_pretty_name = false;
bool found_sortix_abi = false;
bool found_version_id = false;
char* line = NULL;
size_t line_size = 0;
ssize_t line_length;
while ( 0 < (line_length = getline(&line, &line_size, fp)) )
{
if ( line[line_length-1] == '\n' )
line[--line_length] = '\0';
if ( !strncmp(line, "ID=", strlen("ID=")) )
{
const char* param = line + strlen("ID=");
found_id = true;
char* value = os_release_eval(param);
if ( value )
{
if ( strcmp(value, "sortix") != 0 )
{
warn("%s: ID does not specify a 'sortix' system", errpath);
failure = true;
}
free(value);
}
else
{
warn("malloc");
failure = true;
}
}
else if ( !strncmp(line, "PRETTY_NAME=", strlen("PRETTY_NAME=")) )
{
const char* param = line + strlen("PRETTY_NAME=");
found_pretty_name = true;
if ( !(release->pretty_name = os_release_eval(param)) )
{
warn("malloc");
failure = true;
}
}
else if ( !strncmp(line, "SORTIX_ABI=", strlen("SORTIX_ABI=")) )
{
const char* param = line + strlen("SORTIX_ABI=");
found_sortix_abi = true;
char* value = os_release_eval(param);
if ( value )
{
parse_version(value, &release->abi_major, &release->abi_minor);
free(value);
}
else
{
warn("malloc");
failure = true;
}
}
else if ( !strncmp(line, "VERSION_ID=", strlen("VERSION_ID=")) )
{
const char* param = line + strlen("VERSION_ID=");
found_version_id = true;
char* value = os_release_eval(param);
if ( value )
{
parse_release(value, &release->version_major,
&release->version_minor, &release->version_dev);
free(value);
}
else
{
warn("malloc");
failure = true;
}
}
}
if ( ferror(fp) )
warn("%s", errpath);
else if ( failure )
;
else if ( !found_id )
warnx("%s: No ID", errpath);
else if ( !found_pretty_name )
warnx("%s: No PRETTY_NAME", errpath);
else if ( !found_sortix_abi )
warnx("%s: No SORTIX_ABI", errpath);
else if ( !found_version_id )
warnx("%s: No VERSION_ID", errpath);
else
success = true;
free(line);
fclose(fp);
if ( failure || !success )
{
release_free(release);
return false;
}
return true;
}
/*
* Parse SDP message.
*/
PJ_DEF(pj_status_t) pjmedia_sdp_parse( pj_pool_t *pool,
char *buf, pj_size_t len,
pjmedia_sdp_session **p_sdp)
{
pj_scanner scanner;
pjmedia_sdp_session *session;
pjmedia_sdp_media *media = NULL;
void *attr;
pjmedia_sdp_conn *conn;
pj_str_t dummy;
int cur_name = 254;
parse_context ctx;
PJ_USE_EXCEPTION;
ctx.last_error = PJ_SUCCESS;
init_sdp_parser();
pj_scan_init(&scanner, buf, len, 0, &on_scanner_error);
session = pj_pool_calloc(pool, 1, sizeof(pjmedia_sdp_session));
PJ_ASSERT_RETURN(session != NULL, PJ_ENOMEM);
PJ_TRY {
while (!pj_scan_is_eof(&scanner)) {
cur_name = *scanner.curptr;
switch (cur_name) {
case 'a':
attr = parse_attr(pool, &scanner, &ctx);
if (attr) {
if (media) {
media->attr[media->attr_count++] = attr;
} else {
session->attr[session->attr_count++] = attr;
}
}
break;
case 'o':
parse_origin(&scanner, session, &ctx);
break;
case 's':
parse_generic_line(&scanner, &session->name, &ctx);
break;
case 'c':
conn = pj_pool_calloc(pool, 1, sizeof(*conn));
parse_connection_info(&scanner, conn, &ctx);
if (media) {
media->conn = conn;
} else {
session->conn = conn;
}
break;
case 't':
parse_time(&scanner, session, &ctx);
break;
case 'm':
media = pj_pool_calloc(pool, 1, sizeof(*media));
parse_media(&scanner, media, &ctx);
session->media[ session->media_count++ ] = media;
break;
case 'v':
parse_version(&scanner, &ctx);
break;
case 13:
/* Allow empty newline at the end of the message */
pj_scan_get_char(&scanner);
/* Continue below */
case 10:
pj_scan_get_char(&scanner);
if (!pj_scan_is_eof(&scanner)) {
on_scanner_error(&scanner);
}
break;
default:
if (cur_name >= 'a' && cur_name <= 'z')
parse_generic_line(&scanner, &dummy, &ctx);
else {
ctx.last_error = PJMEDIA_SDP_EINSDP;
on_scanner_error(&scanner);
}
break;
}
}
ctx.last_error = PJ_SUCCESS;
}
PJ_CATCH(SYNTAX_ERROR) {
char errmsg[PJ_ERR_MSG_SIZE];
pj_strerror(ctx.last_error, errmsg, sizeof(errmsg));
PJ_LOG(4, (THIS_FILE, "Error parsing SDP in line %d col %d: %s",
scanner.line, pj_scan_get_col(&scanner),
errmsg));
session = NULL;
pj_assert(ctx.last_error != PJ_SUCCESS);
}
PJ_END;
pj_scan_fini(&scanner);
*p_sdp = session;
return ctx.last_error;
}
int main(int argc, char *argv[])
{
version_info v;
char legal_copyright[512];
char *buffer;
size_t size;
int opt;
FILE *f;
memset(&v, 0, sizeof(v));
build = BUILD_WINDOWS;
// validate parameters
opt = 1;
while (opt < argc && *argv[opt] == '-')
{
if (!strcmp(argv[opt], "-b"))
{
char *p = argv[++opt];
if (!strcmp(p,"windows"))
build = BUILD_WINDOWS;
else if (!strcmp(p,"winui"))
build = BUILD_WINUI;
else if (!strcmp(p,"mess"))
build = BUILD_MESS;
else
return usage(argv[0]);
}
else
return usage(argv[0]);
opt++;
}
if (opt != argc-1 )
{
return usage(argv[0]);
}
// open the file
f = fopen(argv[argc-1], "rb");
if (f == NULL)
{
fprintf(stderr, "Error opening file %s\n", argv[argc-1]);
return 1;
}
// get the file size
fseek(f, 0, SEEK_END);
size = ftell(f);
fseek(f, 0, SEEK_SET);
// allocate a buffer
buffer = (char *)malloc(size + 1);
if (buffer == NULL)
{
fclose(f);
fprintf(stderr, "Error allocating %ld bytes\n", (long) size + 1);
return 1;
}
// read the file contents and NULL-terminate
fread(buffer, 1, size, f);
fclose(f);
buffer[size] = 0;
// parse out version string
if (parse_version(buffer, &v.version_major, &v.version_minor, &v.version_build, &v.version_string))
{
fprintf(stderr, "Error parsing version from '%s'\n", buffer);
free(buffer);
return 1;
}
if (build == BUILD_MESS)
{
// MESS
v.author = "MESS Team";
v.comments = "Multi Emulation Super System";
v.company_name = "MESS Team";
v.file_description = "Multi Emulation Super System";
v.internal_name = "MESS";
v.original_filename = "MESS";
v.product_name = "MESS";
}
else if (build == BUILD_WINUI)
{
// MAMEUI
v.author = "Christopher Kirmse and the MAMEUI team";
v.comments = "Multiple Arcade Machine Emulator with GUI";
v.company_name = "MAME Team";
v.file_description = "Multiple Arcade Machine Emulator with GUI";
v.internal_name = "MAMEUI";
v.original_filename = "MAMEUI";
v.product_name = "MAMEUI";
}
else
{
// MAME
v.author = "Nicola Salmoria and the MAME Team";
v.comments = "Multiple Arcade Machine Emulator";
v.company_name = "MAME Team";
v.file_description = "Multiple Arcade Machine Emulator";
v.internal_name = "MAME";
v.original_filename = "MAME";
v.product_name = "MAME";
}
// build legal_copyright string
v.legal_copyright = legal_copyright;
snprintf(legal_copyright, ARRAY_LENGTH(legal_copyright), "Copyright Nicola Salmoria and the MAME team");
// emit the info
emit_version_info(&v);
free(buffer);
return 0;
}
void call_parse()
{
parse_version("fubar");
}
