int main()
{
char filename[]="data.txt";
char letter;
FILE *fp = NULL;
struct letter_obj *string = NULL;
fp = fopen(filename, "r");
if(fp == NULL)
{
printf("Error: Unable to open input file\n");
return 1;
}
// Read in the input file one character at a time
letter = fgetc(fp);
while(letter != EOF)
{
// Add each character to a string in linked-list format
// "string" will always stay pointing to the first character.
string = string_append(string, letter);
// Get another character
letter = fgetc(fp);
}
// Close the file - done with input
fclose(fp);
// Print out the original string
printf("Original string read from file: \n");
string_print(string);
printf("\n");
// Modify the string, dropping all vowels from it
string = string_drop_vowels(string);
// Print out the modified string
printf("Modified string with vowels dropped: \n");
string_print(string);
printf("\n");
// Delete the string (calls free() for each letter in string)
string_delete(string);
// Free dynamically allocated memory
free(object); // invalid code, not sure why :(
return 0;
}
void words_print(char ** string, int count)
{
if (string == NULL)
{
return;
}
for (int i = 0; i < count; ++i)
{
string_print(string[i]);
}
std::cout << std::endl;
}
int main()
{
string *s = string_init();
string *o;
string *subs;
string *q = string_init_cstring("quit");
string_read_line(s);
while(string_cmp(s, q))
{
string_print(s);
string_reset(s);
string_read_line(s);
}
string_append(s, q);
o = string_cat(s, q);
string_print(s);
string_print(o);
string_append_cstring(o, "hello");
string_append_char(o, 'J');
string_print(o);
subs = string_substring(o, 5, 6);
printf("--\n");
printf("%c\n", string_get(s, 5));
printf("%d\n", string_index(o, 'o'));
string_print(subs);
printf("--\n");
o = string_free(o);
s = string_free(s);
q = string_free(q);
subs = string_free(subs);
return 0;
}
/**
Print a value to standard output
*/
void value_print(value_t value)
{
switch (value.tag)
{
case TAG_FALSE:
printf("false");
break;
case TAG_TRUE:
printf("true");
break;
case TAG_INT64:
printf("%ld", value.word.int64);
break;
case TAG_FLOAT64:
printf("%lf", value.word.float64);
break;
case TAG_STRING:
{
putchar('"');
string_print((string_t*)value.word.heapptr);
putchar('"');
}
break;
case TAG_ARRAY:
{
array_t* array = (array_t*)value.word.heapptr;
putchar('[');
for (size_t i = 0; i < array->len; ++i)
{
value_print(array_get(array, i));
if (i + 1 < array->len)
printf(", ");
}
putchar(']');
}
break;
default:
printf("unknown value tag");
break;
}
}
int main()
{
map *m;
string *k;
string *v;
string *q;
map_iterator *n;
pair *t;
m = map_init(stcmp);
q = string_init_cstring("");
k = string_init();
string_read_line(k);
while(string_cmp(k, q))
{
v = string_init();
string_read_line(v);
map_add(m, k, v);
k = string_init();
string_read_line(k);
}
k = string_free(k);
/* Iterate through map. */
for(n = map_begin(m); n; n = map_next(n))
{
t = n->data;
string_print(t->first);
printf(" => ");
string_println(t->second);
}
/* Free map. */
for(n = map_begin(m); n; n = map_next(n))
{
t = n->data;
string_free(t->first);
string_free(t->second);
}
string_free(q);
m = map_free(m);
return 0;
}
int main()
{
/// Ввод данных
std::cout << "Your text: ";
char * text = new char[STRING_LENGTH];
memset(text, 0, STRING_LENGTH * sizeof(char));
gets(text);
/// Обработка данных
int words_count = word_counter(text);
char ** words = string_to_words(text);
char ** bricks = new char * [words_count];
memset(bricks, 0, words_count * sizeof(char *));
for (int index = 0; index < words_count; ++index)
{
bricks[index] = string_bricking(words[index]);
}
/// Вывод результатов
std::cout << "String length: " << string_length(text) << std::endl;
std::cout << "String: " << std::endl;
string_print(text);
std::cout << std::endl;
std::cout << "String to words: " << std::endl;
words_print(words, words_count);
std::cout << "Bricked string: " << std::endl;
words_print(bricks, words_count);
/// Освобаждение оесурсов
words_free(&bricks, words_count);
words_free(&words, words_count);
delete [] text;
return 0;
}
void process_stddev(void)
{
struct stddev_cmd stddev_msg;
struct stddev_res res;
struct stddev_devtype_res *type_res = NULL;
struct stddev_ver_res *ver_res = NULL;
struct stddev_ioctl_cmd *ioctl = NULL;
struct key_suscription *s = NULL;
int i = 0, sender_id;
while(get_msg_count(CSL_STDDEV_PORT) > 0)
{
get_msg(CSL_STDDEV_PORT, &stddev_msg, &sender_id);
res.logic_deviceid = -1;
res.command = stddev_msg.command;
res.msg_id = stddev_msg.msg_id;
switch(stddev_msg.command)
{
case STDDEV_GET_DEVICETYPE:
type_res = (struct stddev_devtype_res*)&res;
type_res->dev_type = STDDEV_CHAR;
type_res->ret = STDDEV_OK;
type_res->msg_id = stddev_msg.msg_id;
break;
case STDDEV_VER:
ver_res = (struct stddev_ver_res*)&res;
ver_res->ret = STDDEV_OK;
ver_res->ver = STDDEV_VERSION;
ver_res->msg_id = stddev_msg.msg_id;
break;
case STDDEV_GET_DEVICE:
case STDDEV_GET_DEVICEX:
res.logic_deviceid = stddev_msg.padding0;
res.msg_id = stddev_msg.msg_id;
res.ret = STDDEV_OK;
break;
case STDDEV_FREE_DEVICE:
res.logic_deviceid = stddev_msg.padding0;
res.msg_id = stddev_msg.msg_id;
res.ret = STDDEV_OK;
break;
case STDDEV_IOCTL:
ioctl = (struct stddev_ioctl_cmd*)&stddev_msg;
res.ret = STDDEV_ERR;
res.logic_deviceid = ioctl->logic_deviceid;
//if(!check_ownership(ioctl->logic_deviceid, sender_id)) break;
if(res.logic_deviceid >= NUM_VIRTUAL)
string_print("CONS: ASSERT 1",0,7);
((struct stddev_ioctrl_res *)&res)->dev_error = -1;
switch(ioctl->request)
{
case CSL_IO_DISABLE_ECHO:
i = 0;
while(i < t[res.logic_deviceid].owners)
{
if(t[res.logic_deviceid].ownerid[i] == sender_id)
{
t[res.logic_deviceid].force_echo[i] = CSL_FORCE_NOECHO;
break;
}
i++;
}
res.ret = STDDEV_OK;
break;
case CSL_IO_COMMAND_ECHO:
i = 0;
while(i < t[res.logic_deviceid].owners)
{
if(t[res.logic_deviceid].ownerid[i] == sender_id)
{
t[res.logic_deviceid].force_echo[i] = CSL_FORCE_NONE;
break;
}
i++;
}
res.ret = STDDEV_OK;
break;
case CSL_IO_ENABLE_ECHO:
i = 0;
while(i < t[res.logic_deviceid].owners)
{
if(t[res.logic_deviceid].ownerid[i] == sender_id)
{
t[res.logic_deviceid].force_echo[i] = CSL_FORCE_ECHO;
break;
}
i++;
}
res.ret = STDDEV_OK;
break;
case CSL_IO_SWITCH:
vt_switch(ioctl->logic_deviceid);
res.ret = STDDEV_OK;
break;
case CSL_IO_SETATT:
t[ioctl->logic_deviceid].attribute = (char)ioctl->param;
res.ret = STDDEV_OK;
break;
case CSL_IO_SETSIGNALPORT:
s = get_suscription(sender_id, ioctl->logic_deviceid);
if(s)
{
s->port = ioctl->param;
res.ret = STDDEV_OK;
}
else
{
res.ret = STDDEV_ERR;
}
break;
case CSL_IO_SIGNAL:
s = get_suscription(sender_id, ioctl->logic_deviceid);
if(s == NULL || s->susc != MAX_SUSCRIPTIONS)
{
res.ret = STDDEV_OK;
s->keycodes[s->susc] = (char)ioctl->param;
s->susc++;
}
else
{
res.ret = STDDEV_ERR;
}
break;
case CSL_IO_USIGNAL:
if(remove_suscription(sender_id, ioctl->logic_deviceid))
res.ret = STDDEV_ERR;
else
res.ret = STDDEV_OK;
break;
case CSL_IO_MSIGNAL:
{
for(i = 0; i < MAX_MOUSE_SUSCRIPTIONS; i++)
{
if(mouse_suscriptions[i] == -1)
break;
}
if(i == MAX_MOUSE_SUSCRIPTIONS)
{
res.ret = STDDEV_ERR;
}
else
{
mouse_suscriptions[i] = sender_id;
mouse_suscriptions_ports[i] = 0;
msuscs++;
res.ret = STDDEV_OK;
}
}
break;
case CSL_IO_UMSIGNAL:
{
for(i = 0; i < MAX_MOUSE_SUSCRIPTIONS; i++)
{
if(mouse_suscriptions[i] == sender_id)
break;
}
if(i == MAX_MOUSE_SUSCRIPTIONS)
{
res.ret = STDDEV_ERR;
}
else
{
mouse_suscriptions[i] = -1;
msuscs--;
res.ret = STDDEV_OK;
}
}
break;
case CSL_IO_SETMSIGNALPORT:
{
for(i = 0; i < MAX_MOUSE_SUSCRIPTIONS; i++)
{
if(mouse_suscriptions[i] == sender_id)
break;
}
if(i == MAX_MOUSE_SUSCRIPTIONS)
{
res.ret = STDDEV_ERR;
}
else
{
mouse_suscriptions_ports[i] = ioctl->param;
res.ret = STDDEV_OK;
}
}
break;
case CSL_MOUSE_ENABLE:
mouse_enable(ioctl->param);
res.ret = STDDEV_OK;
break;
}
break;
}
send_msg(sender_id, stddev_msg.ret_port, &res);
}
}
PmReturn_t
obj_print(pPmObj_t pobj, uint8_t is_expr_repr, uint8_t is_nested)
{
PmReturn_t retval = PM_RET_OK;
C_ASSERT(pobj != C_NULL);
/* Something gets printed unless it's None in an unnested expression */
if (!((OBJ_GET_TYPE(pobj) == OBJ_TYPE_NON) && is_expr_repr && !is_nested))
{
gVmGlobal.somethingPrinted = C_TRUE;
}
switch (OBJ_GET_TYPE(pobj))
{
case OBJ_TYPE_NON:
if (!is_expr_repr || is_nested)
{
plat_putByte('N');
plat_putByte('o');
plat_putByte('n');
retval = plat_putByte('e');
}
break;
case OBJ_TYPE_INT:
retval = int_print(pobj);
break;
#ifdef HAVE_FLOAT
case OBJ_TYPE_FLT:
retval = float_print(pobj);
break;
#endif /* HAVE_FLOAT */
case OBJ_TYPE_STR:
retval = string_print(pobj, (is_expr_repr || is_nested));
break;
case OBJ_TYPE_TUP:
retval = tuple_print(pobj);
break;
case OBJ_TYPE_LST:
retval = list_print(pobj);
break;
case OBJ_TYPE_DIC:
retval = dict_print(pobj);
break;
case OBJ_TYPE_BOOL:
if (((pPmBoolean_t) pobj)->val == C_TRUE)
{
plat_putByte('T');
plat_putByte('r');
plat_putByte('u');
}
else
{
plat_putByte('F');
plat_putByte('a');
plat_putByte('l');
plat_putByte('s');
}
retval = plat_putByte('e');
break;
case OBJ_TYPE_CLI:
#ifdef HAVE_BYTEARRAY
{
pPmObj_t pobj2;
retval = dict_getItem((pPmObj_t)((pPmInstance_t)pobj)->cli_attrs,
PM_NONE,
(pPmObj_t *)&pobj2);
if ((retval == PM_RET_OK)
&& (OBJ_GET_TYPE(pobj2) == OBJ_TYPE_BYA))
{
retval = bytearray_print(pobj2);
break;
}
}
#endif /* HAVE_BYTEARRAY */
case OBJ_TYPE_COB:
case OBJ_TYPE_MOD:
case OBJ_TYPE_CLO:
case OBJ_TYPE_FXN:
case OBJ_TYPE_CIM:
case OBJ_TYPE_NIM:
case OBJ_TYPE_NOB:
case OBJ_TYPE_THR:
case OBJ_TYPE_CIO:
case OBJ_TYPE_MTH:
case OBJ_TYPE_SQI:
plat_putByte('<');
plat_putByte('o');
plat_putByte('b');
plat_putByte('j');
plat_putByte(' ');
plat_putByte('t');
plat_putByte('y');
plat_putByte('p');
plat_putByte('e');
plat_putByte(' ');
plat_putByte('0');
plat_putByte('x');
int_printHexByte(OBJ_GET_TYPE(pobj));
plat_putByte(' ');
plat_putByte('@');
plat_putByte(' ');
plat_putByte('0');
plat_putByte('x');
_int_printHex((intptr_t)pobj);
retval = plat_putByte('>');
break;
default:
/* Otherwise raise a TypeError */
PM_RAISE(retval, PM_RET_EX_TYPE);
break;
}
return retval;
}
PmReturn_t
obj_print(pPmObj_t pobj, uint8_t is_expr_repr, uint8_t is_nested)
{
PmReturn_t retval = PM_RET_OK;
C_ASSERT(pobj != C_NULL);
/* Something gets printed unless it's None in an unnested expression */
if (!((OBJ_GET_TYPE(pobj) == OBJ_TYPE_NON) && is_expr_repr && !is_nested))
{
gVmGlobal.somethingPrinted = C_TRUE;
}
switch (OBJ_GET_TYPE(pobj))
{
case OBJ_TYPE_NON:
if (!is_expr_repr || is_nested)
{
sli_puts((uint8_t *)"None");
}
break;
case OBJ_TYPE_INT:
retval = int_print(pobj);
break;
#ifdef HAVE_FLOAT
case OBJ_TYPE_FLT:
retval = float_print(pobj);
break;
#endif /* HAVE_FLOAT */
case OBJ_TYPE_STR:
retval = string_print(pobj, (is_expr_repr || is_nested));
break;
case OBJ_TYPE_TUP:
retval = tuple_print(pobj);
break;
case OBJ_TYPE_LST:
retval = list_print(pobj);
break;
case OBJ_TYPE_DIC:
retval = dict_print(pobj);
break;
case OBJ_TYPE_BOOL:
sli_puts(
(((pPmBoolean_t) pobj)->val == C_TRUE)
? (uint8_t *)"True"
: (uint8_t *)"False");
break;
case OBJ_TYPE_CLI:
#ifdef HAVE_BYTEARRAY
{
pPmObj_t pobj2;
retval = dict_getItem((pPmObj_t)((pPmInstance_t)pobj)->cli_attrs,
PM_NONE,
(pPmObj_t *)&pobj2);
if ((retval == PM_RET_OK)
&& (OBJ_GET_TYPE(pobj2) == OBJ_TYPE_BYA))
{
retval = bytearray_print(pobj2);
break;
}
}
#endif /* HAVE_BYTEARRAY */
case OBJ_TYPE_COB:
case OBJ_TYPE_MOD:
case OBJ_TYPE_CLO:
case OBJ_TYPE_FXN:
case OBJ_TYPE_CIM:
case OBJ_TYPE_NIM:
case OBJ_TYPE_NOB:
case OBJ_TYPE_THR:
case OBJ_TYPE_CIO:
case OBJ_TYPE_MTH:
case OBJ_TYPE_SQI:
{
uint8_t buf[17];
sli_puts((uint8_t *)"<obj type 0x");
sli_btoa16(OBJ_GET_TYPE(pobj), buf, sizeof(buf), C_TRUE);
sli_puts(buf);
sli_puts((uint8_t *)" @ 0x");
sli_ptoa16((intptr_t)pobj, buf, sizeof(buf), C_TRUE);
sli_puts(buf);
retval = plat_putByte('>');
break;
}
default:
/* Otherwise raise a TypeError */
PM_RAISE(retval, PM_RET_EX_TYPE);
break;
}
return retval;
}
/*******************************************************************
* Reduced snprintf to be used for Trusted firmware.
* The following type specifiers are supported:
*
* %d or %i - signed decimal format
* %s - string format
* %u - unsigned decimal format
*
* The function panics on all other formats specifiers.
*
* It returns the number of characters that would be written if the
* buffer was big enough. If it returns a value lower than n, the
* whole string has been written.
*******************************************************************/
int snprintf(char *s, size_t n, const char *fmt, ...)
{
va_list args;
int num;
unsigned int unum;
char *str;
size_t chars_printed = 0U;
if (n == 0U) {
/* There isn't space for anything. */
} else if (n == 1U) {
/* Buffer is too small to actually write anything else. */
*s = '\0';
n = 0U;
} else {
/* Reserve space for the terminator character. */
n--;
}
va_start(args, fmt);
while (*fmt != '\0') {
if (*fmt == '%') {
fmt++;
/* Check the format specifier. */
switch (*fmt) {
case 'i':
case 'd':
num = va_arg(args, int);
if (num < 0) {
if (chars_printed < n) {
*s = '-';
s++;
}
chars_printed++;
unum = (unsigned int)-num;
} else {
unum = (unsigned int)num;
}
unsigned_dec_print(&s, n, &chars_printed, unum);
break;
case 's':
str = va_arg(args, char *);
string_print(&s, n, &chars_printed, str);
break;
case 'u':
unum = va_arg(args, unsigned int);
unsigned_dec_print(&s, n, &chars_printed, unum);
break;
default:
/* Panic on any other format specifier. */
ERROR("snprintf: specifier with ASCII code '%d' not supported.",
*fmt);
plat_panic_handler();
assert(0); /* Unreachable */
}
fmt++;
continue;
}
if (chars_printed < n) {
*s = *fmt;
s++;
}
fmt++;
chars_printed++;
}
int main(int argc, char **argv)
{
vector *v;
string *s;
string **tmp;
string *sup;
int i;
v = vector_init(stcmp);
sup = string_init_cstring("6");
while(--argc)
{
s = string_init_cstring(argv[argc]);
vector_append(v, s);
}
printf("size: %d\n", v->len);
printf("---\n");
/* Print. */
for(i = 0; i < v->len; ++i)
string_println(vector_get(v, i));
printf("---\n");
/* Sort and print again. */
vector_sort(v);
for(i = 0; i < v->len; ++i)
string_println(vector_get(v, i));
printf("---\n");
/* Search for sup. */
if(vector_index(v, sup) != -1)
string_print(sup), printf(" found.\n");
else
string_print(sup), printf(" not found.\n");
printf("---\n");
/* Using bsearch. */
tmp = vector_search(v, sup);
if(tmp)
{
string_print(*tmp);
printf(" found using bsearch.\n");
}
else
{
string_print(sup);
printf(" bsearch failed.\n");
}
printf("---\n");
/* Shuffle and print again. */
vector_shuffle(v);
for(i = 0; i < v->len; ++i)
string_println(vector_get(v, i));
printf("---\n");
for(i = 0; i < v->len; ++i)
string_free(vector_get(v, i));
string_free(sup);
vector_free(v);
return 0;
}
