NAPA Compiler V4.50
Author: Yves Leduc, yves.leduc.be@gmail.com
Loading...
Searching...
No Matches
C:/Simulate/Napados/Source/tk.c File Reference
#include "./napa.h"
#include "./proto.h"

Go to the source code of this file.

Macros

#define EXTERN   extern

Functions

char * build_name (const char *sgn, char *tok, long lr_type)
void build_pathname (const char *brc, char *tok, const char *path, const unsigned long *mlin, const unsigned long *mfil)
void resolve_pathnames (char *lin, long depth)
void extract_directory (char *pn, char *fn, long depth)
void clean_parentheses (char *tok)
void process_cell_line (char *buf, long d, const unsigned long *mlin, const unsigned long *mfil)
void expand_indirections (char *str)
void expand_iterative_identifiers (char *str, unsigned long *mlin, const unsigned long *mfil)
char * expand_nodeset (char *str, long n, long w, const unsigned long *mlin, const unsigned long *mfil)
char * get_function_identifier (char *str, char *fun_id, char *fun_parm)
char * get_output_and_scaling (char *str, char *sgn, char *out, char *scl)
char * extract_prefix (char *nam)
char * get_token_between_braces (char *str, char *brc, char *tok)
char * get_sign_and_token (char *str, char *sgn, char *tok)
char * get_token (char *str, char *tok, long keep_quotes)
int is_an_identifier (const char *tok)
int is_an_extended_identifier (const char *tok)
int is_a_string (char *str)
int is_an_integer_number (const char *str)
void clean_line (char *str)
void restore_line (char *lin)
char * compact_line (char *str1, char *str2)
char * extract_line (char *str1, char *str2)
void drop_filename (char *pnam)
void drop_pathname (char *pnam)
void simplify_pathname (char *pnam)
void strip_extension (char *fnam)
void strip_quotes (char *str)
void replace_parentheses (char *str)
void replace_dollar (char *tok)
char * format_suffixed_number (double value, long places, const char *unit)
char * unique_name (void)
char * upper_to_lower (char *s)
char * replace_char (char *s, char b, char a)
char * multiple (char c, long n)
int cistrcmp (const char *a, const char *b)
int fnstrcmp (char const *a, char const *b)
int f1flush (FILE *fp)

Macro Definition Documentation

◆ EXTERN

#define EXTERN   extern

Definition at line 4 of file tk.c.

Function Documentation

◆ build_name()

char * build_name ( const char * sgn,
char * tok,
long lr_type )

Definition at line 69 of file tk.c.

69 { /* 'tok' is modified in the process! */
70 char sign[2] = {'\0'}; /* lr-type: left ot right of '=' in assignation */
71 char prefix[STRLENGTH] = {'\0'};
72 char buf1[2*STRLENGTH] = {'\0'};
73 char buf2[2*STRLENGTH] = {'\0'};
74 static char *ptr = (char*) NULL;
75 long n, tp;
76 if (0 == strcmp(sgn, "-")) {
77 (void) strcpy(sign, "-");
78 } else {
79 (void) strcpy(sign, "");
80 }
81 n = node_id(tok);
82 if (UNDEFINED != n) { /* node */
83 if (RIGHT_VALUE == lr_type) {
84 Node_List[n].used = true;
85 }
86 tp = get_type(tok);
87 if (DIGITAL_DATA_TYPE == tp) {
88 (void) strcpy(prefix, "inode_");
89 } else if (ANALOG_DATA_TYPE == tp) {
90 (void) strcpy(prefix, "dnode_");
91 } else {
92 (void) strcpy(prefix, "xnode_"); /* should not happen, will cause a C compiler error */
93 }
94 (void) snprintf(buf1, (size_t) (STRLENGTH-1L), "%s", Node_List[n].name1);
95 ptr = strchr(buf1, ':');
96 if ((char*) NULL != ptr) { /* correction to be compatible to ANSI-C ':'-> '__' */
97 *ptr = '\0'; /* cut string in 2 substrings */
98 (void) strcpy(buf2, buf1); /* copy part of identifier before ':' */
99 (void) strcat(buf2, "__"); /* introduce a double '_' to avoid name collision */
100 (void) strcat(buf2, ptr+1); /* copy part of identifier after ':' */
101 (void) strcpy(buf1, buf2); /* only one ':' is processed */
102 }
103 if ((Node_List[n].inject) && (RIGHT_VALUE == lr_type)) {
104 if ((2L*LENGTH(buf1) + 20L) >= STRLENGTH) {
105 print_error_location("node", Node_List[n].mline, Node_List[n].mfile);
106 (void) fprintf(STDERR, " string overflow, node name <%s%s> is too long, use shorter identifiers\n", prefix, buf1);
107 print_limits();
108 print_error_banner_and_exit();
109 }
110 if (ANALOG_DATA_TYPE != Node_List[n].type) {
111 print_error_location("node", Node_List[n].mline, Node_List[n].mfile);
112 (void) fprintf(STDERR, " digital node, only injection on analog nodes is allowed\n");
113 print_error_banner_and_exit();
114 }
115 (void) snprintf(tok, (size_t) (LINLENGTH-1L), "%s(%s%s + inject_%s)", sign, prefix, buf1, buf1);
116 } else {
117 if (STRLENGTH <= (LENGTH(buf1) + 8L)) {
118 print_error_location("node", Node_List[n].mline, Node_List[n].mfile);
119 (void) fprintf(STDERR, " string overflow, node name <%s%s> is too long, use shorter identifiers\n", prefix, buf1);
120 print_limits();
121 print_error_banner_and_exit();
122 }
123 (void) snprintf(tok, (size_t) (LINLENGTH-1L), "%s%s%s", sign, prefix, buf1);
124 }
125 return tok;
126 }
127 n = var_id(tok); /* variable */
128 if (UNDEFINED != n) {
129 if (RIGHT_VALUE == lr_type) {
130 Var_List[n].used = true;
131 }
132 tp = get_type(tok);
133 if (0 != strncmp(tok, "const__", (size_t) 7)) { /* prefix for variables, not created constants */
134 if (DIGITAL_DATA_TYPE == tp) {
135 (void) strcpy(prefix, "ivar_");
136 } else if (ANALOG_DATA_TYPE == tp) {
137 (void) strcpy(prefix, "dvar_");
138 } else if (STRING_DATA_TYPE == tp) {
139 (void) strcpy(prefix, "svar_");
140 } else {
141 (void) strcpy(prefix, "xvar_"); /* should not happen, will cause a C compiler error */
142 }
143 } else { /* specific prefix for created constants */
144 if (DIGITAL_DATA_TYPE == tp) {
145 (void) strcpy(prefix, "i") ;
146 } else if (ANALOG_DATA_TYPE == tp) {
147 (void) strcpy(prefix, "d");
148 } else if (STRING_DATA_TYPE == tp) {
149 (void) strcpy(prefix, "s");
150 } else {
151 (void) strcpy(prefix, "x"); /* should not happen, will cause a C compiler error */
152 }
153 }
154 if (STRLENGTH <= (LENGTH(Var_List[n].name1) + 7L)) {
155 print_error_location("var", Var_List[n].mline, Var_List[n].mfile);
156 (void) fprintf(STDERR, " string overflow, var name <%s%s> is too long, use shorter identifiers\n", prefix, Var_List[n].name1);
157 print_limits();
158 print_error_banner_and_exit();
159 }
160 (void) snprintf(tok, (size_t) (LINLENGTH-1L), "%s%s%s", sign, prefix, Var_List[n].name1);
161 return tok;
162 }
163 n = array_id(tok); /* array */
164 if (UNDEFINED != n) {
165 if (RIGHT_VALUE == lr_type) {
166 Array_List[n].used = true;
167 }
168 tp = get_type(tok);
169 if ((DIGITAL_DATA_TYPE == tp) || (HEX_DATA_TYPE == tp)) {
170 (void) strcpy(prefix, "i_array_");
171 } else if (ANALOG_DATA_TYPE == tp) {
172 (void) strcpy(prefix, "d_array_");
173 } else {
174 (void) strcpy(prefix, "x_array_"); /* should not happen, will cause a C compiler error */
175 }
176 if (STRLENGTH <= (LENGTH(Array_List[n].name) + 9L)) {
177 print_error_location("array", Array_List[n].mline, Array_List[n].mfile);
178 (void) fprintf(STDERR, " string overflow, array name <%s%s> is too long, use shorter identifiers\n", prefix, Array_List[n].name);
179 print_limits();
180 print_error_banner_and_exit();
181 }
182 (void) snprintf(tok, (size_t) (LINLENGTH-1L), "%s%s%s", sign, prefix, Array_List[n].name);
183 return tok;
184 }
185 n = record_id(tok); /* array of pointers */
186 if (UNDEFINED != n) {
187 if (ISNOTEMPTY(sign)) {
188 (void) fprintf(STDERR, "\nNAPA Error:\n");
189 (void) fprintf(STDERR, " sign is not expected in front of a pointer array\n");
190 exit(EXIT_FAILURE);
191 }
192 (void) strcpy(prefix, "record_");
193 if (STRLENGTH <= (LENGTH(Record_List[n].name) + 9L)) {
194 print_error_location("record", Record_List[n].mline, Record_List[n].mfile);
195 (void) fprintf(STDERR, " string overflow, record name <%s%s> is too long, use shorter identifiers\n", prefix, Record_List[n].name);
196 print_limits();
197 print_error_banner_and_exit();
198 }
199 if (RIGHT_VALUE == lr_type) {
200 Record_List[n].used = true;
201 (void) snprintf(tok, (size_t) (LINLENGTH-1L), "&%s%s", prefix, Record_List[n].name);
202 } else {
203 (void) snprintf(tok, (size_t) (LINLENGTH-1L), "%s%s", prefix, Record_List[n].name);
204 }
205 return tok;
206 }
207 (void) strcpy(buf1, tok); /* other: no process */
208 if (STRLENGTH <= (LENGTH(buf1) + 1L)) {
209 print_error_location("identifier", NULL, NULL);
210 (void) fprintf(STDERR, " string overflow, identifier name <%s> is too long, use shorter identifiers\n", buf1);
211 print_limits();
212 print_error_banner_and_exit();
213 }
214 (void) snprintf(tok, (size_t) (LINLENGTH-1L), "%s%s", sign, buf1);
215 if (0 == strcmp(tok, "stdin" )) {
216 (void) strcpy(tok, "\"stdin\"");
217 }
218 if (0 == strcmp(tok, "stdout")) {
219 (void) strcpy(tok, "\"stdout\"");
220 }
221 if (0 == strcmp(tok, "stderr")) {
222 (void) strcpy(tok, "\"stderr\"");
223 }
224 return tok;
225}
print_error_location
void print_error_location(const char *type, const unsigned long *mlin, const unsigned long *mfil)
Definition fc.c:1476
print_limits
void print_limits(void)
Definition fc.c:56
get_type
long get_type(char *identifier)
Definition id.c:1190
array_id
long array_id(const char *identifier)
Definition id.c:635
node_id
long node_id(const char *identifier)
Definition id.c:718
var_id
long var_id(const char *identifier)
Definition id.c:855
record_id
long record_id(const char *identifier)
Definition id.c:796
RIGHT_VALUE
#define RIGHT_VALUE
Definition napa.h:416
Var_List
EXTERN VAR_TYPE Var_List[2047L]
Definition napa.h:970
Record_List
EXTERN RECORD_TYPE Record_List[127L]
Definition napa.h:965
Array_List
EXTERN ARRAY_TYPE Array_List[63L]
Definition napa.h:950
LENGTH
#define LENGTH(s)
Definition napa.h:397
UNDEFINED
#define UNDEFINED
Definition napa.h:331
STDERR
#define STDERR
Definition napa.h:105
Node_List
EXTERN NODE_TYPE Node_List[4095L]
Definition napa.h:962
ANALOG_DATA_TYPE
#define ANALOG_DATA_TYPE
Definition napa.h:338
LINLENGTH
#define LINLENGTH
Definition napa.h:216
ISNOTEMPTY
#define ISNOTEMPTY(s)
Definition napa.h:395
STRLENGTH
#define STRLENGTH
Definition napa.h:217
STRING_DATA_TYPE
#define STRING_DATA_TYPE
Definition napa.h:339
HEX_DATA_TYPE
#define HEX_DATA_TYPE
Definition napa.h:340
DIGITAL_DATA_TYPE
#define DIGITAL_DATA_TYPE
Definition napa.h:337
print_error_banner_and_exit
void print_error_banner_and_exit(void)
Definition pr.c:5482

