static bool append_value(bson_t* bson, const char* key, size_t length, object_t* value) {
    switch (value->type) {
        case type_nil:    bson_append_null(bson, key, length);                       break; 
        case type_bool:   bson_append_bool(bson, key, length, value->b);             break; 
        case type_double: bson_append_double(bson, key, length, value->d);           break; 
        case type_str:    bson_append_utf8(bson, key, length, value->str, value->l); break; 

        case type_int:    append_int(bson, key, length, value->i);                   break; 
        case type_uint:   append_int(bson, key, length, (int64_t)value->u);          break;

        case type_map: {
            bson_t child;
            bson_append_document_begin(bson, key, length, &child);
            append_document(&child, value);
            bson_append_document_end(bson, &child);
        } break;

        case type_array: {
            bson_t child;
            bson_append_array_begin(bson, key, length, &child);
            append_array(&child, value);
            bson_append_array_end(bson, &child);
        } break;

        default:
            return false;
    }
    return true;
}
Example #2
0
/*----------------Set up to send to the laserwriter------------------------*/
void lw_laser_open(void)
{
extern int getpid(void);
	char pps[]=".eps";
	filnam=address;
	if(!filename_set) {
	    strcpy(filnam, "/tmp/.cg");
	    
	    append_int(getpid());
	    strcat(filnam, "-");
	    append_int(counter);
	    counter++;
	    filnam=strcat(filnam, pps);
	}
	if(useStandardOutput)
	    cgstream = stdout;			/* output to stdout */
	else
	    cgstream = fopen(filnam, "a");	/* open for append */
	if(cgstream == NULL) {
		fprintf(stderr, "Cannot open %s for PS output\n", filnam);
		return;
	}
	return;			/* successful file/device open */
	
}
void x264x_xlinkedx_xoptx_xo_storage_initializer_()
{
char buffer[1024];  char* ss;  sprintf(buffer, "call x264x_xlinkedx_xoptx_xo_storage_initializer_ ");
append_int(buffer,0); ADD_SPACE__(buffer);
append_int(buffer,0); ADD_SPACE__(buffer);
send_packet_and_wait_for_response(buffer,strlen(buffer)+1,"localhost",9999);
return;
}
void dct_engine()
{
char buffer[1024];  char* ss;  sprintf(buffer, "call dct_engine ");
append_int(buffer,0); ADD_SPACE__(buffer);
append_int(buffer,0); ADD_SPACE__(buffer);
send_packet_and_wait_for_response(buffer,strlen(buffer)+1,"localhost",9999);
return;
}
Example #5
0
static int build_csv_record(char *buf, size_t bufsize, struct cw_cdr *cdr)
{

	buf[0] = '\0';
	/* Account code */
	append_string(buf, cdr->accountcode, bufsize);
	/* Source */
	append_string(buf, cdr->src, bufsize);
	/* Destination */
	append_string(buf, cdr->dst, bufsize);
	/* Destination context */
	append_string(buf, cdr->dcontext, bufsize);
	/* Caller*ID */
	append_string(buf, cdr->clid, bufsize);
	/* Channel */
	append_string(buf, cdr->channel, bufsize);
	/* Destination Channel */
	append_string(buf, cdr->dstchannel, bufsize);
	/* Last Application */
	append_string(buf, cdr->lastapp, bufsize);
	/* Last Data */
	append_string(buf, cdr->lastdata, bufsize);
	/* Start Time */
	append_date(buf, cdr->start, bufsize);
	/* Answer Time */
	append_date(buf, cdr->answer, bufsize);
	/* End Time */
	append_date(buf, cdr->end, bufsize);
	/* Duration */
	append_int(buf, cdr->duration, bufsize);
	/* Billable seconds */
	append_int(buf, cdr->billsec, bufsize);
	/* Disposition */
	append_string(buf, cw_cdr_disp2str(cdr->disposition), bufsize);
	/* AMA Flags */
	append_string(buf, cw_cdr_flags2str(cdr->amaflags), bufsize);

#ifdef CSV_LOGUNIQUEID
	/* Unique ID */
	append_string(buf, cdr->uniqueid, bufsize);
#endif
#ifdef CSV_LOGUSERFIELD
	/* append the user field */
	append_string(buf, cdr->userfield,bufsize);	
#endif
	/* If we hit the end of our buffer, log an error */
	if (strlen(buf) < bufsize - 5) {
		/* Trim off trailing comma */
		buf[strlen(buf) - 1] = '\0';
		strncat(buf, "\n", bufsize - strlen(buf) - 1);
		return 0;
	}
	return -1;
}
Example #6
0
/* Return:  is the device_name (hostname) */
std::string	SQL_Devices::sql_find_preferred_name	( int mUser_id, std::string mPreferredName	)
{
    query_string =  "SELECT preferred_name,hostname FROM ";
    query_string += table_name;
    query_string += " WHERE ";
    query_string += " user_id=";
    query_string += append_int( mUser_id );
    query_string += " AND preferred_name='";
    query_string += mPreferredName;
    query_string += "';";
    int retval = query(true);

    // Now for all results, do the regex_search:
    goto_first_row();
    bool found=false;
    std::regex exp;    
    std::smatch match;
    while (m_row)
    {
    	if (m_row[0])  exp=m_row[0];
    	found = std::regex_search( mPreferredName, match, exp ); 
    	if (found)
    		return m_row[1];		// return device_name;
    	goto_next_row();
    }
    return NULL;
}
Example #7
0
// IN_ACCESS, IN_MODIFY, IN_CLOSE_NOWRITE, IN_OPEN, IN_DELETE, IN_DELETE_SELF
int add_watch(void* inotify, char* path) {
    int watch_fd = inotify_add_watch(((inotify_t*)inotify)->instance, path,
            /*IN_ATTRIB | */ IN_CLOSE_WRITE | IN_MOVED_FROM | IN_MOVED_TO |
            IN_CREATE | IN_DELETE);
    if (watch_fd == -1) {
        perror("inotify_add_watch");
        return -1;
    }
    append_int(&((inotify_t*)inotify)->watch_fds, watch_fd);
    append_str(&((inotify_t*)inotify)->files, path);
    return 0;
}
Example #8
0
int
main() {
    printf("auto-array test program\n");

    struct Integer_array my_array;

    create_int_array(&my_array, 4);

    for (int i=0; i<10; i++) {
        append_int(&my_array, 2*i);
    }

    print_array(&my_array);

    return 0;
}
Example #9
0
int	SQL_Devices::sql_find	( int mUser_id, std::string mDevice_name )
{
    query_string =  "SELECT * FROM ";
    query_string += table_name;
    query_string += " ";
    query_string += " WHERE hostname='";		// device_name is hostname
    query_string += mDevice_name;
    query_string += "' AND user_id=";
    query_string += append_int( mUser_id );
    query_string += ";";
    int retval = query(true);
    m_row = mysql_fetch_row( m_result );
    if (m_row)
	    _id = atoi(m_row[0]);
    printf("device_id = %d\n", _id );
    return retval;
}
Example #10
0
void test_devices_db()
{
    // Add some samples rows : 
    connect_to_users_db();
    
    std::string mRegex;
    int user_id = sql_users.sql_find("stenniswood");  
    printf("User_id=%d\n", user_id );
    sql_devices.get_all_device_names_regex ( user_id, mRegex );    


    Sentence phrase = "main TV";
    int result = phrase.regex_find( mRegex );
    printf("REGEX result: %d\n", result );
	if (result) {
		std::string tmp = phrase.m_sentence.regex_matches[1];    
		printf("REGEX MATCH: %s\n", tmp.c_str());
    }
    
    std::string tmp = "(";
	tmp += append_int( user_id );
    
    std::string tmp1 = tmp + ", 'successroad1', '(main TV|TV)', 'RPI')";
	std::string tmp2 = tmp + ", 'successroad2', '(bedroom TV)', 'RPI')";
	std::string tmp3 = tmp + ", 'portable', '(LCD pi)', 'RPI')";

//	sql_devices.sql_add_if_not_already(user_id, dev_info_map );
//	sql_devices.sql_add_if_not_already(user_id, "( user_id, device_name, preferred_name, device_type )", tmp1, "successroad1");
//	sql_devices.sql_add_if_not_already(user_id, "( user_id, device_name, preferred_name, device_type )", tmp2, "successroad2");
//	sql_devices.sql_add_if_not_already(user_id, "( user_id, device_name, preferred_name, device_type )", tmp3, "portable");
	
	sql_devices.sql_find( user_id,"successroad1" );	sql_devices.print_results();
	sql_devices.sql_find( user_id,"successroad2" );	sql_devices.print_results();
	sql_devices.sql_find( user_id,"portable" );	sql_devices.print_results();


	printf("Done with test_devices_db()\n");
}
Example #11
0
/*
 * Like 'vsprintf', but ensures the target is big enough, resizing if
 * necessary.
 */
