Example #1
0
static bool find_module_file(const char* module_name, caValue* filenameOut)
{
    Value module;
    set_string(&module, module_name);

    int count = list_length(&g_moduleSearchPaths);
    for (int i=0; i < count; i++) {

        // For each search path we'll check two places.

        // Look under searchPath/moduleName.ca
        Value searchPath;
        copy(g_moduleSearchPaths[i], &searchPath);
        circa_join_path(&searchPath, &module);
        string_append(&searchPath, ".ca");

        if (circa_file_exists(as_cstring(&searchPath))) {
            swap(&searchPath, filenameOut);
            return true;
        }

        // Look under searchPath/moduleName/moduleName.ca
        copy(g_moduleSearchPaths[i], &searchPath);

        circa_join_path(&searchPath, &module);
        circa_join_path(&searchPath, &module);
        string_append(&searchPath, ".ca");

        if (circa_file_exists(as_cstring(&searchPath))) {
            swap(&searchPath, filenameOut);
            return true;
        }
    }
    return false;
}
Example #2
0
void cmd_write (uint64_t cluster, uint8_t adcport, uint64_t maxsize, uint8_t speed)
{
	uart_puts_P("Writing...\r\n");

	uint16_t maxblocks = maxsize / 512;
	uint16_t block = 0;
	char c = 0x00;
	while(c != 'q')
	{
		char values[512] = {0x00};
		for (uint16_t i = 0; i<=80; ++i)
		{
			adc_request(adcport);
			uint16_t adcvalue = adc_read();
			string_append(values, num2str(adcvalue, 10));
			string_append(values, "\r\n");
			for (uint8_t d = 0; d<=speed; ++d)
				_delay_ms(3);

			uart_puts(num2str(i, 10));
			uart_puts(": ");
			uart_puts(num2str(adcvalue, 10));
			uart_puts("\r\n");
			c = uart_getc();
			if (c == 'q') break;
		}
		fat_write_file(cluster, (unsigned char*)values, block);
		++block;
		if (block >= maxblocks) break;
	}

	uart_puts_P("...done\r\n");
}
void inicializar_panel(t_tipo_proceso tipo_proceso, char* path){
	char* tipo_proceso_str;

	if (tipo_proceso == KERNEL)
		tipo_proceso_str = "kernel";
	else if (tipo_proceso == CPU)
		tipo_proceso_str = "cpu";
	else
		tipo_proceso_str = "?";

	proceso_tipo = tipo_proceso;

	char* logFile = string_duplicate(path);
	string_append(&logFile, tipo_proceso_str);
	string_append(&logFile, ".log");

	remove(logFile);
	logger = log_create(logFile, tipo_proceso_str, true, LOG_LEVEL_INFO);

	log_info(logger, "Inicializando panel para %s, en \"%s\"", tipo_proceso_str, logFile);

	free(logFile);

	kernel_cpus_conectadas = list_create();
	kernel_consolas_conectadas = list_create();
}
Example #4
0
File: Oauth.c Project: bomma/io
static void build_signature(struct signctx *senv, const char *method, const char *consumerSecret, const char *tokenSecret)
{
	struct signature_param *sp;
	const size_t nParams = vector_size(&senv->signatureParams);
	uint32_t i;
	uint8_t digest[20];

	qsort(vector_values(&senv->signatureParams), vector_size(&senv->signatureParams), senv->signatureParams.item_size, bySignatureParamName);
	string_append(&senv->signatureSeed, "&", 1);

	if (nParams)
	{
		i = 0;
		do
		{
			sp = (struct signature_param *)vector_value(&senv->signatureParams, i);
			string_appendfmt(&senv->signatureSeed, "%s%%3D", sp->name);
			string_append_urlencoded_rfc3986(&senv->signatureSeed, sp->value, sp->len);
			string_append(&senv->signatureSeed, "%26", 3);

		} while (++i != nParams);
		string_adjustlen(&senv->signatureSeed, 3);
	}


	char _k[256];
	const size_t keyLen = sprintf(_k, "%s&%s", consumerSecret, tokenSecret);

	string_reset(&senv->signatureParamsBuf);
	hmac((uint8_t *)_k, keyLen, (uint8_t *)string_data(&senv->signatureSeed), string_len(&senv->signatureSeed), digest);
	base64_encode(digest, 20, &senv->signatureParamsBuf, 0);
}
Example #5
0
void logearOrdenReduce(char* nombre){

	t_log_level nivel;

	t_log* archivoDeLog;

	nivel = LOG_LEVEL_INFO;

	archivoDeLog = log_create("LogNodo", "Nodo", 0, nivel);

		 char *unaPalabra = string_new();

		 string_append(&unaPalabra, "Solicitud de Reduce con el script ");

		 string_append(&unaPalabra, nombre);






		log_info(archivoDeLog,unaPalabra);

		free(unaPalabra);
		log_destroy(archivoDeLog);

}
//Devuelve un num positivo o Devuelve 0 si hay error
int getCantidadDeCopiasDe1Bloque_ArchivoDB(const bson_t * documento_X, int numBloque)
{
    bson_iter_t punteroDeBusqueda;
    bson_iter_t valorEncontrado;
    int CantidadDeCopias = 0;

    char *claveGenerada = string_new();

		string_append(&claveGenerada, "Bloques");
    		string_append(&claveGenerada, ".");
		string_append(&claveGenerada, string_itoa(numBloque));
			string_append(&claveGenerada, ".");
		string_append(&claveGenerada, "cantidadDeCopias");

    if (documento_X != NULL &&
        bson_iter_init (&punteroDeBusqueda, documento_X) &&
        bson_iter_find_descendant (&punteroDeBusqueda, claveGenerada, &valorEncontrado) &&
        BSON_ITER_HOLDS_INT32 (&valorEncontrado))
    {
        CantidadDeCopias = bson_iter_int32 (&valorEncontrado);
    }

    free(claveGenerada);

    return CantidadDeCopias;
}
Example #7
0
static void import_base_rule( void * r_, void * d_ )
{
    RULE * r = (RULE *)r_;
    RULE * ir1;
    RULE * ir2;
    struct import_base_data * d = (struct import_base_data *)d_;
    string qualified_name[ 1 ];
    OBJECT * qname;

    string_new      ( qualified_name               );
    string_append   ( qualified_name, object_str( d->base_name ) );
    string_push_back( qualified_name, '.'          );
    string_append   ( qualified_name, object_str( r->name ) );

    qname = object_new( qualified_name->value );

    ir1 = import_rule( r, d->class_module, r->name );
    ir2 = import_rule( r, d->class_module, qname );

    object_free( qname );

    /* Copy 'exported' flag. */
    ir1->exported = ir2->exported = r->exported;

    /* If we are importing a class method, localize it. */
    if ( ( r->module == d->base_module ) || ( r->module->class_module &&
        ( r->module->class_module == d->base_module ) ) )
    {
        rule_localize( ir1, d->class_module );
        rule_localize( ir2, d->class_module );
    }

    string_free( qualified_name );
}
Example #8
0
caValue* selector_advance(caValue* value, caValue* selectorElement, caValue* error)
{
    if (is_int(selectorElement)) {
        int selectorIndex = as_int(selectorElement);

        if (!is_list(value)) {
            set_error_string(error, "Value is not indexable: ");
            string_append_quoted(error, value);
            return NULL;
        }

        if (selectorIndex >= list_length(value)) {
            set_error_string(error, "Index ");
            string_append(error, selectorIndex);
            string_append(error, " is out of range");
            return NULL;
        }

        return get_index(value, selectorIndex);
    }
    else if (is_string(selectorElement)) {
        caValue* field = get_field(value, as_cstring(selectorElement));
        if (field == NULL) {
            set_error_string(error, "Field not found: ");
            string_append(error, selectorElement);
            return NULL;
        }
        return field;
    } else {
        set_error_string(error, "Unrecognized selector element: ");
        string_append_quoted(error, selectorElement);
        return NULL;
    }
}
Example #9
0
void join_path(Value* left, Value* right)
{
    const char* leftStr = as_cstring(left);
    const char* rightStr = as_cstring(right);
    int left_len = (int) strlen(leftStr);
    int right_len = (int) strlen(leftStr);

    if (string_equals(left, "") || string_equals(left, ".")) {
        copy(right, left);
        return;
    }

    if (string_equals(right, ""))
        return;

    int seperatorCount = 0;
    if (left_len > 0 && is_path_seperator(leftStr[left_len-1]))
        seperatorCount++;

    if (right_len > 0 && is_path_seperator(rightStr[0]))
        seperatorCount++;

    if (seperatorCount == 2)
        string_resize(left, left_len - 1);
    else if (seperatorCount == 0)
        string_append(left, "/");

    string_append(left, right);
}
Example #10
0
void get_path_relative_to_source(caBlock* relativeTo, Value* relPath, Value* result)
{
    if (relativeTo == NULL) {
        copy(relPath, result);
        return;
    }

    // Don't modify absolute paths
    if (is_absolute_path(relPath)) {
        copy(relPath, result);
        return;
    }

    Value scriptLocation;
    get_source_file_location(relativeTo, &scriptLocation);

    if (string_equals(&scriptLocation, "") || string_equals(&scriptLocation, ".")) {
        set_value(result, relPath);
        return;
    }

    set_value(result, &scriptLocation);

    if (!string_equals(relPath,"")) {
        string_append(result, "/");
        string_append(result, relPath);
    }

}
void imprimirLista(char* nivel, t_list* rdy, t_list* blk, int cont) {
	char* tmp = malloc(20);
	char* retorno = malloc(500);
	int i;

	personaje_t* levantador;
	if (list_size(rdy) == 0 || cont < 0) { //Si no hay nadie listo, no se quien esta ejecutando
		sprintf(retorno, "Lista de: %s\n\tEjecutando:\n\tListos: \t", nivel);
	} else {
		levantador = list_get(rdy, cont);
		sprintf(retorno, "Lista de: %s\n\tEjecutando: %c\n\tListos: \t", nivel, levantador->name);
	}
	for (i = 0; i < list_size(rdy); i++) {
		levantador = list_get(rdy, i);
		sprintf(tmp, "%c -> ", levantador->name);
		string_append(&retorno, tmp);
	}
	sprintf(tmp, "\n\tBloqueados: \t");
	string_append(&retorno, tmp);
	for (i = 0; i < list_size(blk); i++) {
		levantador = list_get(blk, i);
		sprintf(tmp, "%c -> ", levantador->name);
		string_append(&retorno, tmp);
	}

	log_info(logger, retorno);
	free(tmp);
	free(retorno);
}
Example #12
0
File: cpp.c Project: rui314/8cc-old
/*
 * Join tokens in a given list.  If sep is true, a space is put
 * between tokens.  If false, no separator.
 */