References ANALOG_DATA_TYPE, array_id(), Array_List, DIGITAL_DATA_TYPE, get_type(), HEX_DATA_TYPE, ISNOTEMPTY, LENGTH, LINLENGTH, node_id(), Node_List, print_error_banner_and_exit(), print_error_location(), print_limits(), record_id(), Record_List, RIGHT_VALUE, STDERR, STRING_DATA_TYPE, STRLENGTH, UNDEFINED, var_id(), and Var_List.

Referenced by build_condition(), build_input(), build_main_loop_conditions(), build_main_loop_inject(), build_main_loop_time(), build_output(), build_update(), call_postprocess_functions(), call_user_functions(), close_IO_files(), collect_export_definitions(), collect_string_of_options(), declare_a_digital_node(), declare_an_analog_node(), declare_arrays(), declare_records(), declare_vars(), define_directives(), dump_function(), open_IO_files(), open_ping_file(), prepare_tool_synchronization(), print_adc(), print_algebra(), print_alu(), print_average(), print_bshift(), print_btoi(), print_buf(), print_bwinv(), print_change(), print_check_arrays(), print_clip(), print_clock(), print_comp(), print_copy(), print_dac(), print_dc(), print_delay(), print_delay1(), print_delay2(), print_delay3(), print_differentiator(), print_dtoi(), print_dyadic0(), print_dyadic1(), print_dyadic2(), print_dyadic3(), print_dyadic4(), print_dyadic5(), print_dyadic6(), print_dyadic7(), print_equal(), print_fzbuf(), print_fzinv(), print_gain(), print_holdtrack(), print_integrator(), print_inv(), print_itob(), print_itod(), print_latch(), print_merge(), print_minmax(), print_muller(), print_mux(), print_node_width_postprocessing(), print_noise(), print_offset(), print_osc(), print_poly(), print_quant(), print_ram(), print_rect(), print_relay(), print_rip(), print_rlshift(), print_rom(), print_rshift1(), print_rshift2(), print_sign(), print_sincos(), print_square(), print_step(), print_terminate_condition(), print_test(), print_toggle(), print_triangle(), print_trig(), print_uadc(), print_udac(), print_usertool(), print_var_width_postprocessing(), print_wsum(), print_zero(), reset_a_command_line_parameter(), reset_a_dc_node(), reset_a_digital_node(), reset_an_analog_node(), reset_arrays_function(), reset_records_function(), and reset_user_variables().

◆ build_pathname()

void build_pathname ( const char * brc,
char * tok,
const char * path,
const unsigned long * mlin,
const unsigned long * mfil )

Definition at line 230 of file tk.c.

230 {
231 char buf[LINLENGTH] = {'\0'};
232 char *s = (char*) NULL;
233 char *t = (char*) NULL;
234 if (0 == strcmp(brc, "<>")) { /* pathname of a file of a generic library */
235 (void) snprintf(buf, (size_t) (LINLENGTH-1L), "%s/%s", path, tok); /* complete path e.g."/NAPA/hdr" */
236 s = buf;
237 t = tok;
238 while ('\0' != *s) {
239 if (('.' != *s) && ('.' == *(s+1)) && ('/' == *(s+2))) { /* remove extra './' */
240 *t = *s;
241 s++;
242 t++;
243 s += 2;
244 }
245 *t = *s;
246 s++;
247 t++;
248 }
249 *t = '\0';
250 } else if (0 != strcmp(brc, "\"\"")) { /* a user's file */
251 print_error_location("pathname", mlin, mfil);
252 if (2L == LENGTH(brc)) {
253 (void) fprintf(STDERR, " %c%s%c is not a correct pathname\n", brc[0], tok, brc[1]);
254 } else {
255 (void) fprintf(STDERR, " the pathname <%s> is not correct\n", tok);
256 }
257 print_error_banner_and_exit();
258 }
259 return;
260}

References LENGTH, LINLENGTH, print_error_banner_and_exit(), print_error_location(), and STDERR.

Referenced by get_data(), get_header(), get_void(), process_cell(), and process_gen().

◆ cistrcmp()

int cistrcmp ( const char * a,
const char * b )

Definition at line 1817 of file tk.c.

1817 { /* case insensitive strcmp() */
1818 int d;
1819 for (;; a++, b++) {
1820 d = (int) (tolower((unsigned char)*a) - tolower((unsigned char)*b));
1821 if ((0 != d) || (!(*a))) {
1822 return d;
1823 }
1824 }
1825}

◆ clean_line()

void clean_line ( char * str)

Definition at line 1397 of file tk.c.

1397 {
1398 char *s = (char*) NULL;
1399 char *t = (char*) NULL;
1400 int flag;
1401 flag = false;
1402 t = str; /* remove NAPA comments <//...> of end of line */
1403 while (!((('/' == *t) && ('/' == *(t+1)) && (!flag)) || ('\0' == *t))) {
1404 if ('"' == *t) {
1405 flag = !flag; /* string can include double slash */
1406 }
1407 t++;
1408 }
1409 *t = '\0';
1410
1411 t = str;
1412 while ('\0' != *t) { /* replace any space (like tabs) by one blank */
1413 if (isspace((int) *t)) {
1414 *t = ' ';
1415 }
1416 t++;
1417 }
1418
1419 t = str;
1420 s = str;
1421 while ((isspace((int) *t)) && (isspace((int) *(t+1)))) { /* shrink double blanks */
1422 t++;
1423 }
1424
1425 if ('#' == *t) {
1426 *str = '#';
1427 *(str+1) = '\0'; /* comment is cleared, process is completed */
1428 return;
1429 }
1430
1431 while (('\0' != *t) && ('\n' != *t)) {
1432 *s = *t;
1433 s++;
1434 t++;
1435 }
1436 *s = '\0';
1437 *t = '\0';
1438
1439 while (('\0' == *s) || ('\n' == *s)) {
1440 s--;
1441 }
1442
1443 while (isspace((int) *s)) { /* remove blanks at end of line */
1444 s--;
1445 }
1446 *(s+1) = '\0';
1447
1448 return;
1449}

Referenced by expand_records(), expand_update_definitions(), get_a_line(), rearrange_data_interfaces(), and reset_user_variables().

◆ clean_parentheses()

void clean_parentheses ( char * tok)

Definition at line 403 of file tk.c.

403 { /* remove useless external parenthesis */
404 char buf[LINLENGTH] = {'\0'};
405 long n;
406 char *s = (char*) NULL;
407 s = tok;
408 if ('(' != *s) {
409 return; /* no simplification */
410 }
411 s += ((int) strlen(tok)) - 1;
412 if (')' != *s) {
413 return; /* no simplification */
414 }
415 s = tok;
416 n = 0L;
417 while ('\0' != *s) {
418 if ('(' == *s) {
419 n++;
420 } else if (')' == *s) {
421 n--;
422 }
423 s++;
424 if ((0L == n) && ('\0' != *s)) {
425 return; /* no simplification */
426 }
427 }
428 s = tok + 1; /* suppress first parenthesis */
429 (void) strcpy(buf, s);
430 s = buf + ((int) strlen(buf)) - 1;
431 *s = '\0'; /* suppress last parenthesis */
432 s = buf;
433 (void) strcpy(tok, s);
434 clean_parentheses(tok); /* recursive call to clean further */
435 return;
436}
clean_parentheses
void clean_parentheses(char *tok)
Definition tk.c:403

References clean_parentheses(), and LINLENGTH.

Referenced by build_condition(), build_main_loop_inject(), clean_parentheses(), get_assert(), get_declare(), get_drop(), get_dump(), get_init(), get_inject(), get_opcode(), get_sampling(), get_stuck(), get_terminate(), get_update(), get_var(), redefine_nodes(), reset_a_dc_node(), and stuck_nodes().

◆ compact_line()

char * compact_line ( char * str1,
char * str2 )

Definition at line 1468 of file tk.c.

1468 { /* remove extra spaces */
1469 static char *s1 = (char*) NULL;
1470 static char *s2 = (char*) NULL;
1471 s1 = str1;
1472 s2 = str2;
1473 while (('\0' != *s1) && ('\0' != *(s1+1))) {
1474 if ((isspace((int) *s1)) && (isspace((int) *(s1+1)))) {
1475 s1++;
1476 } else {
1477 *s2 = *s1;
1478 s1++;
1479 s2++;
1480 }
1481 }
1482 *s2 = *s1;
1483 return str2;
1484}

Referenced by is_a_string(), and process_gen().

◆ drop_filename()

void drop_filename ( char * pnam)

Definition at line 1510 of file tk.c.

