static void get_tuples(int iatm, const struct mod_structure *struc,
const struct mod_sequence *seq,
const struct mdt_atom_class_list *atclass,
GArray *tlist, const struct mod_libraries *libs)
{
int iclass, *iresatm, *irestyp, ir1;
char *resnam;
iresatm = mod_int1_pt(&struc->cd.iresatm);
irestyp = mod_int1_pt(&seq->irestyp);
ir1 = iresatm[iatm] - 1;
resnam = mod_residue_name_from_type(irestyp[ir1], libs);
for (iclass = 0; iclass < atclass->nclass; iclass++) {
int itype;
struct mdt_atom_class *c = &atclass->classes[iclass];
for (itype = 0; itype < c->ntypes; itype++) {
struct mdt_atom_type *t = &c->types[itype];
/* Does the residue type match? */
if (strcmp(resnam, t->names[0]) == 0 || strcmp(t->names[0], "*") == 0) {
char *atmnam = mod_coordinates_atmnam_get(&struc->cd, iatm);
/* Does the lead atom type match? */
if (strcmp(atmnam, t->names[1]) == 0) {
add_tuple(&struc->cd, seq, t, iatm, ir1, iclass, atclass->natom,
irestyp, libs, tlist);
}
g_free(atmnam);
}
}
}
g_free(resnam);
}
static reach_type_t* add_type(reach_t* r, ast_t* type, pass_opt_t* opt)
{
switch(ast_id(type))
{
case TK_UNIONTYPE:
case TK_ISECTTYPE:
return add_isect_or_union(r, type, opt);
case TK_TUPLETYPE:
return add_tuple(r, type, opt);
case TK_NOMINAL:
return add_nominal(r, type, opt);
default:
assert(0);
}
return NULL;
}
static reachable_type_t* add_type(reachable_method_stack_t** s,
reachable_types_t* r, uint32_t* next_type_id, ast_t* type)
{
switch(ast_id(type))
{
case TK_UNIONTYPE:
case TK_ISECTTYPE:
return add_isect_or_union(s, r, next_type_id, type);
case TK_TUPLETYPE:
return add_tuple(s, r, next_type_id, type);
case TK_NOMINAL:
return add_nominal(s, r, next_type_id, type);
default:
assert(0);
}
return NULL;
}
int main( int argc, const char **argv )
{
int i;
int status;
int fFound;
CHAINTYPE *chain;
fDumpAll = FALSE;
DecodeCommandLine( argc, argv );
fSyntaxError = FALSE;
//
// Initialize some of our list pointers
//
cursect = headsect = 0;
curchain = headchain = tailchain = 0;
tailtuple = headtuple = 0;
for( i = 0; i < NUM_WORKSTATION_ID; i++ ){
aWorkstationId[i] = 0L;
}
if( sHostName[0] ){
aWorkstationId[0] = (char *)malloc(strlen(sHostName)+1);
strcpy(aWorkstationId[0],sHostName);
}
else{
// Get the hostname from the system
uname(&unamebuf);
aWorkstationId[0] = (char *)malloc(strlen(unamebuf.nodename)+1);
strcpy(aWorkstationId[0],unamebuf.nodename);
// Get the
GetAddrs();
aWorkstationId[1] = (char *)malloc(strlen(sIPAddr)+1);
strcpy(aWorkstationId[1],sIPAddr);
aWorkstationId[2] = (char *)malloc(strlen(sMACAddr)+1);
strcpy(aWorkstationId[2],sMACAddr);
}
// treat the main config file just like any other include
if(parseConfig(sConfigFile) != 0) {
char buf[255];
sprintf(buf,"Error opening config file [%s]", sConfigFile);
perror(buf);
exit(2);
}
lineno = 1;
yyparse();
//
// When the parsing is complete, we have a tree in memory
// that contains ALL of the sections with all of the values.
//
//
// The next step is to find the section that matches the workstation
// that we are interested in. Then, walk through the linked list
// looking for any entries that indicate we want to "inherit" entries
// from another section. We'll build a new linked list of those
// sections that we want to inherit from. Then, we'll tack any wildcard matches
// and the 'Default' section on the end of that. Once we have the inheritance list, we
// need to walk that list backwards, building the list of
// tuples (keyword/value pairs).
// Finally, when we are all done, we should have all of the values that
// should go with the workstation we are interested in. So, we
// either dump all of the entries out, or we dump out a single entry.
// This is dependent on whether this program was called with the
// '-a' option or not.
//
//
// Find the entry that exactly matches our workstation.
//
i = 0;
fFound = FALSE;
while( aWorkstationId[i] && !fFound ){
if(find_chain_entry(aWorkstationId[i], FALSE)){
fFound = TRUE;
}
i++;
}
chain = headchain;
while(chain){
curtuple = chain->sect->tuple_list;
while(curtuple){
if(strcasecmp(curtuple->keyword,"LIKE") == 0)
status = find_chain_entry(curtuple->value, FALSE);
curtuple = curtuple->next;
}
chain = chain->next;
}
for (i=0; aWorkstationId[i]; ++i){
if((status = find_chain_entry(aWorkstationId[i], TRUE))){
chain = headchain;
while(chain){
curtuple = chain->sect->tuple_list;
while(curtuple){
if(strcasecmp(curtuple->keyword,"LIKE") == 0)
status = find_chain_entry(curtuple->value, FALSE);
curtuple = curtuple->next;
}
chain = chain->next;
}
}
}
//
// the last entry in the chain is the '[Default]' entry
//
status = find_chain_entry("default", FALSE);
curchain = tailchain;
while(curchain){
curtuple = curchain->sect->tuple_list;
while(curtuple){
if(strcasecmp(curtuple->keyword,"LIKE") != 0)
add_tuple(curtuple);
curtuple = curtuple->next;
}
curchain = curchain->prev;
}
if(fDumpAll){
//
// Spit out all of the variables for this workstation
//
curtuple = headtuple;
while(curtuple){
char *p = curtuple->keyword;
while(*p){
*p = toupper(*p);
p++;
}
if(strcasecmp(curtuple->value,"NONE") != 0){
printf("%s=\"%s\"\n", curtuple->keyword, curtuple->value);
}
curtuple = curtuple->next;
}
curtuple = headtuple;
while(curtuple){
if(strcasecmp(curtuple->value,"NONE") != 0){
printf("export %s\n", curtuple->keyword);
}
curtuple = curtuple->next;
}
}
else{
//
// Dump just one var
//
int fFound = FALSE;
curtuple = headtuple;
while(curtuple && !fFound ){
if(strcasecmp(curtuple->keyword,pOptionName) == 0){
if(strcasecmp(curtuple->value,"NONE") != 0){
printf("%s\n", curtuple->value);
}
fFound = TRUE;
}
curtuple = curtuple->next;
}
}
return(0);
}
G_MODULE_EXPORT gboolean
tracker_extract_get_metadata (TrackerExtractInfo *info)
{
FLAC__Metadata_SimpleIterator *iter;
FLAC__StreamMetadata *stream = NULL, *vorbis, *picture;
FLAC__bool success;
FlacData fd = { 0 };
TrackerSparqlBuilder *preupdate, *metadata;
gchar *filename, *uri, *artist_uri = NULL, *album_uri = NULL;
const gchar *creator;
GFile *file;
goffset size;
const gchar *graph;
graph = tracker_extract_info_get_graph (info);
preupdate = tracker_extract_info_get_preupdate_builder (info);
metadata = tracker_extract_info_get_metadata_builder (info);
file = tracker_extract_info_get_file (info);
filename = g_file_get_path (file);
size = tracker_file_get_size (filename);
if (size < 18) {
g_free (filename);
return FALSE;
}
iter = FLAC__metadata_simple_iterator_new ();
success = FLAC__metadata_simple_iterator_init (iter, filename, TRUE, TRUE);
g_free (filename);
if (!success) {
FLAC__metadata_simple_iterator_delete (iter);
return FALSE;
}
uri = g_file_get_uri (file);
do {
switch (FLAC__metadata_simple_iterator_get_block_type (iter)) {
case FLAC__METADATA_TYPE_STREAMINFO:
stream = FLAC__metadata_simple_iterator_get_block (iter);
break;
case FLAC__METADATA_TYPE_VORBIS_COMMENT:
vorbis = FLAC__metadata_simple_iterator_get_block (iter);
parse_vorbis_comments (&(vorbis->data.vorbis_comment), &fd);
FLAC__metadata_object_delete (vorbis);
break;
case FLAC__METADATA_TYPE_PICTURE:
picture = FLAC__metadata_simple_iterator_get_block (iter);
/* Deal with picture */
FLAC__metadata_object_delete (picture);
break;
default:
break;
}
} while (FLAC__metadata_simple_iterator_next (iter));
creator = tracker_coalesce_strip (3, fd.artist, fd.albumartist,
fd.performer);
if (creator) {
artist_uri = tracker_sparql_escape_uri_printf ("urn:artist:%s", creator);
tracker_sparql_builder_insert_open (preupdate, NULL);
if (graph) {
tracker_sparql_builder_graph_open (preupdate, graph);
}
tracker_sparql_builder_subject_iri (preupdate, artist_uri);
tracker_sparql_builder_predicate (preupdate, "a");
tracker_sparql_builder_object (preupdate, "nmm:Artist");
tracker_sparql_builder_predicate (preupdate, "nmm:artistName");
tracker_sparql_builder_object_unvalidated (preupdate, creator);
if (graph) {
tracker_sparql_builder_graph_close (preupdate);
}
tracker_sparql_builder_insert_close (preupdate);
}
if (fd.album) {
if (fd.albumartist) {
album_uri = tracker_sparql_escape_uri_printf ("urn:album:%s:%s", fd.album, fd.albumartist);
} else {
album_uri = tracker_sparql_escape_uri_printf ("urn:album:%s", fd.album);
}
tracker_sparql_builder_insert_open (preupdate, NULL);
if (graph) {
tracker_sparql_builder_graph_open (preupdate, graph);
}
tracker_sparql_builder_subject_iri (preupdate, album_uri);
tracker_sparql_builder_predicate (preupdate, "a");
tracker_sparql_builder_object (preupdate, "nmm:MusicAlbum");
/* FIXME: nmm:albumTitle is now deprecated
* tracker_sparql_builder_predicate (preupdate, "nie:title");
*/
tracker_sparql_builder_predicate (preupdate, "nmm:albumTitle");
tracker_sparql_builder_object_unvalidated (preupdate, fd.album);
if (graph) {
tracker_sparql_builder_graph_close (preupdate);
}
tracker_sparql_builder_insert_close (preupdate);
if (fd.trackcount) {
tracker_sparql_builder_delete_open (preupdate, NULL);
tracker_sparql_builder_subject_iri (preupdate, album_uri);
tracker_sparql_builder_predicate (preupdate, "nmm:albumTrackCount");
tracker_sparql_builder_object_variable (preupdate, "unknown");
tracker_sparql_builder_delete_close (preupdate);
tracker_sparql_builder_where_open (preupdate);
tracker_sparql_builder_subject_iri (preupdate, album_uri);
tracker_sparql_builder_predicate (preupdate, "nmm:albumTrackCount");
tracker_sparql_builder_object_variable (preupdate, "unknown");
tracker_sparql_builder_where_close (preupdate);
tracker_sparql_builder_insert_open (preupdate, NULL);
if (graph) {
tracker_sparql_builder_graph_open (preupdate, graph);
}
tracker_sparql_builder_subject_iri (preupdate, album_uri);
tracker_sparql_builder_predicate (preupdate, "nmm:albumTrackCount");
tracker_sparql_builder_object_unvalidated (preupdate, fd.trackcount);
if (graph) {
tracker_sparql_builder_graph_close (preupdate);
}
tracker_sparql_builder_insert_close (preupdate);
}
if (fd.albumgain) {
tracker_sparql_builder_delete_open (preupdate, NULL);
tracker_sparql_builder_subject_iri (preupdate, album_uri);
tracker_sparql_builder_predicate (preupdate, "nmm:albumGain");
tracker_sparql_builder_object_variable (preupdate, "unknown");
tracker_sparql_builder_delete_close (preupdate);
tracker_sparql_builder_where_open (preupdate);
tracker_sparql_builder_subject_iri (preupdate, album_uri);
tracker_sparql_builder_predicate (preupdate, "nmm:albumGain");
tracker_sparql_builder_object_variable (preupdate, "unknown");
tracker_sparql_builder_where_close (preupdate);
tracker_sparql_builder_insert_open (preupdate, NULL);
if (graph) {
tracker_sparql_builder_graph_open (preupdate, graph);
}
tracker_sparql_builder_subject_iri (preupdate, album_uri);
tracker_sparql_builder_predicate (preupdate, "nmm:albumGain");
tracker_sparql_builder_object_double (preupdate, atof (fd.albumgain));
if (graph) {
tracker_sparql_builder_graph_close (preupdate);
}
tracker_sparql_builder_insert_close (preupdate);
}
if (fd.albumpeakgain) {
tracker_sparql_builder_delete_open (preupdate, NULL);
tracker_sparql_builder_subject_iri (preupdate, album_uri);
tracker_sparql_builder_predicate (preupdate, "nmm:albumPeakGain");
tracker_sparql_builder_object_variable (preupdate, "unknown");
tracker_sparql_builder_delete_close (preupdate);
tracker_sparql_builder_where_open (preupdate);
tracker_sparql_builder_subject_iri (preupdate, album_uri);
tracker_sparql_builder_predicate (preupdate, "nmm:albumPeakGain");
tracker_sparql_builder_object_variable (preupdate, "unknown");
tracker_sparql_builder_where_close (preupdate);
tracker_sparql_builder_insert_open (preupdate, NULL);
if (graph) {
tracker_sparql_builder_graph_open (preupdate, graph);
}
tracker_sparql_builder_subject_iri (preupdate, album_uri);
tracker_sparql_builder_predicate (preupdate, "nmm:albumPeakGain");
tracker_sparql_builder_object_double (preupdate, atof (fd.albumpeakgain));
if (graph) {
tracker_sparql_builder_graph_close (preupdate);
}
tracker_sparql_builder_insert_close (preupdate);
}
}
tracker_sparql_builder_predicate (metadata, "a");
tracker_sparql_builder_object (metadata, "nmm:MusicPiece");
tracker_sparql_builder_object (metadata, "nfo:Audio");
add_tuple (metadata, "nmm:performer", artist_uri);
g_free (artist_uri);
add_tuple (metadata, "nmm:musicAlbum", album_uri);
tracker_guarantee_title_from_file (metadata, "nie:title", fd.title, uri, NULL);
add_tuple (metadata, "nmm:trackNumber", fd.tracknumber);
if (fd.album && album_uri) {
gchar *album_disc_uri;
if (fd.albumartist) {
album_disc_uri = tracker_sparql_escape_uri_printf ("urn:album-disc:%s:%s:Disc%d",
fd.album, fd.albumartist,
fd.discno ? atoi(fd.discno) : 1);
} else {
album_disc_uri = tracker_sparql_escape_uri_printf ("urn:album-disc:%s:Disc%d",
fd.album,
fd.discno ? atoi(fd.discno) : 1);
}
tracker_sparql_builder_delete_open (preupdate, NULL);
tracker_sparql_builder_subject_iri (preupdate, album_disc_uri);
tracker_sparql_builder_predicate (preupdate, "nmm:setNumber");
tracker_sparql_builder_object_variable (preupdate, "unknown");
tracker_sparql_builder_delete_close (preupdate);
tracker_sparql_builder_where_open (preupdate);
tracker_sparql_builder_subject_iri (preupdate, album_disc_uri);
tracker_sparql_builder_predicate (preupdate, "nmm:setNumber");
tracker_sparql_builder_object_variable (preupdate, "unknown");
tracker_sparql_builder_where_close (preupdate);
tracker_sparql_builder_delete_open (preupdate, NULL);
tracker_sparql_builder_subject_iri (preupdate, album_disc_uri);
tracker_sparql_builder_predicate (preupdate, "nmm:albumDiscAlbum");
tracker_sparql_builder_object_variable (preupdate, "unknown");
tracker_sparql_builder_delete_close (preupdate);
tracker_sparql_builder_where_open (preupdate);
tracker_sparql_builder_subject_iri (preupdate, album_disc_uri);
tracker_sparql_builder_predicate (preupdate, "nmm:albumDiscAlbum");
tracker_sparql_builder_object_variable (preupdate, "unknown");
tracker_sparql_builder_where_close (preupdate);
tracker_sparql_builder_insert_open (preupdate, NULL);
if (graph) {
tracker_sparql_builder_graph_open (preupdate, graph);
}
tracker_sparql_builder_subject_iri (preupdate, album_disc_uri);
tracker_sparql_builder_predicate (preupdate, "a");
tracker_sparql_builder_object (preupdate, "nmm:MusicAlbumDisc");
tracker_sparql_builder_predicate (preupdate, "nmm:setNumber");
tracker_sparql_builder_object_int64 (preupdate, fd.discno ? atoi (fd.discno) : 1);
tracker_sparql_builder_predicate (preupdate, "nmm:albumDiscAlbum");
tracker_sparql_builder_object_iri (preupdate, album_uri);
if (graph) {
tracker_sparql_builder_graph_close (preupdate);
}
tracker_sparql_builder_insert_close (preupdate);
tracker_sparql_builder_predicate (metadata, "nmm:musicAlbumDisc");
tracker_sparql_builder_object_iri (metadata, album_disc_uri);
g_free (album_disc_uri);
}
g_free (album_uri);
/* FIXME: Trackgain/Trackpeakgain: commented out in vorbis */
add_tuple (metadata, "nie:comment", fd.comment);
add_tuple (metadata, "nie:contentCreated", fd.date);
add_tuple (metadata, "nfo:genre", fd.genre);
add_tuple (metadata, "nie:plainTextContent", fd.lyrics);
add_tuple (metadata, "nie:copyright", fd.copyright);
add_tuple (metadata, "nie:license", fd.license);
if (fd.publisher) {
tracker_sparql_builder_predicate (metadata, "dc:publisher");
tracker_sparql_builder_object_blank_open (metadata);
tracker_sparql_builder_predicate (metadata, "a");
tracker_sparql_builder_object (metadata, "nco:Contact");
tracker_sparql_builder_predicate (metadata, "nco:fullname");
tracker_sparql_builder_object_unvalidated (metadata,
fd.publisher);
tracker_sparql_builder_object_blank_close (metadata);
}
if (stream) {
tracker_sparql_builder_predicate (metadata, "nfo:sampleRate");
tracker_sparql_builder_object_int64 (metadata,
stream->data.stream_info.sample_rate);
tracker_sparql_builder_predicate (metadata, "nfo:channels");
tracker_sparql_builder_object_int64 (metadata,
stream->data.stream_info.channels);
tracker_sparql_builder_predicate (metadata,
"nfo:averageBitrate");
tracker_sparql_builder_object_int64 (metadata,
stream->data.stream_info.bits_per_sample);
tracker_sparql_builder_predicate (metadata, "nfo:duration");
tracker_sparql_builder_object_int64 (metadata,
stream->data.stream_info.total_samples /
stream->data.stream_info.sample_rate);
}
g_free (fd.artist);
g_free (fd.album);
g_free (fd.albumartist);
g_free (fd.performer);
g_free (fd.title);
g_free (fd.trackcount);
g_free (fd.tracknumber);
g_free (fd.discno);
g_free (fd.trackgain);
g_free (fd.trackpeakgain);
g_free (fd.albumgain);
g_free (fd.albumpeakgain);
g_free (fd.date);
g_free (fd.comment);
g_free (fd.genre);
g_free (fd.mbalbumid);
g_free (fd.mbartistid);
g_free (fd.mbalbumartistid);
g_free (fd.mbtrackid);
g_free (fd.lyrics);
g_free (fd.copyright);
g_free (fd.license);
g_free (fd.organisation);
g_free (fd.location);
g_free (fd.publisher);
g_free (uri);
return TRUE;
}