static String *join_tokens(List *arg, bool sep) {
    String *s = make_string();
    for (int i = 0; i < LIST_LEN(arg); i++) {
        Token *tok = LIST_REF(arg, i);
        if (sep && STRING_LEN(s) && tok->space)
            o1(s, ' ');
        switch (tok->toktype) {
        case TOKTYPE_IDENT:
        case TOKTYPE_CPPNUM:
            string_append(s, STRING_BODY(tok->val.str));
            break;
        case TOKTYPE_PUNCT:
            string_append(s, token_to_string(tok));
            break;
        case TOKTYPE_CHAR: {
            // TODO: retain original spelling
            o1(s, '\'');
            stringize_char(s, tok->val.i, '\'');
            string_append(s, "\'");
            break;
        }
        case TOKTYPE_STRING: {
            o1(s, '"');
            for (char *p = STRING_BODY(tok->val.str); *p; p++)
                stringize_char(s, *p, '\"');
            string_append(s, "\"");
            break;
        }
        default:
            panic("invalid token type: %d", tok->toktype);
        }
    }
    return s;
}
Example #13
0
static String* create_json(String* content, Project* project, Message* message, List* elements, List* element_types)
{
    Iterator* it;
    String* base_url_a = string_new();
    base_url_a = get_base_url(base_url_a);
    string_appendf(content, "{project:{name: \"%s\"}, ticket:{id: %d, url: \"%s/%s/ticket/%d\",fields:[",
            string_rawstr(project->name),
            message->id,
            string_rawstr(base_url_a),
            g_project_code_4_url,
            message->id);
    string_free(base_url_a);
    foreach (it, element_types) {
        ElementType* et = it->element;
        String* field_a = string_new();
        String* name_a = string_new();
        String* value_a = string_new();
        string_append(name_a, string_rawstr(et->name));
        escape_quot(name_a);
        string_append(value_a, get_element_value(elements, et));
        escape_quot(value_a);
        string_appendf(field_a, "{name:\"%s\", value:\"%s\"}",
                string_rawstr(name_a),
                string_rawstr(value_a));
        string_free(name_a);
        string_free(value_a);
        string_append(content, string_rawstr(field_a));
        string_free(field_a);
        if (iterator_next(it)) string_append(content, ",");
    }
char * posicionToString(t_posicion * posicion){
	char * pos = string_new();
	string_append(&pos, string_from_format("%d",posicion->posX));
	string_append(&pos, ",");
	string_append(&pos, string_from_format("%d",posicion->posY));

	return pos;
}
Example #15
0
void nerr_error_traceback (NEOERR *err, NEOSTRING *str)
{
  NEOERR *more;
  char buf[1024];
  char buf2[1024];
  char *err_name;

  if (err == STATUS_OK)
    return;

  if (err == INTERNAL_ERR)
  {
    string_append (str, "Internal error");
    return;
  }

  more = err;
  string_append (str, "Traceback (innermost last):\n");
  while (more && more != INTERNAL_ERR)
  {
    err = more;
    more = err->next;
    if (err->error != NERR_PASS)
    {
      NEOERR *r;
      if (err->error == 0)
      {
	err_name = buf;
	snprintf (buf, sizeof (buf), "Unknown Error");
      }
      else
      {
	r = uListGet (Errors, err->error - 1, (void *)&err_name);
	if (r != STATUS_OK)
	{
	  err_name = buf;
	  snprintf (buf, sizeof (buf), "Error %d", err->error);
	}
      }

      snprintf (buf2, sizeof(buf2),
	  "  File \"%s\", line %d, in %s()\n%s: %s\n", err->file,
	  err->lineno, err->func, err_name, err->desc);
      string_append(str, buf2);
    }
    else
    {
      snprintf (buf2, sizeof(buf2), "  File \"%s\", line %d, in %s()\n",
	  err->file, err->lineno, err->func);
      string_append(str, buf2);
      if (err->desc[0])
      {
	snprintf (buf2, sizeof(buf2), "    %s\n", err->desc);
	string_append(str, buf2);
      }
    }
  }
}
Example #16
0
app_action_t application_function_flash_receive(string_t *src, string_t *dst)
{
	unsigned int chunk_offset, chunk_length;

	if(string_size(&flash_sector_buffer) < SPI_FLASH_SEC_SIZE)
	{
		string_format(dst, "ERROR flash-receive: flash sector buffer too small: %d\n", string_size(&flash_sector_buffer));
		return(app_action_error);
	}

	if(parse_uint(1, src, &chunk_offset, 0, ' ') != parse_ok)
	{
		string_append(dst, "ERROR flash-receive: chunk offset required\n");
		return(app_action_error);
	}

	if(parse_uint(2, src, &chunk_length, 0, ' ') != parse_ok)
	{
		string_append(dst, "ERROR flash-receive: chunk chunk_length required\n");
		return(app_action_error);
	}

	if((chunk_length == 0) || ((chunk_offset % chunk_length) != 0))
	{
		string_append(dst, "ERROR: flash-receive: chunk offset should be divisible by chunk size");
		return(app_action_error);
	}

	if((chunk_length == 0) || ((SPI_FLASH_SEC_SIZE % chunk_length) != 0))
	{
		string_append(dst, "ERROR: flash-receive: chunk length should be divisible by flash sector size");
		return(app_action_error);
	}

	if((chunk_offset + chunk_length) > SPI_FLASH_SEC_SIZE)
	{
		string_format(dst, "ERROR flash-receive: chunk_length(%u) + chunk_offset(%u) > sector size(%d)\n", chunk_length, chunk_offset, SPI_FLASH_SEC_SIZE);
		return(app_action_error);
	}

	if((flash_sector_buffer_use != fsb_free) && (flash_sector_buffer_use != fsb_config_cache) && (flash_sector_buffer_use != fsb_ota))
	{
		string_format(dst, "ERROR: flash_send: sector buffer in use: %u\n", flash_sector_buffer_use);
		return(app_action_error);
	}

	flash_sector_buffer_use = fsb_ota;

	string_format(dst, "OK flash-receive: sending bytes: %u, from offset: %u, data: @", chunk_length, chunk_offset);
	string_splice(dst, -1, &flash_sector_buffer, chunk_offset, chunk_length);
	string_append(dst, "\n");

	if((chunk_offset + chunk_length) >= SPI_FLASH_SEC_SIZE)
		flash_sector_buffer_use = fsb_free;

	return(app_action_normal);
}
Example #17
0
void agregarHeader(char** mensaje){
	char* head=string_new();
	char* numero=header(string_length(*mensaje));
	string_append(&head,numero);
	string_append(&head,*mensaje);
	*mensaje=string_duplicate(head);
	free(numero);
	free (head);
}
Example #18
0
char* path_append( char* base, const char* tail )
{
	if( !base )
		return path_clean( string_clone( tail ), path_is_absolute( tail ) );
	base = string_append( base, "/" );
	base = string_append( base, tail );
	base = path_clean( base, path_is_absolute( base ) );
	return base;
}
LIST *property_set_create( PARSE *parse, FRAME *frame )
{
    LIST* properties = lol_get( frame->args, 0 );    
    LIST* sorted = 0;
    LIST* order_sensitive = 0;
    LIST* unique;
    LIST* tmp;
    LIST* val;
    string var[1];

#if 0
    /* Sort all properties which are not order sensitive */
    for(tmp = properties; tmp; tmp = tmp->next) {
        LIST* g = get_grist(tmp->string);
        LIST* att = call_rule("feature.attributes", frame, g, 0);
        if (list_in(att, "order-sensitive")) {
            order_sensitive = list_new( order_sensitive, tmp->string);
        } else {
            sorted = list_new( sorted, tmp->string);
        }
        list_free(att);
    }
    
    sorted = list_sort(sorted);
    sorted = list_append(sorted, order_sensitive);
    unique = list_unique(sorted);
#endif
    sorted = list_sort(properties);
    unique = list_unique(sorted);

    string_new(var);
    string_append(var, ".ps.");
    
    for(tmp = unique; tmp; tmp = tmp->next) {
        string_append(var, tmp->string);
        string_push_back(var, '-');
    }
    val = var_get(var->value);
    if (val == 0) 
    {          
        val = call_rule("new", frame, 
                        list_append(list_new(0, "property-set"), unique), 0);                
        
        var_set(newstr(var->value), list_copy(0, val), VAR_SET);
    }
    else
    {
        val = list_copy(0, val);
    }
    
    string_free(var);
    /* The 'unique' variable is freed in 'call_rule'. */
    list_free(sorted);

    return val;

}
Example #20
0
static void test_string_append() {
	char *string = string_new();
	string_append(&string, "Hello");
	string_append(&string, " ");
	string_append(&string, "world");

	CU_ASSERT_STRING_EQUAL(string, "Hello world");

	free(string);
}
Example #21
0
void term_toString(Value* val, Value* out)
{
    Term* t = as_term_ref(val);
    if (t == NULL)
        string_append(out, "Term#null");
    else {
        string_append(out, "Term#");
        string_append(out, t->id);
    }
}
Example #22
0
void block_to_string(Value* value, Value* asStr)
{
    Block* block = as_block(value);
    if (block == NULL) {
        string_append(asStr, "Block#null");
    } else {
        string_append(asStr, "Block#");
        string_append(asStr, block->id);
    }
}
Example #23
0
void CuSuiteSummary(CuSuite* testSuite, char **summary) {
	int i;

	for (i = 0 ; i < testSuite->count ; ++i)
        {
            CuTest* testCase = testSuite->list[i];
            string_append(summary, testCase->failed ? "F" : ".");
        }
	string_append(summary, "\n\n");
}
Example #24
0
bool block_check_invariants_print_result(Block* block, Value* out)
{
    circa::Value result;
    block_check_invariants(&result, block);

    if (list_length(&result) == 0)
        return true;

    string_append(out, list_length(&result));
    string_append(out, " errors found in block ");
    string_append_ptr(out, block);
    string_append(out, "\n");

    for (int i=0; i < list_length(&result); i++) {
        Value* error = list_get(&result,i);
        string_append(out, "[");
        string_append(out, as_int(list_get(error, 1)));
        string_append(out, "]");
        string_append(out, as_cstring(list_get(error, 2)));
        string_append(out, "\n");
    }

    string_append(out, "contents:\n");
    print_block(block, out);

    return false;
}
Example #25
0
/**
 * Turns the backtrace into a string that can be displayed
 *
 * @param bt
 * @return
 */
char *arch_debug_bt2string(struct bt *bt)
{
#if defined(__SASC) && defined(DEBUG_RESTRACK)
	string str;
	char buf[120];
	int i;
	int last_line = -1;
	char *last_file = NULL;

	if (!bt) return NULL;

	if (!(string_initialize(&str,200)))
		return NULL;

	/* Load debug infos if not done yet */
	arch_debug_load();

	string_append(&str,"Backtrace\n");

	for (i=0;i<bt->addr_used;i++)
	{
		ULONG offset = (ULONG)bt->addr[i] - (ULONG)__code_base;

		sm_snprintf(buf,sizeof(buf),"\t\t%p (offset %p",bt->addr[i],offset);
		string_append(&str,buf);


		if (debug_info_count > 0)
		{
			struct debug_info *di;
			int offset = (ULONG)bt->addr[i] - (ULONG)__code_base;

			BIN_SEARCH(debug_info_array, 0, debug_info_count-1,
					(debug_info_array[m].offset <= offset) ?
					(offset < debug_info_array[m+1].offset?0:(1)):(-1),
					di);

			if (di && (di->filename != last_file || di->line != last_line))
			{
				string_append(&str,", ");
				sm_snprintf(buf,sizeof(buf),"%s/%d",di->filename,di->line);
				string_append(&str,buf);
				last_file = di->filename;
				last_line = di->line;
			}
		}

		string_append(&str,")\n");
	}

	return str.str;
#else
	return NULL;
#endif
}
Example #26
0
int64_t query_index(query_t *query, int64_t id)
{
  string_t *sql = string_new();
  char *where = build_filters(query);
  sqlite3_stmt *stmt;
  int64_t result;
  int64_t index = 1;

  string_append(sql, query->format->index);
  string_append(sql, query->format->from);
  string_append(sql, query->format->join);
  string_append(sql, where);
  free(where);

  if (string_size(query->order) > 0) {
    string_appendf(sql, " ORDER BY %s", string_string(query->order));
  }

  musicd_log(LOG_DEBUG, "query", "%s", string_string(sql));

  if (sqlite3_prepare_v2(db_handle(),
                         string_string(sql), -1,
                         &stmt, NULL) != SQLITE_OK) {
    musicd_log(LOG_ERROR, "query", "can't prepare '%s': %s",
               string_string(sql), db_error());
    string_free(sql);
    return -1;
  }
  string_free(sql);

  bind_filters(query, stmt);

  while (1) {
    result = sqlite3_step(stmt);
    if (result == SQLITE_DONE) {
      result = 0;
      goto finish;
    }
    if (result != SQLITE_ROW) {
      musicd_log(LOG_ERROR, "query", "query_count: sqlite3_step failed");
      result = -1;
      goto finish;
    }
    if (sqlite3_column_int64(stmt, 0) == id) {
      result = index;
      goto finish;
    }
    ++index;
  }

finish:
  sqlite3_finalize(stmt);
  return result;
}
char* string_join(t_list* chunks, char * separator) {
	int i;
	char* ret = string_duplicate("");
	for(i = 0; i < list_size(chunks); i++) {
		if(i) {
			string_append(&ret, separator);
		}
		string_append(&ret, (char*) list_get(chunks, i));
	}
	return ret;
}
Example #28
0
void string_append(caValue* left, caValue* right)
{
    ca_assert(is_string(left));

    if (is_string(right))
        string_append(left, as_cstring(right));
    else {
        std::string s = to_string(right);
        string_append(left, s.c_str());
    }
}
Example #29
0
void string_append_qualified_name(caValue* left, caValue* right)
{
    if (string_eq(left, "")) {
        copy(right, left);
        return;
    }
    if (string_eq(right, ""))
        return;
    string_append(left, ":");
    string_append(left, right);
}
Example #30
0
void format_global_id(Term* term, Value* out)
{
    if (!is_string(out))
        set_string(out, "");

    if (term == NULL)
        string_append(out, "null");
    else {
        string_append(out, "#");
        string_append(out, term->id);
    }
}