1510 {
1511 char *sb = (char*) NULL;
1512 char *se = (char*) NULL;
1513 sb = pnam;
1514 se = pnam+ LENGTH(pnam);
1515 while (se != sb) {
1516 if ('/' == *se) {
1517 *se = '\0';
1518 return;
1519 }
1520 se--;
1521 }
1522 return;
1523}

References LENGTH.

◆ drop_pathname()

void drop_pathname ( char * pnam)

Definition at line 1526 of file tk.c.

1526 {
1527 char *sb = (char*) NULL;
1528 char *se = (char*) NULL;
1529 sb = pnam;
1530 se = pnam+ LENGTH(pnam);
1531 while (se != sb) {
1532 if ('/' == *se) {
1533 (void) strcpy(pnam, 1 + se);
1534 return;
1535 }
1536 se--;
1537 }
1538 (void) strcpy(pnam, se); /* filename without pathname */
1539 return;
1540}

References LENGTH.

Referenced by define_macros(), extract_directory(), get_header(), line_parsing(), print_C_code_banner_b(), and process_command_line().

◆ expand_indirections()

void expand_indirections ( char * str)

Definition at line 717 of file tk.c.

717 {
718 double d;
719 char *s = (char*) NULL;
720 char *b = (char*) NULL;
721 char *t = (char*) NULL;
722 char *v = (char*) NULL;
723 char buf[LINLENGTH] = {'\0'};
724 char tok[STRLENGTH] = {'\0'};
725 char val[STRLENGTH] = {'\0'};
726 long m;
727 (void) strcpy(buf, str);
728 b = buf;
729 s = str;
730 while ('\0' != *b) {
731 if ('#' != *b) {
732 *s = *b;
733 b++;
734 s++;
735 } else {
736 b++;
737 t = tok;
738 while (isalnum((int) *b) || ('_' == *b) || (':' == *b) || ('@' == *b)) {
739 *t = *b;
740 b++;
741 t++;
742 }
743 *t = '\0';
744 m = var_id(tok);
745 if (UNDEFINED != m) {
746 Var_List[m].used = true;
747 if (ISNOTEMPTY(Var_List[m].value)) {
748 if (ANALOG_DATA_TYPE == constant_type(Var_List[m].value)) { /* format the analog number */
749 if (1 == sscanf(Var_List[m].value, "%lf", &d)) {
750 (void) snprintf(val, (size_t) (STRLENGTH-1L), "%s", format_suffixed_number(d, 3, ""));
751 } else {
752 (void) strcpy(val, Var_List[m].value);
753 }
754 } else {
755 (void) strcpy(val, Var_List[m].value);
756 }
757 } else {
758 (void) strcpy(val, Var_List[m].value);
759 }
760 } else if ((0 == strcmp(tok, "fs")) && (Periodic_Flag)) {
761 (void) snprintf(val, (size_t) (STRLENGTH-1L), "%s", format_suffixed_number(Sampling_List.frequency, 3, " Hz"));
762 } else if ((0 == strcmp(tok, "ts")) && (Periodic_Flag)) {
763 (void) snprintf(val, (size_t) (STRLENGTH-1L), "%s", format_suffixed_number(Sampling_List.period, 3, " s" ));
764 } else if (0 == strcmp(tok, "random_seed")) {
765 (void) snprintf(val, (size_t) (STRLENGTH-1L), "%ld", Seed_List.rndseed);
766 } else if (UNDEFINED != get_type(tok)) {
767 (void) strcpy(val, tok);
768 } else {
769 (void) strcpy(val, "???");
770 }
771 m = directive_id(tok);
772 if (UNDEFINED != m) {
773 if (ISNOTEMPTY(Directive_List[m].value)) {
774 (void) strcpy(val, Directive_List[m].value);
775 } else {
776 (void) strcpy(val, "?");
777 }
778 }
779 v = val;
780 while ('\0' != *v) {
781 if ('"' != *v) {
782 *s = *v;
783 s++;
784 }
785 v++;
786 }
787 *s = ' ';
788 *v = '\0';
789 }
790 }
791 *s = '\0';
792 return;
793}
constant_type
long constant_type(char *identifier)
Definition id.c:1130
directive_id
long directive_id(const char *identifier)
Definition id.c:707
Seed_List
EXTERN RANDOMSEED_TYPE Seed_List
Definition napa.h:979
Sampling_List
EXTERN SAMPLING_TYPE Sampling_List
Definition napa.h:978
Directive_List
EXTERN DIRECTIVE_TYPE Directive_List[255L]
Definition napa.h:955
Periodic_Flag
EXTERN int Periodic_Flag
Definition napa.h:873
format_suffixed_number
char * format_suffixed_number(double value, long places, const char *unit)
Definition tk.c:1725

References ANALOG_DATA_TYPE, constant_type(), directive_id(), Directive_List, format_suffixed_number(), get_type(), ISNOTEMPTY, LINLENGTH, Periodic_Flag, Sampling_List, Seed_List, STRLENGTH, UNDEFINED, var_id(), and Var_List.

Referenced by expand_string_variables(), line_parsing(), and reset_user_variables().

◆ expand_iterative_identifiers()

void expand_iterative_identifiers ( char * str,
unsigned long * mlin,
const unsigned long * mfil )

Definition at line 796 of file tk.c.

796 {
797 char buf[LINLENGTH] = {'\0'};
798 char tok1[STRLENGTH] = {'\0'};
799 char tok2[STRLENGTH] = {'\0'};
800 char tok3[STRLENGTH] = {'\0'};
801 char tok4[LINLENGTH] = {'\0'};
802 char *s = (char*) NULL;
803 char *t = (char*) NULL;
804 char *u = (char*) NULL;
805 char *n = (char*) NULL;
806 char *b = (char*) NULL;
807 char *e = (char*) NULL;
808 char *f = (char*) NULL;
809 long i, begin, end;
810
811 (void) strcpy(buf, str);
812
813 s = str;
814 t = buf;
815 u = buf + (7*LINLENGTH)/8; /* reserve some margin */
816
817 /* principle: scan 'buf' (pointer t), process and write back in 'str' (pointer s) */
818
819 while (('\0' != *t) && (t < u)) {
820
821 if (('.' == *t) && ('.' == *(t+1))) { /* PERHAPS AN ITERATIVE IDENTIFIER? */
822 n = tok1;
823 b = tok2;
824 e = tok3;
825
826 while ((!isspace((int) *t)) && (t != buf)) { /* go backwards until beginning of token */
827 s--;
828 t--;
829 }
830 while (('.' != *t) && ('\0' != *t)) { /* stops at '.' */
831 *n = *t;
832 t++;
833 n++;
834 }
835 if ('.' != *(t+1)) { /* not a double point, an array of pointer element */
836 *n = *t;
837 t++;
838 n++;
839 }
840 while (('.' != *t) && ('\0' != *t)) { /* stops at '.' */
841 *n = *t;
842 t++;
843 n++;
844 }
845 t--;
846 while ((isdigit((int) *t)) && (t != buf)) {
847 t--;
848 n--;
849 }
850 *n = '\0';
851 if (ISEMPTY(tok1)) { /* not an iterative identifier, ignore! */
852 t += 2;
853 continue;
854 }
855 do { /* get id start */
856 t++;
857 *b = *t;
858 b++;
859 } while (('.' != *t) && ('\0' != *t));
860 b--;
861 *b = '\0';
862 if (1 > sscanf(tok2, "%li", &begin)) { /* tok2 contains the first number */
863 *mlin = *mlin + 1UL;
864 print_error_location("iterative identifier", mlin, mfil);
865 (void) fprintf(STDERR, " error during expansion of start index of identifier <%s>\n", tok1);
866 *s = '\0';
867 print_error_banner_and_exit();
868 }
869 t++;
870 do { /* get id end */
871 t++;
872 *e = *t;
873 e++;
874 } while ((!isspace((int) *t)) && ('\0' != *t));
875 e--;
876 *e = '\0';
877 if (1 > sscanf(tok3, "%li", &end)) { /* tok3 contains the second number */
878 *mlin = *mlin + 1UL;
879 print_error_location("iterative identifier", mlin, mfil);
880 (void) fprintf(STDERR, " error during expansion of stop index of identifier <%s>\n", tok1);
881 *s = '\0';
882 print_error_banner_and_exit();
883 }
884 while ((!isspace((int) *s)) && (s != str)) {
885 s--;
886 }
887 t--;
888 /* generate the identifiers: forward counting or backward counting */
889 if (begin <= end) { /* forward counting */
890 for (i = begin; i <= end; i++) {
891 (void) snprintf(tok4, (size_t) (LINLENGTH-1L), " %s%ld", tok1, i);
892 f = tok4;
893 while ('\0' != *f) {
894 *s = *f;
895 s++;
896 f++;
897 }
898 }
899 } else { /* backward counting */
900 for (i = begin; i >= end; i--) {
901 (void) snprintf(tok4, (size_t) (LINLENGTH-1L), " %s%ld", tok1, i);
902 f = tok4;
903 while ('\0' != *f) {
904 *s = *f;
905 s++;
906 f++;
907 }
908 }
909 }
910 *s = ' ';
911 s--;
912 continue;
913 }
914
915 if ('"' == *t) { /* copy string, no change */
916 do {
917 *s = *t;
918 s++;
919 t++;
920 } while (('"' != *t) && ('\0' != *t));
921 *s = *t;
922 t++;
923 s++;
924 continue;
925 }
926
927 if ('<' == *t) { /* copy string, NAPA library file, no change */
928 do {
929 *s = *t;
930 s++;
931 t++;
932 } while (('>' != *t) && ('\0' != *t));
933 *s = *t;
934 t++;
935 s++;
936 continue;
937 }
938
939 if ('[' == *t) { /* copy characters between brackets, no change */
940 do {
941 *s = *t;
942 s++;
943 t++;
944 } while ((']' != *t) && ('\0' != *t));
945 *s = *t;
946 t++;
947 s++;
948 continue;
949 }
950
951 /* normal identifier: copy char by char */
952 *s = *t;
953 s++;
954 t++;
955
956 }
957
958 if (t >= u) {
959 print_error_location("iterative identifier", mlin, mfil);
960 (void) fprintf(STDERR, " overflow during line expansion, please limit the iteration span\n");
961 print_error_banner_and_exit();
962 }
963
964 *s = '\0';
965 return;
966}
ISEMPTY
#define ISEMPTY(s)
Definition napa.h:394

References ISEMPTY, LINLENGTH, print_error_banner_and_exit(), print_error_location(), STDERR, and STRLENGTH.

Referenced by get_a_line().

