void test_Ticket_2f276877e490b371_Pluses_Line_number(void **state) {
string_eq("++++ GOSUB GET.UNC.AMOUNT ;* Comments",
".......aaaaa..................bbbbbbbbbbb");
string_eq("++++++ GOSUB GET.UNC.AMOUNT ;* Comments",
".........aaaaa..................bbbbbbbbbbb");
string_eq("+++ GOSUB GET.UNC.AMOUNT ;* Comments",
"........................................");
}
void test_Ticket_5aa1f03d4dbecfc4_Plus_Minus_with_numbers(void **state) {
string_eq("0003 X = -2",
".......a.bc");
string_eq("0004 A = X - 2",
".......a...b.c");
string_eq("0005 B = X-2",
".......a..bc");
}
void test_Common(void **state) {
string_eq("0000 A COMMON /BLOO.COMMON, ONE , TWO/ B$OO.ISIN.LIST, B$OO.SM.LST",
".......aaaaaa.b......................c............................");
string_eq("0001 COMMON /BLOO.COMMON, ONE , TWO/ B$OO.ISIN.LIST, B$OO.SM.LST",
".....aaaaaa..bbbbbbbbbbbbbbbbbbbbbb.............................");
string_eq("0001 COMMON /BLOO.COMMON/ B$OO.ISIN.LIST, B$OO.SM.LIST",
".....aaaaaa..bbbbbbbbbbb..............................");
}
void test_Ticket_3f3645bab6_UNTIL_DO_REPEAT(void **state) {
string_eq("0204 UNTIL DONE DO ",
".........aaaaa......bb.");
string_eq("0230 REPEAT",
".........aaaaaa");
string_eq("0231 REPEAT ",
".........aaaaaa.");
}
void test_Ticket_d107ffd1a45fa984_Great_equal(void **state) {
string_eq("0245 IF PGM.NAME[1,2] >= 'G' BP.NO = 2 ELSE BP.NO = 1",
"........aa..........b.c.ddddeee.......f.g.hhhh.......i.j");
string_eq("0245 IF PGM.NAME[1,2] => 'G' BP.NO = 2 ELSE BP.NO = 1",
"........aa..........b.c.ddddeee.......f.g.hhhh.......i.j");
string_eq("0245 IF PGM.NAME[1,2] <= 'G' BP.NO = 2 ELSE BP.NO = 1",
"........aa..........b.c.ddddeee.......f.g.hhhh.......i.j");
string_eq("0245 IF PGM.NAME[1,2] =< 'G' BP.NO = 2 ELSE BP.NO = 1",
"........aa..........b.c.ddddeee.......f.g.hhhh.......i.j");
}
void test_Ticket_3ba17ef8f11c682b_Percent_in_name(void **state) {
string_eq("0086 L%ANSWER = ''",
"................a.bb");
string_eq("0078 IF L%ERR THEN",
".......aa.......bbbb");
string_eq("0088 L%PROMPT = 'aaa'",
"................a.bbbbb");
string_eq("0089 CALL TXTINP(L%PROMPT, 8, 12, FM:'Y_N')",
".......aaaa..................b..cc.....ddddd.");
}
void test_Ticket_b37ddad3e7478348_Abss(void **state) {
string_eq("0001 PROGRAM ABSS-TEST",
".......aaaaaaa..........");
string_eq("0001 SUBROUTINE ABSS-TEST",
".......aaaaaaaaaa..........");
string_eq("0001 GOSUB ABSS-TEST",
".......aaaaa..........");
string_eq("0001 ABSS-TEST:",
".......aaaaaaaaaa");
}
bool string_has_prefix(const char* str, const char* prefix)
{
if (string_eq(prefix, ""))
return true;
if (string_eq(str, ""))
return false;
return strncmp(str, prefix, strlen(prefix)) == 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);
}
void test_Ticket_dd6a19efa5_DATE(void **state) {
string_eq("0029 ENTRIES<1, AC.STE.VALUE.DATE> = TODAY",
"..............a........................b......");
string_eq("0036 ENTRIES<1, AC.STE.BOOKING.DATE> = TODAY",
"..............a........................b......");
string_eq("0036 ENTRIES<1, AC.STE.TOOKING DATE> = TODAY",
"..............a.................bbbb...c......");
string_eq("0036 DATE = TODAY",
".....aaaa.b......");
string_eq("0036 DATE = TODAY",
"......aaaa.b......");
}
void test_Ticket_d581209a49abc4a1_Common(void **state) {
string_eq("0029 COMMON/SLCOM/F$SL.PARAM.FILE, ;* SL",
"........aaaaaa.bbbbb.....................ccccc");
string_eq("0029 COMMON /SLCOM/F$SL.PARAM.FILE, ;* SL",
"........aaaaaa..bbbbb.....................ccccc");
string_eq("0029 COM/SLCOM/F$SL.PARAM.FILE, ;* SL",
"........aaa.bbbbb.....................ccccc");
string_eq("0029 COM /SLCOM/F$SL.PARAM.FILE, ;* SL",
"........aaa..bbbbb.....................ccccc");
string_eq("0029 COM/ SLCOM/F$SL.PARAM.FILE, ;* SL",
"........aaa.bbbbbb.....................ccccc");
}
void test_Numbers(void **state) {
string_eq("0001 A = 10",
".......a.bb");
string_eq("0002 A = +10",
".......a.bcc");
string_eq("0002 A = + 10",
".......a.b.cc");
string_eq("0002 A = -10",
".......a.bcc");
string_eq("0002 A = - 10",
".......a.b.cc");
}
static shell_result_t shell_handler(shell_command_t* command) {
if (command->args_count == 0) return SHELL_RESULT_FAIL;
if (string_eq(command->command, "ht")) {
if (string_eq(command->args[0], "start")) {
start();
} else if (string_eq(command->args[0], "stop")) {
stop();
} else if (string_eq(command->args[0], "sv")) {
uint16_t bytes_written = hum_temp_save();
shell_printf("%u ->\n", bytes_written);
} else if (string_eq(command->args[0], "ld")) {
uint16_t bytes_read = hum_temp_load();
shell_printf("%u <-\n", bytes_read);
} else if (string_eq(command->args[0], "av")) {
hum_temp_print_stats(shell_get_stream());
} else if (string_eq(command->args[0], "dmp")) {
hum_temp_print_samples(shell_get_stream());
} else if (string_eq(command->args[0], "al")) {
ui_set_alarm_on();
} else {
return SHELL_RESULT_FAIL;
}
}
return SHELL_RESULT_SUCCESS;
}
bool string_has_suffix(const char* str, const char* suffix)
{
if (string_eq(suffix, ""))
return true;
if (string_eq(str, ""))
return false;
if (strlen(suffix) > strlen(str))
return false;
const char* search = str + (strlen(str) - strlen(suffix));
rassert(strlen(search) == strlen(suffix));
return string_eq(search, suffix);
}
void block_update_state_type(Block* block)
{
if (!block_state_type_is_out_of_date(block))
return;
// Recreate the state type
Type* type = create_compound_type();
// TODO: give this new type a nice name
for (int i=0; i < block->length(); i++) {
Term* term = block->get(i);
if (term == NULL)
continue;
if (term->function != FUNCS.unpack_state || FUNCS.unpack_state == NULL)
continue;
Term* identifyingTerm = term->input(1);
caValue* fieldName = get_unique_name(identifyingTerm);
ca_assert(is_string(fieldName));
ca_assert(!string_eq(fieldName, ""));
compound_type_append_field(type, declared_type(term), as_cstring(fieldName));
}
block->stateType = type;
block_remove_property(block, sym_DirtyStateType);
// Might need to update any existing pack_state calls.
block_update_pack_state_calls(block);
}
void log_add(string_t s) {
int i ;
log_line_t cur ;
for (i=0;i<nlogs;i++) {
if (logs[i].discr != LOG_NAME) continue;
if (!logs[i].u.name) continue ;
if (string_eq(logs[i].u.name, s)) break ;
}
if (i < nlogs) {
return ;
}
if (nlogs >= MAX_LOGS) {
eprintf("TRACE:log_add:table overflow\n") ;
return ;
}
logs[nlogs].discr = LOG_NAME;
logs[nlogs].u.name = string_copy(s) ;
nlogs ++ ;
for (cur=lines; cur; cur = cur->next) {
if (!strncmp(s, cur->s0, strlen (cur->s0)) &&
!strcmp(s+strlen (cur->s0), cur->s1)) {
cur->__logme__ = LOG_LINE_SET ;
}
}
}
int string_extract_index(
const char* path, const char* prefix, int digits, const char* after)
{
rassert(path != NULL);
rassert(digits > 0);
if (!string_has_prefix(path, prefix))
return -1;
static const char hex_digits[] = "0123456789abcdef";
int prefix_len = 0;
if (prefix != NULL)
{
prefix_len = (int)strlen(prefix);
}
else
{
prefix_len = (int)strcspn(path, hex_digits);
if (path[prefix_len] == '\0')
return -1;
}
const char* num_s = path + prefix_len;
int index = 0;
for (int i = 0; i < digits; ++i, ++num_s)
{
index *= 0x10;
if (*num_s == '\0')
return -1;
char* pos = strchr(hex_digits, *num_s);
if (pos == NULL)
return -1;
index += (int)(pos - hex_digits);
}
if (string_has_prefix(after, ".") && !string_eq(num_s, after))
return -1;
else if ((after != NULL) && string_eq(after, "") && !string_eq(num_s, ""))
return -1;
else if (!string_has_prefix(num_s, after))
return -1;
return index;
}
static shell_result adc_shell_handler(shell_command* command) {
if (!string_eq(command->command, "adc")) return SHELL_RESULT_FAIL;
if (command->args_count == 0) return SHELL_RESULT_FAIL;
if (string_eq(command->args[0], "read")) {
shell_printf("Channel\tReading\r\n");
if (command->args_count == 2) {
uint8_t channel = atoi(command->args[1]);
shell_printf("%u\t%u\r\n", channel, adc_read(channel));
} else {
for (int i = 0; i < 6; i++) {
shell_printf("%u\t%u\r\n", i, adc_read(i));
}
}
return SHELL_RESULT_SUCCESS;
}
return SHELL_RESULT_FAIL;
}
void setup_type(Type* type)
{
if (string_eq(&type->name, ""))
set_string(&type->name, "int");
type->storageType = name_StorageTypeInt;
type->reset = reset;
type->equals = equals;
type->hashFunc = hashFunc;
type->toString = to_string;
type->formatSource = format_source;
}
Proc_cons* Proc_type_find_cons(const char* type)
{
rassert(type != NULL);
for (int i = 0; proc_types[i].type != NULL; ++i)
{
if (string_eq(type, proc_types[i].type))
return proc_types[i].cons;
}
return NULL;
}
DSP_cons* DSP_type_find_cons(const char* type)
{
assert(type != NULL);
for (int i = 0; dsp_types[i].type != NULL; ++i)
{
if (string_eq(type, dsp_types[i].type))
return dsp_types[i].cons;
}
return NULL;
}
void write(caValue* item)
{
possiblyStartNewLine();
if (string_eq(item, "\n")) {
set_string(output.append(), "\n");
startNewLine = true;
return;
}
copy(item, output.append());
}
DSP_property* DSP_type_find_property(const char* type)
{
assert(type != NULL);
for (int i = 0; dsp_types[i].type != NULL; ++i)
{
if (string_eq(type, dsp_types[i].type))
return dsp_types[i].property;
}
assert(false);
return NULL;
}
void test_Execution_control(void **state) {
string_eq("0001 GOSUB xxx",
".......aaaaa....");
string_eq("0001 GOSUB xxx ",
".......aaaaa.....");
string_eq("0001 RETURN",
".......aaaaaa");
string_eq("0001 RETURN ",
".......aaaaaaa");
string_eq("0001 STOP",
".......aaaa");
string_eq("0001 STOP ",
".......aaaa.");
string_eq("0001 GOTO xxx",
".......aaaa....");
string_eq("0001 GOTO xxx ",
".......aaaa.....");
string_eq("0001 EXECUTE xxx",
".......aaaaaaa....");
string_eq("0001 EXECUTE xxx ",
".......aaaaaaa.....");
}
static bool read_expressions_def(Streader* sr, const char* key, void* userdata)
{
rassert(sr != NULL);
rassert(key != NULL);
rassert(userdata != NULL);
Au_expressions* ae = userdata;
if (string_eq(key, "default_note_expr"))
{
char expr[KQT_VAR_NAME_MAX + 1] = "";
if (!Streader_read_string(sr, KQT_VAR_NAME_MAX + 1, expr))
return false;
if ((expr[0] != '\0') && !is_valid_var_name(expr))
{
Streader_set_error(sr, "Invalid default note expression: %s", expr);
return false;
}
strcpy(ae->default_note_expr, expr);
}
else if (string_eq(key, "expressions"))
{
if (!Streader_read_dict(sr, read_expressions, ae))
{
rassert(Streader_is_error_set(sr));
return false;
}
}
else
{
Streader_set_error(sr, "Unexpected key in expression specification: %s", key);
return false;
}
return true;
}
bool map_contains(map_t map, key_t key){
bool exist = false;
if (map != NULL){
if(string_eq(key, map->key)){
exist = true;
}
else if (string_less(key, map->key)){
exist = map_contains(map->leftnode, key);
}
else {
exist = map_contains(map->rightnode, key);
}
}
return exist;
}
value_t map_get(map_t map, key_t key){
value_t resultado = NULL;
if (map != NULL) {
if (string_eq(key, map->key)){
resultado = map->value;
}
else if (string_less(key, map->key)){
resultado = map_get(map->leftnode, key);
}
else {
resultado = map_get(map->rightnode, key);
}
}
return resultado;
}
int list_find_field_index_by_name(Type* listType, const char* name)
{
if (!is_list_based_type(listType))
return -1;
caValue* names = list_get_name_list_from_type(listType);
if (names == NULL)
return -1;
for (int i=0; i < circa_count(names); i++)
if (string_eq(circa_index(names, i), name))
return i;
// Not found
return -1;
}
struct cache_entry *cache_lookup(struct string *key) {
size_t i;
for (i = 0; i < kCacheSize; ++i) {
struct cache_entry *entry = &cache[i];
// Skip expired cache entries.
if (entry->lifetime == 0) {
continue;
}
if (string_eq(entry->key, key)) {
return entry;
}
}
return NULL;
}
void test_Label(void **state) {
string_eq("0017 LABEL:",
"......aaaaaa");
string_eq("0018 LABEL: ",
".....aaaaaa.");
string_eq("0019 LABEL: ",
"........aaaaaa.");
string_eq("0019 LA:EL: ",
"........aaa....");
string_eq("0019 LABEL: a = b",
"........aaaaaa...b..");
string_eq("0019 LABEL: a = b:c:b",
"........aaaaaa...b......");
string_eq("0020 LABEL: // LABEL: ",
"........aaaaaa.bbbbbbbbbb");
}