void
archive_string_vsprintf(struct archive_string *as, const char *fmt,
    va_list ap)
{
	char long_flag;
	intmax_t s; /* Signed integer temp. */
	uintmax_t u; /* Unsigned integer temp. */
	const char *p, *p2;
	const wchar_t *pw;

	if (archive_string_ensure(as, 64) == NULL)
		__archive_errx(1, "Out of memory");

	if (fmt == NULL) {
		as->s[0] = 0;
		return;
	}

	for (p = fmt; *p != '\0'; p++) {
		const char *saved_p = p;

		if (*p != '%') {
			archive_strappend_char(as, *p);
			continue;
		}

		p++;

		long_flag = '\0';
		switch(*p) {
		case 'j':
		case 'l':
		case 'z':
			long_flag = *p;
			p++;
			break;
		}

		switch (*p) {
		case '%':
			archive_strappend_char(as, '%');
			break;
		case 'c':
			s = va_arg(ap, int);
			archive_strappend_char(as, (char)s);
			break;
		case 'd':
			switch(long_flag) {
			case 'j': s = va_arg(ap, intmax_t); break;
			case 'l': s = va_arg(ap, long); break;
			case 'z': s = va_arg(ap, ssize_t); break;
			default:  s = va_arg(ap, int); break;
			}
		        append_int(as, s, 10);
			break;
		case 's':
			switch(long_flag) {
			case 'l':
				pw = va_arg(ap, wchar_t *);
				if (pw == NULL)
					pw = L"(null)";
				if (archive_string_append_from_wcs(as, pw,
				    wcslen(pw)) != 0 && errno == ENOMEM)
					__archive_errx(1, "Out of memory");
				break;
			default:
				p2 = va_arg(ap, char *);
				if (p2 == NULL)
					p2 = "(null)";
				archive_strcat(as, p2);
				break;
			}
			break;
		case 'S':
			pw = va_arg(ap, wchar_t *);
			if (pw == NULL)
				pw = L"(null)";
			if (archive_string_append_from_wcs(as, pw,
			    wcslen(pw)) != 0 && errno == ENOMEM)
				__archive_errx(1, "Out of memory");
			break;
		case 'o': case 'u': case 'x': case 'X':
			/* Common handling for unsigned integer formats. */
			switch(long_flag) {
			case 'j': u = va_arg(ap, uintmax_t); break;
			case 'l': u = va_arg(ap, unsigned long); break;
			case 'z': u = va_arg(ap, size_t); break;
			default:  u = va_arg(ap, unsigned int); break;
			}
			/* Format it in the correct base. */
			switch (*p) {
			case 'o': append_uint(as, u, 8); break;
			case 'u': append_uint(as, u, 10); break;
			default: append_uint(as, u, 16); break;
			}
			break;
		default:
			/* Rewind and print the initial '%' literally. */
			p = saved_p;
			archive_strappend_char(as, *p);
		}
	}
}
Example #12
0
void MenuItem::load_size_options(int mSize_id, int mRestaurant_id)
{
    query_string = "select * from ";
    query_string += sql_global_knowledge_name;
    query_string += ".sizes_options WHERE size_id=";
    query_string += append_int(mSize_id);
    query_string += " and restaurant_id=";
    query_string += append_int(mRestaurant_id);
    query_string += ";";
    // restaurant = restaurant_id;  but we don't know the restaurant id.
    printf("%s\n", query_string.c_str() ); 
    query(true);
    int                 type=-1;
    PickOne             one;
    AdditionalToppings  top;
    SuperString         extra_cost;
    StandardOptions     standard;

    while ((row = mysql_fetch_row(result)) )
    {
        type = -1;
        if (row[6])
            type = atoi(row[6]);
        extra_cost = row[4];
        extra_cost.split(',');
        extra_cost.trim_spaces();
        
        switch(type)
        {
        case 0 :
                standard.name = row[3];
                standard.name.split(',');
                standard.name.trim_spaces();
                for (int i=0; i < standard.name.m_split_words.size(); i++)
                    standard.additional_cost[standard.name.m_split_words[i] ] = stof(extra_cost.m_split_words[i]); // .convert_to_float();
                
                if (row[5]) standard.comment = row[5];
                m_standard_toppings.push_back(standard);
                break;
        case 1 :
                one.name                = row[3];
                one.name.split_wordlist();    // "(small|medium|large)"  Want to do this because the prices will be a map based on these names.
                for (int i=0; i < standard.name.m_split_words.size(); i++)
                    one.additional_cost[one.name.m_split_words[i] ] = stof(extra_cost.m_split_words[i]); // .convert_to_float();
                if (row[5])
                    one.comment = row[5];
                m_required_options.push_back(one);
                break;
        case 2 :
                top.name = row[3];
                top.name.split(',');
                top.name.trim_spaces();
                for (int i=0; i < standard.name.m_split_words.size(); i++)
                    top.additional_cost[top.name.m_split_words[i]] = stof(extra_cost.m_split_words[i]); // convert_to_float();
                if (row[5]) top.comment = row[5];
                m_additional_toppings.push_back(top);
            break;
        default:
            break;
        }
    }
    mysql_free_result( result );
}
Example #13
0
static void xbt_log_layout_format_dynamic(xbt_log_layout_t l,
                                          xbt_log_event_t ev,
                                          const char *fmt,
                                          xbt_log_appender_t app)
{
  xbt_strbuff_t buff = xbt_strbuff_new();
  char tmpfmt[50];
  int precision = -1;
  int length = -1;
  char *q = l->data;
  char *tmp;
  char *tmp2;

  while (*q != '\0') {
    if (*q == '%') {
      q++;
    handle_modifier:
      switch (*q) {
      case '\0':
        fprintf(stderr, "Layout format (%s) ending with %%\n",
                (char *) l->data);
        abort();
      case '%':
        xbt_strbuff_append(buff, "%");
        break;
      case 'n':                /* platform-dependant line separator (LOG4J compliant) */
        xbt_strbuff_append(buff, "\n");
        break;
      case 'e':                /* plain space (SimGrid extension) */
        xbt_strbuff_append(buff, " ");
        break;

      case '.':                /* precision specifyier */
        q++;
        sscanf(q, "%d", &precision);
        q += (precision>9?2:1);
        goto handle_modifier;

      case '0':
      case '1':
      case '2':
      case '3':
      case '4':
      case '5':
      case '6':
      case '7':
      case '8':
      case '9': /* length modifier */
        sscanf(q, "%d", &length);
        q += (length>9?2:1);
        goto handle_modifier;

      case 'c':                /* category name; LOG4J compliant
                                   should accept a precision postfix to show the hierarchy */
        append_string(ev->cat->name);
        break;
      case 'p':                /* priority name; LOG4J compliant */
        append_string(xbt_log_priority_names[ev->priority]);
        break;

      case 'h':                /* host name; SimGrid extension */
        append_string(gras_os_myname());
        break;
      case 't':                /* thread name; LOG4J compliant */
        append_string(xbt_thread_self_name());
        break;
      case 'P':                /* process name; SimGrid extension */
        append_string(xbt_procname());
        break;
      case 'i':                /* process PID name; SimGrid extension */
        append_int((*xbt_getpid) ());
        break;

      case 'F':                /* file name; LOG4J compliant */
        append_string(ev->fileName);
        break;
      case 'l':                /* location; LOG4J compliant */
        append2("%s:%d", ev->fileName, ev->lineNum);
        precision = -1;         /* Ignored */
        break;
      case 'L':                /* line number; LOG4J compliant */
        append_int(ev->lineNum);
        break;
      case 'M':                /* method (ie, function) name; LOG4J compliant */
        append_string(ev->functionName);
        break;
      case 'b':                /* backtrace; called %throwable in LOG4J */
      case 'B':                /* short backtrace; called %throwable{short} in LOG4J */
#if defined(HAVE_EXECINFO_H) && defined(HAVE_POPEN) && defined(ADDR2LINE)
        {
          xbt_ex_t e;
          int i;

          e.used = backtrace((void **) e.bt, XBT_BACKTRACE_SIZE);
          e.bt_strings = NULL;
          e.msg = NULL;
          e.remote = 0;
          xbt_backtrace_current(&e);
          if (*q == 'B') {
            append_string(e.bt_strings[2] + 8);
          } else {
            for (i = 2; i < e.used; i++) {
              append_string(e.bt_strings[i] + 8);
              xbt_strbuff_append(buff, "\n");
            }
          }

          xbt_ex_free(e);
        }
#else
        append_string("(no backtrace on this arch)");
#endif
        break;

      case 'd':                /* date; LOG4J compliant */
        append_double(gras_os_time());
        break;
      case 'r':                /* application age; LOG4J compliant */
        append_double(gras_os_time() - format_begin_of_time);
        break;

      case 'm':                /* user-provided message; LOG4J compliant */
        tmp2 = bvprintf(fmt, ev->ap_copy);
        append_string(tmp2);
        free(tmp2);
        break;

      default:
        fprintf(stderr, ERRMSG, *q, (char *) l->data);
        abort();
      }
      q++;
    } else {
      char tmp2[2];
      tmp2[0] = *(q++);
      tmp2[1] = '\0';
      xbt_strbuff_append(buff, tmp2);
    }
  }
  app->do_append(app, buff->data);
  xbt_strbuff_free(buff);
}
Example #14
0
z_string & z_string::operator << (const int i)
{
    return append_int(i);
}