◆ expand_nodeset()

char * expand_nodeset ( char * str,
long n,
long w,
const unsigned long * mlin,
const unsigned long * mfil )

Definition at line 969 of file tk.c.

969 {
970 char tok1[LINLENGTH] = {'\0'};
971 char tok2[LINLENGTH] = {'\0'};
972 char iter[STRLENGTH] = {'\0'};
973 char ch[STRLENGTH] = {'\0'};
974 char *s1 = (char*) NULL;
975 char *s2 = (char*) NULL;
976 char *s3 = (char*) NULL;
977 long i1, i2, i, j;
978 int flag;
979 (void) strcpy(tok1, str);
980 s1 = tok1;
981 s2 = tok2;
982 while ('\0' != *s1) {
983 while (('[' != *s1) && ('\0' != *s1)) {
984 *s2 = *s1;
985 s1++;
986 s2++;
987 }
988 s1++;
989 (void) strcpy(iter, "");
990 s3 = iter;
991 while ((']' != *s1) && ('\0' != *s1)) {
992 if ('.' == *s1) {
993 *s3 = ' ';
994 } else {
995 *s3 = *s1;
996 }
997 s1++;
998 s3++;
999 }
1000 s1++;
1001 *s3 = '\0';
1002 if (ISEMPTY(iter)) {
1003 break;
1004 }
1005 flag = sscanf(iter, "%li %li", &i1, &i2); /* process iterator */
1006 if (2 != flag) {
1007 print_error_location("syntax", mlin, mfil);
1008 (void) fprintf(STDERR, " invalid iterator [%s] in nodeset\n", iter);
1009 print_error_banner_and_exit();
1010 }
1011 if (((i2-i1) != (w-1L)) && ((i1-i2) != (w-1L))) {
1012 print_error_location("syntax", mlin, mfil);
1013 (void) fprintf(STDERR, " iterator [%ld..%ld] does not match nodeset declaration [%ld]\n", i1, i2, w);
1014 print_error_banner_and_exit();
1015 }
1016 if (i2 > i1) {
1017 i = i1 + n;
1018 } else {
1019 i = i1 - n;
1020 }
1021 (void) snprintf(ch, (size_t) (STRLENGTH-1L), "%ld", i);
1022 for (j = 0L; 6L > j; j++) {
1023 if ('\0' == ch[j]) {
1024 break;
1025 }
1026 *s2 = ch[j];
1027 s2++;
1028 }
1029 }
1030 *s2 = '\0';
1031 (void) strcpy(str, tok2);
1032 return str;
1033}

References ISEMPTY, LINLENGTH, print_error_banner_and_exit(), print_error_location(), STDERR, and STRLENGTH.

Referenced by get_node().

◆ extract_directory()

void extract_directory ( char * pn,
char * fn,
long depth )

Definition at line 339 of file tk.c.

339 { /* build directory pathname from dir and file */
340 long len; /* move pathname directory of 'fn' to 'pn' */
341 char *s = (char*) NULL;
342 char *t = (char*) NULL;
343 char buf1[LINLENGTH] = {'\0'};
344 char buf2[LINLENGTH] = {'\0'};
345 /* this is not a pathname for sure ? */
346 if ((char*) NULL == strstr(fn, "/")) {
347 (void) strcpy(pn, "");
348 return;
349 }
350 /* it is still possible that it is not a pathname */
351 (void) strcpy(buf1, fn);
352 (void) strcpy(buf2, "");
353 s = buf1 + ((int) strlen(buf1)) - 1; /* go to end of file */
354 while (('/' != *s) && (s >= buf1)) { /* go back to detect last slash */
355 s--;
356 }
357 s++;
358 *s = '\0'; /* place an end of string: dir pathname */
359 /* buf1[] contains now the part of directory pathname which was in the file name this directory follows the NAPA file system */
360 /* naming ? absolute pathname: "/ etc " */
361 if ('/' == buf1[0]) {
362 s = buf1; /* pathname without any modifications */
363 (void) strcpy(pn, s); /* pn: pathname without file name */
364 drop_pathname(fn); /* fn: file name without pathname */
365 /* ? path refers to dir containing main file: "~/ etc " */
366 } else if (('~' == buf1[0]) && ('/' == buf1[1])) {
367 t = buf1 + 2;
368 (void) snprintf(buf2, (size_t) (LINLENGTH-1L),"%s%s", Cur_Lib_Name[depth], t);
369 len = LENGTH(buf2);
370 if (LINLENGTH <= len) {
371 (void) fprintf(STDERR, "\nNAPA Error:\n");
372 (void) fprintf(STDERR, " string buffer overflow while tracking pathname\n");
373 (void) fprintf(STDERR, " current limit is %ld characters (LINLENGTH)\n", LINLENGTH);
374 exit(EXIT_FAILURE);
375 }
376 s = buf2;
377 (void) strcpy(pn, s); /* pn: pathname without file name */
378 drop_pathname(fn); /* fn: file name without pathname */
379 /* ? path refers to dir containing the cell file being processed "./ etc " */
380 } else if (('.' == buf1[0]) && ('/' == buf1[1])) {
381 t = buf1 + 2;
382 (void) snprintf(buf2, (size_t) (LINLENGTH-1L), "%s%s", pn, t); /* use pathname of function input */
383 len = LENGTH(buf2);
384 if (LINLENGTH <= len) {
385 (void) fprintf(STDERR, "\nNAPA Error:\n");
386 (void) fprintf(STDERR, " string buffer overflow while tracking pathname\n");
387 (void) fprintf(STDERR, " current limit is %ld characters (LINLENGTH)\n", LINLENGTH);
388 exit(EXIT_FAILURE);
389 }
390 s = buf2;
391 (void) strcpy(pn, s); /* pn: pathname without file name */
392 drop_pathname(fn); /* fn: file name without pathname */
393 /* ? refers to working directory " etc ", BUT also compatible with no pathname string */
394 } else {
395 s = buf1; /* pathname without any modifications */
396 (void) strcpy(pn, s); /* pn: pathname without file name */
397 drop_pathname(fn); /* fn: file name without pathname */
398 }
399 return;
400}
Cur_Lib_Name
EXTERN char Cur_Lib_Name[31L][2047L]
Definition napa.h:932
drop_pathname
void drop_pathname(char *pnam)
Definition tk.c:1526

References Cur_Lib_Name, drop_pathname(), LENGTH, LINLENGTH, and STDERR.

Referenced by get_data(), get_header(), get_void(), process_cell(), process_gen(), and resolve_pathnames().

◆ extract_line()

char * extract_line ( char * str1,
char * str2 )

Definition at line 1487 of file tk.c.

1487 { /* str1 -> "abc..z\nABC...Z" */
1488 char *s1 = (char*) NULL; /* str1 -> "abc..z\\nABC...Z" */
1489 char *s2 = (char*) NULL;
1490 s1 = str1; /* s1 -> 'a' */
1491 s2 = str2;
1492 while ('\0' != *s1) {
1493 *s2 = *s1;
1494 if ('\n' == *s1) { /* detect '\n' (case "abc..z\nABC...Z" ) */
1495 break;
1496 }
1497 if (('\\' == *s1) && ('n' == *(s1+1))) { /* detect '\\n' (case "abc..z\\nABC...Z") */
1498 s1++;
1499 break;
1500 }
1501 s1++;
1502 s2++;
1503 }
1504 *s2 = '\0';
1505 str1 = s1 + 1; /* str1 -> 'A' */
1506 return str1;
1507}

Referenced by command_line_usage_function(), print_C_code_banner_a(), and print_output_banner_4().

◆ extract_prefix()

char * extract_prefix ( char * nam)

Definition at line 1086 of file tk.c.

1086 {
1087 char *s = (char*) NULL;
1088 char *t = (char*) NULL;
1089 long len;
1090 s = nam;
1091 t = nam;
1092 len = LENGTH(nam);
1093 if (3L >= len) {
1094 *s = '\0';
1095 return nam;
1096 }
1097 t += ((int) len) - 3;
1098 while (s != t) {
1099 if (('_' == *s) || ('_' == *(s+1))) {
1100 *(s+3) = '\0';
1101 return nam;
1102 }
1103 s++;
1104 }
1105 *(s-3) = '\0';
1106 return nam;
1107}

References LENGTH.

◆ f1flush()

int f1flush ( FILE * fp)

Definition at line 1843 of file tk.c.

1843 {
1844 if ((FILE*) NULL != fp) {
1845 if (EOF == fflush(fp)) {
1846 print_error_location("I/O", (unsigned long*) NULL, (unsigned long*) NULL);
1847 (void) fprintf(STDERR, " Flushing data from buffers I/O was not successful\n");
1848 print_error_banner_and_exit();
1849 }
1850 }
1851 return 0;
1852}

References print_error_banner_and_exit(), print_error_location(), and STDERR.

Referenced by get_data(), last_message(), print_location(), process_cell(), process_error_if_any(), process_gen(), that_s_all(), and wall_clock().

◆ fnstrcmp()

int fnstrcmp ( char const * a,
char const * b )

Definition at line 1828 of file tk.c.

1828 { /* file name strcmp() compare depending on OS */
1829 int d;
1830 for (;; a++, b++) {
1831#if (IS_WIN64 == PLATFORM)
1832 d = (int) (tolower((unsigned char)*a) - tolower((unsigned char)*b));
1833#else
1834 d = (int) (*a - *b);
1835#endif
1836 if ((0 != d) || (!(*a))) {
1837 return d;
1838 }
1839 }
1840}

Referenced by get_dump(), get_header(), get_input(), get_output(), get_post(), and record_file_nam().

◆ format_suffixed_number()

char * format_suffixed_number ( double value,
long places,
const char * unit )

Definition at line 1725 of file tk.c.

1725 {
1726 static char result[64] = {'\0'};
1727 const char prefixes[] = {'y', 'z', 'a', 'f', 'p', 'n', 'u', 'm', ' ', 'k', 'M', 'G', 'T', 'P', 'E', 'Z', 'Y'};
1728 long p_lo = 0L;
1729 long p = 8L;
1730 long p_hi = 16L;
1731 char sgn = ' ';
1732 if (0.0 > value) {
1733 sgn = '-';
1734 value = -value;
1735 }
1736 while ((p > p_lo) && ISNOTSMALL(value) && ( (1.0+_SMALL_) >= value)) {
1737 value *= 1000.0;
1738 p--;
1739 }
1740 while ((p < p_hi) && ISNOTSMALL(value) && (1000.0*(1.0-_SMALL_) <= value)) {
1741 value /= 1000.0;
1742 p++;
1743 }
1744 if (3L < places) {
1745 if (100.0*(1.0-_SMALL_) <= value) {
1746 places -= 3L;
1747 } else if ( 10.0*(1.0-_SMALL_) <= value) {
1748 places -= 2L;
1749 } else {
1750 places -= 1L;
1751 }
1752 (void) snprintf(result, (size_t) 63, "%c%.*f %c%s", sgn, (int) places, value, prefixes[p], unit);
1753 } else {
1754 if (100.0*(1.0-_SMALL_) <= value) {
1755 (void) snprintf(result, (size_t) 63, "%c%3.0f %c%s", sgn, value, prefixes[p], unit);
1756 } else if ( 10.0*(1.0-_SMALL_) <= value) {
1757 (void) snprintf(result, (size_t) 63, "%c%2.1f %c%s", sgn, value, prefixes[p], unit);
1758 } else {
1759 (void) snprintf(result, (size_t) 63, "%c%1.2f %c%s", sgn, value, prefixes[p], unit);
1760 }
1761 }
1762 return result;
1763}
_SMALL_
#define _SMALL_
Definition napa.h:146
ISNOTSMALL
#define ISNOTSMALL(x)
Definition napa.h:385

References _SMALL_, and ISNOTSMALL.

Referenced by build_main_loop_control1(), build_main_loop_segment_begin(), expand_indirections(), print_C_code_banner_b(), print_output_banner_1(), and that_s_all().

◆ get_function_identifier()

char * get_function_identifier ( char * str,
char * fun_id,
char * fun_parm )

Definition at line 1036 of file tk.c.

1036 {
1037 long n;
1038 char tok1[STRLENGTH] = {'\0'};
1039 char tok2[STRLENGTH] = {'\0'};
1040 char sgn[2] = {'\0'};
1041 char brc[3] = {'\0'};
1042 static char *b = (char*) NULL;
1043 str = get_sign_and_token(str, sgn, tok1); /* get possible identifier */
1044 b = str;
1045 n = directive_id(tok1); /* ignore defined directive */
1046 if (UNDEFINED != n) {
1047 str = get_sign_and_token(str, sgn, tok1); /* get next possible identifier */
1048 }
1049 (void) get_token_between_braces(str, brc, tok2);
1050 if (ISNOTEMPTY(tok1) && (0 == strcmp(brc, "()")) && (is_an_identifier(tok1)) && (' ' != *(b-1))) { /* ignore option */
1051 (void) strcpy(fun_id, tok1);
1052 (void) strcpy(fun_parm, tok2);
1053 } else {
1054 (void) strcpy(fun_id, ""); /* no success */
1055 (void) strcpy(fun_parm, "");
1056 }
1057 return b;
1058}
is_an_identifier
int is_an_identifier(const char *tok)
Definition tk.c:1327
get_token_between_braces
char * get_token_between_braces(char *str, char *brc, char *tok)
Definition tk.c:1110
get_sign_and_token
char * get_sign_and_token(char *str, char *sgn, char *tok)
Definition tk.c:1188

References directive_id(), get_sign_and_token(), get_token_between_braces(), is_an_identifier(), ISNOTEMPTY, STRLENGTH, and UNDEFINED.

Referenced by collect_functions(), and get_node().

◆ get_output_and_scaling()

char * get_output_and_scaling ( char * str,
char * sgn,
char * out,
char * scl )

Definition at line 1061 of file tk.c.

1061 {
1062 char tok1[STRLENGTH] = {'\0'};
1063 char tok2[STRLENGTH] = {'\0'};
1064 char brc[3] = {'\0'};
1065 char *b = (char*) NULL;
1066 str = get_sign_and_token(str, sgn, tok1); /* get output with sign */
1067 do {
1068 b = strchr(tok1, '\'');
1069 if ((char*) NULL != b) {
1070 *b = '$'; /* replace character ' by $ */
1071 }
1072 } while ((char*) NULL != b);
1073 b = str;
1074 str = get_token_between_braces(str, brc, tok2); /* get scaling if it exists */
1075 if (ISNOTEMPTY(tok1) && (0 == strcmp(brc, "()")) && (is_an_identifier(tok1)) && (' ' != *(b-1))) { /* ignore scaling */
1076 (void) strcpy(out, tok1); /* scaling */
1077 (void) strcpy(scl, tok2);
1078 } else {
1079 (void) strcpy(out, tok1); /* no scaling */
1080 (void) strcpy(scl, "");
1081 }
1082 return str;
1083}

References get_sign_and_token(), get_token_between_braces(), is_an_identifier(), ISNOTEMPTY, and STRLENGTH.

Referenced by build_output(), print_output_banner_2(), and print_output_banner_function().

◆ get_sign_and_token()

char * get_sign_and_token ( char * str,
char * sgn,
char * tok )

Definition at line 1188 of file tk.c.

1188 {
1189 char buf[STRLENGTH] = {'\0'};
1190 str = get_token(str, buf, true); /* strings must be preserved */
1191 if (0 == strcmp(buf, "+")) {
1192 (void) strcpy(sgn, "+");
1193 str = get_token(str, tok, false);
1194 } else if (0 == strcmp(buf, "-")) {
1195 (void) strcpy(sgn, "-");
1196 str = get_token(str, tok, false);
1197 } else {
1198 (void) strcpy(sgn, "");
1199 (void) strcpy(tok, buf);
1200 }
1201 return str;
1202}
get_token
char * get_token(char *str, char *tok, long keep_quotes)
Definition tk.c:1210

References get_token(), and STRLENGTH.

Referenced by authorize_option(), build_condition(), build_node_dependencies(), build_record_dependencies(), build_to_be_delayed_node_list(), build_update_dependencies(), build_var_dependencies(), call_postprocess_functions(), check_array_usage(), check_record_usage(), check_types(), collect_export_definitions(), create_nodes(), declaration_type_B(), declare_a_digital_node(), declare_an_analog_node(), declare_vars(), determine_output_segment_rate(), dump_function(), expand_records(), get_alias(), get_command_line(), get_debug(), get_decimate(), get_declare(), get_directive(), get_fs_ts(), get_function_identifier(), get_gateway(), get_inject(), get_interlude(), get_interpolate(), get_node(), get_nominal(), get_opcode(), get_output_and_scaling(), get_post(), get_stuck(), get_update(), get_var(), mark_directives(), name_mangling(), node_determination(), print_adc(), print_bshift(), print_btoi(), print_buf(), print_bwinv(), print_change(), print_clip(), print_clock(), print_comp(), print_dac(), print_delay(), print_delay1(), print_delay2(), print_delay3(), print_differentiator(), print_dtoi(), print_equal(), print_fzbuf(), print_fzinv(), print_gain(), print_holdtrack(), print_integrator(), print_inv(), print_itob(), print_itod(), print_latch(), print_merge(), print_mux(), print_noise(), print_offset(), print_osc(), print_poly(), print_quant(), print_rect(), print_relay(), print_rip(), print_rlshift(), print_rshift1(), print_rshift2(), print_sign(), print_sincos(), print_square(), print_step(), print_toggle(), print_triangle(), print_trig(), print_uadc(), print_udac(), print_wsum(), print_zero(), process_condition(), process_init(), purge_constants_in_ganging(), purge_constants_in_options(), redefine_nodes(), reset_an_analog_node(), reset_records_function(), syntax_nodes(), and syntax_records().

◆ get_token()

char * get_token ( char * str,
char * tok,
long keep_quotes )

Definition at line 1210 of file tk.c.

1210 {
1211 char *t = (char*) NULL;
1212 char a, b;
1213 t = tok;
1214 while (isspace((int) *str)) { /* skip whitespace and tab */
1215 str++;
1216 }
1217 if ('"' == *str) { /* if first char== '"', read til '"' or end of line */
1218 if (keep_quotes) { /* record or drop quotes */
1219 *(t++) = *(str++);
1220 } else {
1221 str++;
1222 }
1223 while (('"' != *str) && ('\0' != *str)) {
1224 *(t++) = *(str++);
1225 }
1226 if ('"' == *str) {
1227 if (keep_quotes) { /* record or drop quotes */
1228 *(t++) = *(str++);
1229 } else {
1230 str++;
1231 }
1232 }
1233 } else if (('>' == *str) && ('=' == *(str+1))) { /* 'greater than' >= */
1234 *(t++) = *(str++);
1235 *t = *str;
1236 str++;
1237 t++;
1238 } else if (('<' == *str) && ('=' == *(str+1))) { /* 'smaller than' <= */
1239 *(t++) = *(str++);
1240 *t = *str;
1241 str++;
1242 t++;
1243 } else if (('=' == *str) && ('=' == *(str+1))) { /* 'equal to' == */
1244 *(t++) = *(str++);
1245 *t = *str;
1246 str++;
1247 t++;
1248 } else if (('!' == *str) && ('=' == *(str+1))) { /* 'not equal to' != */
1249 *(t++) = *(str++);
1250 *t = *str;
1251 str++;
1252 t++;
1253 } else if (('>' == *str) && ('>' == *(str+1))) { /* 'left shift << */
1254 *(t++) = *(str++);
1255 *t = *str;
1256 str++;
1257 t++;
1258 } else if (('<' == *str) && ('<' == *(str+1))) { /* 'right shift' >> */
1259 *(t++) = *(str++);
1260 *t = *str;
1261 str++;
1262 t++;
1263 } else if (('&' == *str) && ('&' == *(str+1))) { /* 'logical and' && */
1264 *(t++) = *(str++);
1265 *t = *str;
1266 str++;
1267 t++;
1268 } else if (('|' == *str) && ('|' == *(str+1))) { /* 'logical or' || */
1269 *(t++) = *(str++);
1270 *t = *str;
1271 str++;
1272 t++;
1273 } else if (('?' == *str) || (':' == *str) || ('%' == *str)) {
1274 *(t++) = ' ';
1275 *(t++) = *(str++);
1276 *(t++) = ' ';
1277 } else if (('0' == *str) && (('x' == *(str+1)) || ('X' == *(str+1)))) { /* hexa number */
1278 *(t++) = *(str++);
1279 if ('X' == *str) {
1280 *t = 'x';
1281 } else {
1282 *t = *str;
1283 }
1284 str++;
1285 t++;
1286 while (isdigit((int) *str)
1287 || ('a' == *str) || ('b' == *str) || ('c' == *str) || ('d' == *str) || ('e' == *str) || ('f' == *str)
1288 || ('A' == *str) || ('B' == *str) || ('C' == *str) || ('D' == *str) || ('E' == *str) || ('F' == *str)) {
1289 *t = (char) toupper((int) *str);
1290 str++;
1291 t++;
1292 }
1293 } else if (isdigit((int) *str)) { /* if it starts with a digit, get the entire number */
1294 while (isdigit((int) *str) || ('.' == *str) || ('e' == *str) || ('E' == *str) || ('L' == *str) || ('F' == *str)) {
1295 if (('e' == *str) || ('E' == *str)) {
1296 a = *(str + 1);
1297 b = *(str + 2);
1298 if (isdigit((int) a) || ((('+' == a) || ('-' == a)) && isdigit((int) b))) {
1299 *(t++) = *(str++);
1300 *(t++) = *(str++);
1301 } else {
1302 break;
1303 }
1304 } else {
1305 *(t++) = *(str++);
1306 }
1307 }
1308 } else { /* otherwise read all continuous alphanumeric */
1309 while (isalnum((int) *str) || ('_' == *str) || (':' == *str) || ('$' == *str) || ('°' == *str)
1310 || ('\'' == *str) || ('#' == *str) || ('.' == *str) || ('@' == *str) || ('&' == *str)) {
1311 *(t++) = *(str++);
1312 }
1313 }
1314 if ((t == tok) && ('\0' != *str)) { /* if it was something else (symbol), get it alone */
1315 *(t++) = *(str++);
1316 }
1317 *t = '\0';
1318 while (isspace((int) *str)) { /* get rid of following whitespace and tab */
1319 str++;
1320 }
1321 return str;
1322}

Referenced by build_input(), build_main_loop_conditions(), build_main_loop_inject(), build_main_loop_time(), build_update(), call_user_functions(), check_array_usage(), check_record_usage(), collect_string_of_functions(), collect_string_of_options(), declare_a_digital_node(), define_directives(), dump_function(), expand_dump_definitions(), expand_IO_definitions(), expand_string_variables(), expand_update_definitions(), get_array(), get_data(), get_drop(), get_dump(), get_input(), get_load(), get_opcode(), get_output(), get_ping(), get_post(), get_sign_and_token(), get_title(), get_var(), line_parsing(), mark_updates_if_constant(), node_id(), print_algebra(), print_alu(), print_average(), print_C_code_banner_b(), print_copy(), print_dyadic0(), print_dyadic1(), print_dyadic2(), print_dyadic3(), print_dyadic4(), print_dyadic5(), print_dyadic6(), print_dyadic7(), print_minmax(), print_muller(), print_ram(), print_rom(), print_terminate_condition(), print_test(), print_usertool(), process_cell(), process_gen(), rearrange_data_interfaces(), redefine_node_segments(), redefine_nodes(), reset_a_dc_node(), reset_a_digital_node(), reset_an_analog_node(), reset_user_variables(), separe_qualifiers(), syntax_directives(), syntax_segment_value(), syntax_terminate(), syntax_updates(), syntax_variables(), and var_id().

◆ get_token_between_braces()

char * get_token_between_braces ( char * str,
char * brc,
char * tok )

Definition at line 1110 of file tk.c.

1110 { /* no braces: no token extracted */
1111 char wrd[STRLENGTH] = {'\0'};
1112 char *s = (char*) NULL;
1113 char *b = (char*) NULL;
1114 char *w = (char*) NULL;
1115 char c1, c2;
1116 long i, j, cnt;
1117 s = str;
1118 while (isspace((int) *s)) { /* skip whitespace */
1119 s++;
1120 }
1121 b = brc;
1122 w = wrd;
1123 c1 = *s;
1124 if (('(' != c1) && ('<' != c1) && ('[' != c1) && ('{' != c1) && ('"' != c1) && ('\'' != c1)) {
1125 (void) strcpy(brc, ""); /* no brace */
1126 (void) strcpy(tok, ""); /* no token between braces */
1127 return str; /* statu quo! pointer remains as it was positionned */
1128 }
1129 *b = c1; /* brace found, copy left brace */
1130 cnt = 1L;
1131 if ('(' == c1) {
1132 c2 = ')';
1133 } else if ('<' == c1) {
1134 c2 = '>';
1135 } else if ('[' == c1) {
1136 c2 = ']';
1137 } else if ('{' == c1) {
1138 c2 = '}';
1139 } else if ('"' == c1) {
1140 c2 = '"';
1141 } else if ('\'' == c1) {
1142 c2 = '\'';
1143 } else {
1144 c2 = ' ';
1145 }
1146 b++;
1147 s++;
1148 while (('\0' != *s) && (0 < cnt)) { /* scan text between braces */
1149 if (*s == c2) { /* for quotes, mandatory to check in this order ! */
1150 cnt--;
1151 } else if (*s == c1) {
1152 cnt++;
1153 }
1154 *w = *s;
1155 s++;
1156 w++;
1157 }
1158 s--;
1159 w--;
1160 *w = '\0';
1161 j = 0L;
1162 for (i = 0L; i < LENGTH(wrd); i++) { /* get text between braces, replace tabs */
1163 if ('\t' == wrd[i]) {
1164 wrd[i] = ' ';
1165 continue;
1166 }
1167 tok[j] = wrd[i];
1168 j++;
1169 }
1170 tok[j] = '\0';
1171 if (*s == c2) {
1172 *b = *s; /* copy right brace */
1173 } else {
1174 (void) strcpy(brc, ""); /* no brace */
1175 (void) strcpy(tok, ""); /* no token between braces */
1176 return str; /* statu quo! pointer remains as it was positionned */
1177 }
1178 b++;
1179 *b = '\0';
1180 s++;
1181 while (isspace((int) *s)) { /* skip whitespace */
1182 s++;
1183 }
1184 return s; /* return pointer positionned after double brace */
1185}

References LENGTH, and STRLENGTH.

Referenced by check_types(), get_array(), get_assert(), get_data(), get_declare(), get_directive(), get_dump(), get_format(), get_function_identifier(), get_header(), get_load(), get_node(), get_output_and_scaling(), get_synchronize(), get_update(), get_var(), get_void(), line_parsing(), node_determination(), print_ram(), print_rom(), process_cell(), process_condition(), process_gen(), read_doub_format(), read_hex_format(), read_int_format(), read_str_format(), redefine_nodes(), and syntax_nodes().

◆ is_a_string()

int is_a_string ( char * str)

Definition at line 1369 of file tk.c.

1369 {
1370 char tok[STRLENGTH] = {'\0'};
1371 char *s = (char*) NULL;
1372 s = tok;
1373 (void) compact_line(str, s);
1374 return (('"' == s[0]) && ('"' == s[LENGTH(s)-1L]) ? true : false);
1375}
compact_line
char * compact_line(char *str1, char *str2)
Definition tk.c:1468

References compact_line(), LENGTH, and STRLENGTH.

Referenced by build_usage_comment(), and syntax_variables().

◆ is_an_extended_identifier()

int is_an_extended_identifier ( const char * tok)

Definition at line 1348 of file tk.c.

1348 { /* may include also a '.' */
1349 char tok1[STRLENGTH] = {'\0'};
1350 char *s = (char*) NULL;
1351 (void) strcpy(tok1, tok);
1352 s = tok1;
1353 if ('$' == tok1[LENGTH(tok1) - 1L]) { /* temporary spelling of qualifier '..$' */
1354 tok1[LENGTH(tok1) - 1L] = '\0'; /* remove the '$' before checking */
1355 }
1356 if (isdigit((int) *s) || (('_' == *s) && (0 != strncmp(tok1, "_void", (size_t) 5)))) {
1357 return false;
1358 }
1359 while ('\0' != *s) {
1360 if ((!isalnum((int) *s)) && ('_' != *s) && (':' != *s) && ('.' != *s) && ('@' != *s) && ('\'' != *s)) {
1361 return false;
1362 }
1363 s++;
1364 }
1365 return true;
1366}

References LENGTH, and STRLENGTH.

Referenced by process_cell().

◆ is_an_identifier()

int is_an_identifier ( const char * tok)

Definition at line 1327 of file tk.c.

1327 {
1328 char tok1[STRLENGTH] = {'\0'};
1329 char *s = (char*) NULL;
1330 (void) strcpy(tok1, tok);
1331 s = tok1;
1332 if ('$' == tok1[LENGTH(tok1) - 1L]) { /* temporary spelling of qualifier '..$' */
1333 tok1[LENGTH(tok1) - 1L] = '\0'; /* remove the '$' before checking */
1334 }
1335 if (isdigit((int) *s) || (('_' == *s) && (0 != strncmp(tok1, "_void", (size_t) 5)))) {
1336 return false;
1337 }
1338 while ('\0' != *s) {
1339 if ((!isalnum((int) *s)) && ('_' != *s) && (':' != *s) && ('@' != *s) && ('\'' != *s)) {
1340 return false;
1341 }
1342 s++;
1343 }
1344 return true;
1345}

References LENGTH, and STRLENGTH.

Referenced by collect_export_definitions(), get_alias(), get_array(), get_command_line(), get_data(), get_debug(), get_directive(), get_function_identifier(), get_inject(), get_node(), get_opcode(), get_output_and_scaling(), get_stuck(), get_update(), get_var(), line_parsing(), process_cell(), and syntax_records().

◆ is_an_integer_number()

int is_an_integer_number ( const char * str)

Definition at line 1378 of file tk.c.

1378 {
1379 char *s = (char*) NULL;
1380 double d;
1381 if (((char*) NULL == str) || ('\0' == *str) || isspace((int) *str)) {
1382 return false;
1383 }
1384 d = strtod(str, &s);
1385 if ('\0' != *s) {
1386 return false;
1387 }
1388 if ((double) ((long long) d) != d) {
1389 return false;
1390 }
1391 return true;
1392}

◆ multiple()

char * multiple ( char c,
long n )

Definition at line 1801 of file tk.c.

1801 {
1802 int i, j;
1803 static char result[256] = {'\0'};
1804 char *s = (char*) NULL;
1805 s = result;
1806 j = MAX( 1L, n);
1807 j = MIN(255L, j);
1808 for (i = 0; i < j; i++) {
1809 *s = c;
1810 s++;
1811 }
1812 *s = '\0';
1813 return result;
1814}
MIN
#define MIN(x, y)
Definition napa.h:376
MAX
#define MAX(x, y)
Definition napa.h:377

References MAX, and MIN.

Referenced by build_cross_reference(), check_directive_function(), check_option_function(), control_init_function(), declare_file_handles(), declare_function_pointers(), declare_global_values(), declare_prototypes(), define_directives(), define_macros(), include_ANSI_C_header_files(), include_napa_header_files(), line_parsing(), napa_data_record_function(), napa_exit_functions(), napa_IO_manager_function(), napa_timer_function(), open_main(), print_C_code_banner_a(), print_ping_function(), random_functions(), randomizer_functions(), and that_s_all().

◆ process_cell_line()

void process_cell_line ( char * buf,
long d,
const unsigned long * mlin,
const unsigned long * mfil )

Definition at line 441 of file tk.c.

441 {
442 char *si = (char*) NULL;
443 char *so = (char*) NULL;
444 char *sw = (char*) NULL;
445 char *sb = (char*) NULL;
446 char *str1 = (char*) NULL;
447 char *str2 = (char*) NULL;
448 char li[LINLENGTH] = {'\0'};
449 char wi[LINLENGTH] = {'\0'};
450 char tok1[STRLENGTH] = {'\0'};
451 char tok2[LINLENGTH] = {'\0'};
452 char tok3[STRLENGTH] = {'\0'};
453 char tok4[STRLENGTH] = {'\0'};
454 char tok5[STRLENGTH] = {'\0'};
455 long c, m;
456 long b1, e1, b2, e2;
457 long i, j;
458 int node_flag;
459 int interface_flag;
460 int nodeset_flag;
461 node_flag = false;
462 interface_flag = false;
463 nodeset_flag = false;
464 if ((0L >= d) || ISEMPTY(buf)) { /* nothing to expand at main level or buffer empty */
465 return;
466 }
467 m = LINLENGTH / 8L; /* reasonable maximum to avoid overflow later */
468 if (LENGTH(buf) >= m) {
469 print_error_location( "check", mlin, mfil);
470 (void) fprintf(STDERR, " cell line too long to be expanded, refrain to use long identifiers, esp. long instantiation names!\n");
471 print_error_banner_and_exit();
472 }
473 if (((char*) NULL == strstr(buf, " node")) && ((char*) NULL == strstr(buf, "node["))) {
474 node_flag = false;
475 } else {
476 node_flag = true;
477 }
478 (void) strcpy(li, buf);
479 c = 0L; /* expand local variables */
480 so = buf;
481 si = li; /* scan and process */
482 while (isspace((int) *si) && ('\0' != *si)) {
483 si++; /* remove spaces on the left */
484 }
485
486 while ('\0' != *si) { /* process all char of the line */
487
488 if ('$' == *si) {
489
490 /* local identifier, process */
491 sw = tok1; /* get token starting with $ */
492 while (isalnum((int) *si) || ('$' == *si) || ('_' == *si) || ('.' == *si) || ('@' == *si)) {
493 *sw = *si;
494 sw++;
495 si++;
496 }
497 *sw = '\0'; /* terminate token 'tok1' */
498
499 if (node_flag) { /* it is a node. Is it a nodeset? */
500 str1 = tok1;
501 for (;;) {
502 if (!isspace((int) *str1) && ('[' != *str1)) {
503 nodeset_flag = false;
504 break;
505 }
506 if ('[' == *str1) {
507 nodeset_flag = true;
508 (void) strcpy(tok2, str1);
509 break;
510 }
511 if ('\0' == *str1) {
512 nodeset_flag = false;
513 break;
514 }
515 str1++;
516 }
517 } else {
518 nodeset_flag = false;
519 }
520
521 if (nodeset_flag) { /* nodeset analysis */
522 interface_flag = false;
523 (void) strcpy(tok3, tok1);
524 str1 = tok3;
525 for (;;) {
526 if ('[' == *str1) {
527 break;
528 }
529 if ('\0' == *str1) {
530 break;
531 }
532 str1++;
533 }
534 *str1 = '\0';
535 if (2 != sscanf(tok2, "[%li..%li]", &b1, &e1)) { /* iterator */
536 print_error_location("cell", mlin, mfil);
537 (void) fprintf(STDERR, " nodeset iterator is not well-formed <%s> in <%s>\n", tok2, tok1);
538 print_error_banner_and_exit();
539 }
540 if (b1 < e1) { /* begin, end redefinition */
541 b2 = b1;
542 e2 = e1;
543 } else {
544 b2 = e1;
545 e2 = b1;
546 }
547 i = b2;
548 (void) snprintf(tok2, (size_t) (LINLENGTH-1L), "%s%ld", tok3, i); /* single node from nodeset */
549 for (j = 0L; j < Cell_Num_Parms[d]; j++) { /* identify correspondance */
550 if (0 == strcmp(Cell_Plist[d][j], tok2)) { /* member of interface */
551 interface_flag = true;
552 break;
553 }
554 }
555 if (interface_flag) { /* other nodes are interface? */
556 for (i = b2+1L; i <= e2; i++) {
557 (void) snprintf(tok2, (size_t) (LINLENGTH-1L), "%s%ld", tok3, i); /* single node from nodeset */
558 interface_flag = false;
559 for (j = 0L; j < Cell_Num_Parms[d]; j++) { /* identify correspondance */
560 if (0 == strcmp(Cell_Plist[d][j], tok2)) { /* member of interface */
561 interface_flag = true;
562 break;
563 }
564 }
565 if (!interface_flag) {
566 print_error_location("cell", mlin, mfil);
567 (void) fprintf(STDERR, " first node of the nodeset is part of interface,\n");
568 (void) fprintf(STDERR, " but the nodeset is not composed of interface nodes\n");
569 print_error_banner_and_exit();
570 }
571 }
572 } else { /* other nodes are not interface? */
573 for (i = b2+1L; i <= e2; i++) {
574 (void) snprintf(tok2, (size_t) (LINLENGTH-1L), "%s%ld", tok3, i); /* single node from nodeset */
575 for (j = 0L; j < Cell_Num_Parms[d]; j++) { /* identify correspondance */
576 if (0 == strcmp(Cell_Plist[d][j], tok2)) { /* member of interface */
577 print_error_location("cell", mlin, mfil);
578 (void) fprintf(STDERR, " first node of the nodeset is an internal node,\n");
579 (void) fprintf(STDERR, " but the nodeset is not composed of internal nodes\n");
580 print_error_banner_and_exit();
581 }
582 }
583 }
584 }
585 (void) snprintf(tok1, (size_t) (STRLENGTH-1L), "%s[%ld..%ld]", tok3, b1, e1);
586 if (!interface_flag) { /* local identifier */
587 sw = Cell_Name_Prefix[d];
588 while ('\0' != *sw) {
589 *so = *sw;
590 so++;
591 sw++;
592 c++;
593 }
594 *so++ = '_';
595 *so++ = '_';
596 c += 2L;
597 sw = tok1;
598 sw++; /* skip '$' */
599 while ('\0' != *sw) {
600 *so = *sw;
601 so++;
602 sw++;
603 c++;
604 }
605 } else {
606 sw = tok1;
607 sw++; /* skip '$' */
608 while ('\0' != *sw) {
609 *so = *sw;
610 so++;
611 sw++;
612 c++;
613 }
614 }
615
616 } else { /* it is not a nodeset */
617
618 interface_flag = false;
619
620 /* simple token */
621 for (j = 0L; j < Cell_Num_Parms[d]; j++) { /* identify correspondance */
622 (void) strcpy(tok4, tok1); /* must also process "arrayid.number" identifier */
623 str2 = strchr(tok4, '.');
624 if ((char*) NULL != str2) {
625 (void) strcpy(tok5, str2); /* contains the rest of identifier including '.' */
626 *str2 = '\0'; /* 'tok4' contains the id of the array */
627 } else {
628 (void) strcpy(tok5, "");
629 }
630 if (0 == strcmp(Cell_Plist[d][j], tok4)) { /* member of cell interface */
631 interface_flag = true;
632 (void) strcpy(wi, Inst_Plist[d][j]);
633 (void) strcat(wi, tok5); /* copy right part of identifier "arrayid.number" */
634 sw = wi; /* copy to avoid side effect */
635 if ('-' != *sw) { /* unsigned replacement */
636 while ('\0' != *sw) {
637 *so = *sw;
638 so++;
639 sw++;
640 c++;
641 }
642 } else { /* signed replacement!!! */
643 if (so > li) {
644 sb = so - 1;
645 } else {
646 sb = so;
647 }
648 while ((sb >= li) && (' ' == *sb)) { /* find previous non blank */
649 sb--;
650 }
651 if ('-' == *sb) { /* a minus! */
652 *sb = '+'; /* change sign */
653 *sw = ' '; /* remove minus from copy */
654 }
655 while ('\0' != *sw) {
656 *so = *sw;
657 so++;
658 sw++;
659 c++;
660 }
661 }
662 break;
663 }
664 }
665
666 if (!interface_flag) { /* local identifier */
667 sw = Cell_Name_Prefix[d];
668 while ('\0' != *sw) {
669 *so = *sw;
670 so++;
671 sw++;
672 c++;
673 }
674 *so++ = '_';
675 *so++ = '_';
676 c += 2L;
677 sw = tok1;
678 sw++; /* skip '$' */
679 while ('\0' != *sw) {
680 *so = *sw;
681 so++;
682 sw++;
683 c++;
684 }
685 }
686 }
687
688 } else { /* normal text without prefix $ */
689
690 while (('$' != *si) && ('\0' != *si) && !isspace((int) *si)) {
691 *so = *si;
692 so++;
693 si++;
694 c++;
695 }
696 while (isspace((int) *si) && ('\0' != *si)) { /* space */
697 *so = *si;
698 so++;
699 si++;
700 c++;
701 }
702 }
703
704 if (c >= m) { /* verify length after each word */
705 print_error_location( "check", mlin, mfil);
706 (void) fprintf(STDERR, " line too long, overflow occured during expansion of cell line\n");
707 print_limits();
708 print_error_banner_and_exit();
709 }
710 } /* end of process of all line */
711
712 *so = '\0'; /* terminate string */
713 return;
714}
Inst_Plist
EXTERN char Inst_Plist[31L][127L][16383L]
Definition napa.h:937
Cell_Name_Prefix
EXTERN char Cell_Name_Prefix[31L][2047L]
Definition napa.h:945
Cell_Num_Parms
EXTERN long Cell_Num_Parms[31L]
Definition napa.h:934
Cell_Plist
EXTERN char Cell_Plist[31L][127L][16383L]
Definition napa.h:936

References Cell_Name_Prefix, Cell_Num_Parms, Cell_Plist, Inst_Plist, ISEMPTY, LENGTH, LINLENGTH, print_error_banner_and_exit(), print_error_location(), print_limits(), STDERR, and STRLENGTH.

Referenced by line_parsing().

◆ replace_char()

char * replace_char ( char * s,
char b,
char a )

Definition at line 1788 of file tk.c.

1788 {
1789 char *t = (char*) NULL;
1790 t = s;
1791 while ('\0' != *t) {
1792 if (*t == b) {
1793 *t = a;
1794 }
1795 t++;
1796 }
1797 return s;
1798}

Referenced by define_macros().

◆ replace_dollar()

void replace_dollar ( char * tok)

Definition at line 1713 of file tk.c.

1713 { /* process a single token */
1714 long len;
1715 len = LENGTH(tok) - 1L;
1716 if ('$' == tok[len]) {
1717 tok[len] = '\0';
1718 }
1719 return;
1720}

References LENGTH.

Referenced by call_postprocess_functions(), call_user_functions(), get_header(), print_usertool(), and syntax_nodes().

◆ replace_parentheses()

void replace_parentheses ( char * str)

Definition at line 1644 of file tk.c.

1644 { /* process a full line */
1645 char tok1[STRLENGTH] = {'\0'};
1646 char tok2[STRLENGTH] = {'\0'};
1647 char *t1 = (char*) NULL;
1648 char *t2 = (char*) NULL;
1649 int c;
1650 long n, l;
1651 int flag;
1652 flag = false; /* outside a string */
1653 l = LENGTH(str);
1654 t1 = tok1;
1655 t2 = tok2;
1656 for (c = 0; c < l; c++) {
1657 *(t1 + c) = *(str + c);
1658 }
1659 t1 = tok1;
1660 for (n = 0L; n < l; n++) {
1661 if (('"' != *t1) && (flag)) { /* inside a string, no process */
1662 t1++;
1663 continue;
1664 }
1665 if ('"' == *t1) {
1666 flag = (flag) ? false : true;
1667 t1++;
1668 continue;
1669 }
1670 if ('(' == *t1) {
1671 *t1 = ' ';
1672 }
1673 if (')' == *t1) {
1674 *t1 = '$';
1675 }
1676 t1++;
1677 }
1678 t1 = tok1;
1679 t2 = tok2;
1680 *t2 = *t1;
1681 t1++;
1682 t2++;
1683 *t2 = *t1;
1684 t1++;
1685 t2++;
1686 c = 0;
1687 while (l > c) { /* suppress space after :: */
1688 if (' ' != *t1) {
1689 *t2 = *t1;
1690 t1++;
1691 t2++;
1692 } else {
1693 if ((':' == *(t1-1)) && (':' == *(t1-2))) {
1694 t1++;
1695 } else {
1696 *t2 = *t1;
1697 t1++;
1698 t2++;
1699 }
1700 }
1701 c++;
1702 }
1703 t2 = tok2;
1704 for (c = 0; c < l; c++) {
1705 *(str + c) = *(t2 + c);
1706 }
1707 return;
1708}

References LENGTH, and STRLENGTH.

Referenced by get_node(), and get_post().

◆ resolve_pathnames()

void resolve_pathnames ( char * lin,
long depth )

Definition at line 265 of file tk.c.

265 { /* following the NAPA file system conventions */
266 char *sl = (char*) NULL;
267 char *sb = (char*) NULL;
268 char *se = (char*) NULL;
269 char *sw = (char*) NULL;
270 char tk[LINLENGTH] = {'\0'};
271 char bf[LINLENGTH] = {'\0'};
272 char pn[LINLENGTH] = {'\0'};
273 char fn[LINLENGTH] = {'\0'};
274 long i, j, k;
275 sl = lin;
276 while ('\0' != *sl) {
277 (void) strcpy(tk, "");
278 while (('"' != *sl) && ('\0' != *sl)) { /* skip everything outside a string */
279 sl++;
280 }
281 if ('\0' == *sl) { /* end of line, no more process */
282 break;
283 }
284 sl++; /* symbol after double quote */
285 sb = sl; /* mark begin of the string: sb */
286 se = sl;
287 while (('"' != *sl) && ('\0' != *sl)) {
288 sl++;
289 }
290 if ('\0' == *sl) { /* end of line, no more process */
291 break;
292 }
293 if ('"' == *sl) {
294 se = sl - 1; /* mark end of the string: se */
295 sl++; /* symbol after double quote */
296 }
297 /* 'sb' points to first symbol of string, 'se' points to last symbol of string transfer string constant in array 'tk' */
298 i = 0L;
299 for (sw = sb; sw <= se; sw++) {
300 tk[i] = *sw;
301 i++; /* count the number of symbols */
302 }
303 i--;
304 tk[i] = '\0'; /* terminate string */
305 if (ISEMPTY(tk)) {
306 continue; /* no process, continue scanning */
307 }
308 (void) strcpy(pn, Cur_Lib_Name[depth]);
309 extract_directory(pn, tk, depth); /* follow NAPA file system */
310 (void) snprintf(fn, (size_t) (LINLENGTH-1L), "%s%s", pn, tk); /* 'fn' contains resolved file path */
311 /* build a new line containing the resolved name in array 'bf' */
312 i = 0L;
313 j = 0L;
314 for (sw = lin; sw < sb; sw++) { /* copy all before */
315 bf[i] = *sw;
316 i++;
317 }
318 for (sw = fn; sw < (&(fn[LENGTH(fn)])); sw++) { /* copy resolved pathname */
319 bf[i] = fn[j];
320 i++;
321 j++;
322 }
323 k = i + 1L; /* record where to continue */
324 for (sw = se; sw < (&(lin[LENGTH(lin)])); sw++) { /* append end of line */
325 bf[i] = *sw;
326 i++;
327 }
328 bf[i] = '\0';
329 (void) strcpy(lin, bf); /* copy to 'lin' */
330 sl = lin + k; /* points to next symbol */
331 }
332 return;
333}
extract_directory
void extract_directory(char *pn, char *fn, long depth)
Definition tk.c:339

References Cur_Lib_Name, extract_directory(), ISEMPTY, LENGTH, and LINLENGTH.

Referenced by get_array(), get_assert(), get_call(), get_declare(), get_drop(), get_dump(), get_init(), get_inject(), get_input(), get_load(), get_node(), get_output(), get_ping(), get_post(), get_sampling(), get_stuck(), get_terminate(), get_title(), get_update(), get_var(), and process_gen().

◆ restore_line()

void restore_line ( char * lin)

Definition at line 1452 of file tk.c.

1452 { /* options (..) have been replaced by ..$ ! */
1453 while ('\0' != *lin) { /* restore line back to original if expand netlist */
1454 if ('$' == *lin) {
1455 *lin = ')';
1456 lin--;
1457 while (' ' != *lin) {
1458 lin--;
1459 }
1460 *lin = '(';
1461 }
1462 lin++;
1463 }
1464 return;
1465}

Referenced by line_parsing().

◆ simplify_pathname()

void simplify_pathname ( char * pnam)

Definition at line 1543 of file tk.c.

1543 {
1544 char *cur;
1545 char *t;
1546 int isrooted;
1547 char *very_start = pnam;
1548 char *start;
1549 if (!(*pnam)) {
1550 return;
1551 }
1552 isrooted = ('/' == pnam[0]);
1553 if (isrooted) {
1554 very_start++;
1555 }
1556 for (cur = t = start = very_start;;) { /* treat multiple '/'s as one '/' */
1557 while ('/' == *t) {
1558 t++;
1559 }
1560 if ('\0' == *t) {
1561 if (cur == pnam) { /* convert empty path to dot */
1562 *cur++ = '.';
1563 }
1564 *cur = '\0';
1565 break;
1566 }
1567 if ('.' == t[0]) {
1568 if ((!t[1]) || ('/' == t[1])) {
1569 t += 1;
1570 continue;
1571 } else if (('.' == t[1]) && ((!t[2]) || ('/' == t[2]))) {
1572 if ((!isrooted) && (cur == start)) {
1573 if (cur != very_start) {
1574 *cur++ = '/';
1575 }
1576 *cur++ = '.';
1577 *cur++ = '.';
1578 start = cur;
1579 } else if (cur != start) {
1580 while ((--cur > start) && ('/' != *cur));
1581 }
1582 t += 2;
1583 continue;
1584 }
1585 }
1586 if (cur != very_start) {
1587 *cur++ = '/';
1588 } /* find/copy next component of pathname */
1589 while ((*t) && ('/' != *t)) {
1590 *cur++ = *t++;
1591 }
1592 }
1593}

Referenced by define_macros(), get_dump(), get_header(), get_input(), get_load(), get_output(), get_void(), process_cell(), and process_gen().

◆ strip_extension()

void strip_extension ( char * fnam)

Definition at line 1598 of file tk.c.

1598 {
1599 char *s = (char*) NULL;
1600 char *t = (char*) NULL;
1601 long n;
1602 t = fnam;
1603 n = (LENGTH(t)) - 1L;
1604 s = t + n;
1605 while (0 < n) {
1606 if ('.' == *s) {
1607 *s = '\0';
1608 break; /* break as soon as one point is detected */
1609 }
1610 s--;
1611 n--;
1612 }
1613 return;
1614}

References LENGTH.

Referenced by define_macros(), and line_parsing().

◆ strip_quotes()

void strip_quotes ( char * str)

Definition at line 1619 of file tk.c.

1619 {
1620 char *s = (char*) NULL;
1621 char *t = (char*) NULL;
1622 s = str;
1623 t = str;
1624 if ('"' == *s) {
1625 s++;
1626 t++;
1627 }
1628 while ('\0' != *s) {
1629 if ('"' == *s) {
1630 *s = '\0';
1631 break;
1632 }
1633 s++;
1634 }
1635 (void) strcpy(str, t);
1636 return;
1637}

Referenced by syntax_command_line().

◆ unique_name()

char * unique_name ( void )

Definition at line 1766 of file tk.c.

1766 {
1767 static int count = 0;
1768 static char name[32];
1769 (void) snprintf(name, (size_t) 31, "%s_%d", NAPA_Job_ID, count);
1770 count++;
1771 return name;
1772}
NAPA_Job_ID
EXTERN char NAPA_Job_ID[19]
Definition napa.h:993

References NAPA_Job_ID.

Referenced by get_var().

◆ upper_to_lower()

char * upper_to_lower ( char * s)

Definition at line 1775 of file tk.c.

1775 {
1776 char *t = (char*) NULL;
1777 t = s;
1778 while ('\0' != *t) {
1779 if (isalpha((int) *t)) {
1780 *t = (char) tolower((int) *t);
1781 }
1782 t++;
1783 }
1784 return s;
1785}

Referenced by process_array_error(), process_instruction_error(), process_node_error(), process_node_kind_error(), process_record_error(), process_variable_error(), and syntax_command_line().