const char *
define_macro (int idx, sb *in, sb *label,
int (*get_line) (sb *), const char **namep)
{
macro_entry *macro;
sb name;
const char *namestr;
macro = (macro_entry *) xmalloc (sizeof (macro_entry));
sb_new (¯o->sub);
sb_new (&name);
macro->formal_count = 0;
macro->formals = 0;
idx = sb_skip_white (idx, in);
if (! buffer_and_nest ("MACRO", "ENDM", ¯o->sub, get_line))
return _("unexpected end of file in macro definition");
if (label != NULL && label->len != 0)
{
sb_add_sb (&name, label);
if (idx < in->len && in->ptr[idx] == '(')
{
/* It's the label: MACRO (formals,...) sort */
idx = do_formals (macro, idx + 1, in);
if (in->ptr[idx] != ')')
return _("missing ) after formals");
}
else
{
/* It's the label: MACRO formals,... sort */
idx = do_formals (macro, idx, in);
}
}
else
{
idx = get_token (idx, in, &name);
idx = sb_skip_comma (idx, in);
idx = do_formals (macro, idx, in);
}
/* And stick it in the macro hash table. */
for (idx = 0; idx < name.len; idx++)
name.ptr[idx] = TOLOWER (name.ptr[idx]);
namestr = sb_terminate (&name);
hash_jam (macro_hash, namestr, (PTR) macro);
macro_defined = 1;
if (namep != NULL)
*namep = namestr;
return NULL;
}
static formal_entry *
new_formal (void)
{
formal_entry *formal;
formal = xmalloc (sizeof (formal_entry));
sb_new (&formal->name);
sb_new (&formal->def);
sb_new (&formal->actual);
formal->next = NULL;
formal->type = FORMAL_OPTIONAL;
return formal;
}
int
check_macro (const char *line, sb *expand,
const char **error, macro_entry **info)
{
const char *s;
char *copy, *cs;
macro_entry *macro;
sb line_sb;
if (! ISALPHA (*line)
&& *line != '_'
&& *line != '$'
&& (! macro_mri || *line != '.'))
return 0;
s = line + 1;
while (ISALNUM (*s)
|| *s == '_'
|| *s == '$')
++s;
copy = (char *) alloca (s - line + 1);
memcpy (copy, line, s - line);
copy[s - line] = '\0';
for (cs = copy; *cs != '\0'; cs++)
*cs = TOLOWER (*cs);
macro = (macro_entry *) hash_find (macro_hash, copy);
if (macro == NULL)
return 0;
/* Wrap the line up in an sb. */
sb_new (&line_sb);
while (*s != '\0' && *s != '\n' && *s != '\r')
sb_add_char (&line_sb, *s++);
sb_new (expand);
*error = macro_expand (0, &line_sb, macro, expand);
sb_kill (&line_sb);
/* Export the macro information if requested. */
if (info)
*info = macro;
return 1;
}
static char *
dbrelay_resolve_params(dbrelay_request_t *request, char *sql)
{
int i = 0;
int pos = 0, prevpos = 0;
stringbuf_t *sb = sb_new(NULL);
char *ret;
char *tmpsql = strdup(sql);
if (IS_SET(DBRELAY_MAGIC) && !(request->flags & DBRELAY_FLAG_NOMAGIC)) {
sb_append(sb, DBRELAY_MAGIC);
}
while (request->params[i]) {
prevpos = pos;
pos += dbrelay_find_placeholder(&tmpsql[pos]);
if (pos==-1) {
// ignore missing placeholders
pos = prevpos;
} else {
tmpsql[pos]='\0';
sb_append(sb, &tmpsql[prevpos]);
if (is_quoted_param(request->params[i])) sb_append(sb, "'");
sb_append(sb, strstr(request->params[i], ":") + 1);
if (is_quoted_param(request->params[i])) sb_append(sb, "'");
pos++;
}
i++;
}
sb_append(sb, &tmpsql[pos]);
ret = sb_to_char(sb);
free(tmpsql);
sb_free(sb);
dbrelay_log_debug(request, "new sql %s", ret);
return ret;
}
int main(int argc, char *argv[])
{
SAPO_BROKER_T *sb;
BrokerMessage *m;
sb = sb_new(HOST, PORT, TYPE);
if (!sb) {
printf("%s", sb_error());
exit(-1);
}
if (sb_connect(sb) != SB_OK) {
printf("%s", sb_error());
exit(-1);
}
if (sb_subscribe(sb, EQUEUE_VIRTUAL_QUEUE, TOPIC) != SB_OK) {
printf("%s", sb_error());
exit(-1);
}
while ((m = sb_receive(sb)) != NULL) {
printf("%s\n", m->payload);
sb_send_ack( sb, m);
sb_free_message(m);
}
printf("Exiting: %s\n", sb_error());
}
void
input_scrub_include_sb (sb *from, char *position, int is_expansion)
{
if (macro_nest > max_macro_nest)
as_fatal (_("macros nested too deeply"));
++macro_nest;
#ifdef md_macro_start
if (is_expansion)
{
md_macro_start ();
}
#endif
next_saved_file = input_scrub_push (position);
sb_new (&from_sb);
from_sb_is_expansion = is_expansion;
if (from->len >= 1 && from->ptr[0] != '\n')
{
/* Add the sentinel required by read.c. */
sb_add_char (&from_sb, '\n');
}
sb_scrub_and_add_sb (&from_sb, from);
sb_index = 1;
/* These variables are reset by input_scrub_push. Restore them
since we are, after all, still at the same point in the file. */
logical_input_line = next_saved_file->logical_input_line;
logical_input_file = next_saved_file->logical_input_file;
}
/*
* Opens the backend database.
*
* ARGUMENTS:
* backend Pointer to pointer to backend structure. Shall not be
* NULL. Upon successful return, "*backend" will be set.
* The client should call "beClose(*backend)" when the
* backend is no longer needed.
* dir Pathname of the parent directory of the database.
* Shall not be NULL. The client can free it upon return.
* forWriting Open the database for writing? 0 <=> no
* RETURNS:
* 0 Success. "*backend" is set.
* ENOMEM System error. "log_start()" called.
* EIO Backend database error. "log_start()" called.
*/
RegStatus
beOpen(
Backend** const backend,
const char* const dir,
int forWriting)
{
RegStatus status;
Backend* back = (Backend*)malloc(sizeof(Backend));
assert(NULL != dir);
if (NULL == back) {
log_serror("Couldn't allocate %lu bytes", (long)sizeof(Backend));
status = ENOMEM;
}
else {
DB_ENV* env;
DB* db;
StringBuf* path;
if (0 == (status = sb_new(&path, PATH_MAX))) {
if (0 == (status = sb_cat(path, dir, "/", DB_DIRNAME))) {
if (0 == (status = createDbHandle(path, &env, &db))) {
if (status = db->open(db, NULL, DB_FILENAME, NULL,
DB_BTREE, forWriting ? DB_CREATE : DB_RDONLY, 0)) {
log_add("Couldn't open database \"%s\" in \"%s\" "
"for %s", DB_FILENAME, path,
forWriting ? "writing" : "reading");
status = EIO;
}
else {
back->db = db;
back->cursor.dbCursor = NULL;
*backend = back; /* success */
} /* "db" opened */
/*
* According to the documentation on DB->open(), if that
* call fails, then DB->close() must be called to discard
* the DB handle, so DB->close() is the termination
* counterpart of db_create() rather than of DB->open().
*/
if (status) {
(void)db->close(db, 0);
(void)env->close(env, 0);
}
} /* "env" allocated */
} /* DB directory pathname created */
sb_free(path);
} /* "path" allocated */
if (status)
free(back);
} /* "back" allocated */
return status;
}
static void near addripfile(char *szFilename)
{
if (ripfilebuf || (ripfilebuf=sb_new(STRBUFSZ))!=NULL)
{
if (!ripfilesent(szFilename))
{
if (sb_alloc(ripfilebuf,szFilename)==NULL) /* Out of space */
{
strbuf *newsb=sb_realloc(ripfilebuf,STRBUFSZ,0);
if (newsb==NULL)
sb_alloc(ripfilebuf,szFilename);
}
}
}
}
static const char *
macro_expand_body (sb *in, sb *out, formal_entry *formals,
struct hash_control *formal_hash, const macro_entry *macro)
{
sb t;
int src = 0, inquote = 0, macro_line = 0;
formal_entry *loclist = NULL;
const char *err = NULL;
sb_new (&t);
while (src < in->len && !err)
{
if (in->ptr[src] == '&')
{
sb_reset (&t);
if (macro_mri)
{
if (src + 1 < in->len && in->ptr[src + 1] == '&')
src = sub_actual (src + 2, in, &t, formal_hash, '\'', out, 1);
else
sb_add_char (out, in->ptr[src++]);
}
else
{
/* FIXME: Why do we do this? */
/* At least in alternate mode this seems correct; without this
one can't append a literal to a parameter. */
src = sub_actual (src + 1, in, &t, formal_hash, '&', out, 0);
}
}
else if (in->ptr[src] == '\\')
{
src++;
if (src < in->len && in->ptr[src] == '(')
{
/* Sub in till the next ')' literally. */
src++;
while (src < in->len && in->ptr[src] != ')')
{
sb_add_char (out, in->ptr[src++]);
}
if (src < in->len)
src++;
else if (!macro)
err = _("missing `)'");
else
as_bad_where (macro->file, macro->line + macro_line, _("missing `)'"));
}
else if (src < in->len && in->ptr[src] == '@')
{
/* Sub in the macro invocation number. */
char buffer[10];
src++;
sprintf (buffer, "%d", macro_number);
sb_add_string (out, buffer);
}
else if (src < in->len && in->ptr[src] == '&')
{
/* This is a preprocessor variable name, we don't do them
here. */
sb_add_char (out, '\\');
sb_add_char (out, '&');
src++;
}
else if (macro_mri && src < in->len && ISALNUM (in->ptr[src]))
{
int ind;
formal_entry *f;
if (ISDIGIT (in->ptr[src]))
ind = in->ptr[src] - '0';
else if (ISUPPER (in->ptr[src]))
ind = in->ptr[src] - 'A' + 10;
else
ind = in->ptr[src] - 'a' + 10;
++src;
for (f = formals; f != NULL; f = f->next)
{
if (f->index == ind - 1)
{
if (f->actual.len != 0)
sb_add_sb (out, &f->actual);
else
sb_add_sb (out, &f->def);
break;
}
}
}
else
{
sb_reset (&t);
src = sub_actual (src, in, &t, formal_hash, '\'', out, 0);
}
}
else if ((macro_alternate || macro_mri)
&& is_name_beginner (in->ptr[src])
&& (! inquote
|| ! macro_strip_at
|| (src > 0 && in->ptr[src - 1] == '@')))
{
if (! macro
|| src + 5 >= in->len
|| strncasecmp (in->ptr + src, "LOCAL", 5) != 0
|| ! ISWHITE (in->ptr[src + 5]))
{
sb_reset (&t);
src = sub_actual (src, in, &t, formal_hash,
(macro_strip_at && inquote) ? '@' : '\'',
out, 1);
}
else
{
src = sb_skip_white (src + 5, in);
while (in->ptr[src] != '\n')
{
const char *name;
formal_entry *f = new_formal ();
src = get_token (src, in, &f->name);
name = sb_terminate (&f->name);
if (! hash_find (formal_hash, name))
{
static int loccnt;
char buf[20];
f->index = LOCAL_INDEX;
f->next = loclist;
loclist = f;
sprintf (buf, IS_ELF ? ".LL%04x" : "LL%04x", ++loccnt);
sb_add_string (&f->actual, buf);
err = hash_jam (formal_hash, name, f);
if (err != NULL)
break;
}
else
{
as_bad_where (macro->file,
macro->line + macro_line,
_("`%s' was already used as parameter (or another local) name"),
name);
del_formal (f);
}
src = sb_skip_comma (src, in);
}
}
}
else if (in->ptr[src] == '"'
|| (macro_mri && in->ptr[src] == '\''))
{
inquote = !inquote;
sb_add_char (out, in->ptr[src++]);
}
else if (in->ptr[src] == '@' && macro_strip_at)
{
++src;
if (src < in->len
&& in->ptr[src] == '@')
{
sb_add_char (out, '@');
++src;
}
}
else if (macro_mri
&& in->ptr[src] == '='
&& src + 1 < in->len
&& in->ptr[src + 1] == '=')
{
formal_entry *ptr;
sb_reset (&t);
src = get_token (src + 2, in, &t);
ptr = (formal_entry *) hash_find (formal_hash, sb_terminate (&t));
if (ptr == NULL)
{
/* FIXME: We should really return a warning string here,
but we can't, because the == might be in the MRI
comment field, and, since the nature of the MRI
comment field depends upon the exact instruction
being used, we don't have enough information here to
figure out whether it is or not. Instead, we leave
the == in place, which should cause a syntax error if
it is not in a comment. */
sb_add_char (out, '=');
sb_add_char (out, '=');
sb_add_sb (out, &t);
}
else
{
if (ptr->actual.len)
{
sb_add_string (out, "-1");
}
else
{
sb_add_char (out, '0');
}
}
}
else
{
if (in->ptr[src] == '\n')
++macro_line;
sb_add_char (out, in->ptr[src++]);
}
}
sb_kill (&t);
while (loclist != NULL)
{
formal_entry *f;
f = loclist->next;
/* Setting the value to NULL effectively deletes the entry. We
avoid calling hash_delete because it doesn't reclaim memory. */
hash_jam (formal_hash, sb_terminate (&loclist->name), NULL);
del_formal (loclist);
loclist = f;
}
return err;
}
const char *
define_macro (int idx, sb *in, sb *label,
int (*get_line) (sb *),
char *file, unsigned int line,
const char **namep)
{
macro_entry *macro;
sb name;
const char *error = NULL;
macro = (macro_entry *) xmalloc (sizeof (macro_entry));
sb_new (¯o->sub);
sb_new (&name);
macro->file = file;
macro->line = line;
macro->formal_count = 0;
macro->formals = 0;
macro->formal_hash = hash_new ();
idx = sb_skip_white (idx, in);
if (! buffer_and_nest ("MACRO", "ENDM", ¯o->sub, get_line))
error = _("unexpected end of file in macro `%s' definition");
if (label != NULL && label->len != 0)
{
sb_add_sb (&name, label);
macro->name = sb_terminate (&name);
if (idx < in->len && in->ptr[idx] == '(')
{
/* It's the label: MACRO (formals,...) sort */
idx = do_formals (macro, idx + 1, in);
if (idx < in->len && in->ptr[idx] == ')')
idx = sb_skip_white (idx + 1, in);
else if (!error)
error = _("missing `)' after formals in macro definition `%s'");
}
else
{
/* It's the label: MACRO formals,... sort */
idx = do_formals (macro, idx, in);
}
}
else
{
int cidx;
idx = get_token (idx, in, &name);
macro->name = sb_terminate (&name);
if (name.len == 0)
error = _("Missing macro name");
cidx = sb_skip_white (idx, in);
idx = sb_skip_comma (cidx, in);
if (idx == cidx || idx < in->len)
idx = do_formals (macro, idx, in);
else
idx = cidx;
}
if (!error && idx < in->len)
error = _("Bad parameter list for macro `%s'");
/* And stick it in the macro hash table. */
for (idx = 0; idx < name.len; idx++)
name.ptr[idx] = TOLOWER (name.ptr[idx]);
if (hash_find (macro_hash, macro->name))
error = _("Macro `%s' was already defined");
if (!error)
error = hash_jam (macro_hash, macro->name, (PTR) macro);
if (namep != NULL)
*namep = macro->name;
if (!error)
macro_defined = 1;
else
free_macro (macro);
return error;
}
static int
do_formals (macro_entry *macro, int idx, sb *in)
{
formal_entry **p = ¯o->formals;
const char *name;
idx = sb_skip_white (idx, in);
while (idx < in->len)
{
formal_entry *formal = new_formal ();
int cidx;
idx = get_token (idx, in, &formal->name);
if (formal->name.len == 0)
{
if (macro->formal_count)
--idx;
break;
}
idx = sb_skip_white (idx, in);
/* This is a formal. */
name = sb_terminate (&formal->name);
if (! macro_mri
&& idx < in->len
&& in->ptr[idx] == ':'
&& (! is_name_beginner (':')
|| idx + 1 >= in->len
|| ! is_part_of_name (in->ptr[idx + 1])))
{
/* Got a qualifier. */
sb qual;
sb_new (&qual);
idx = get_token (sb_skip_white (idx + 1, in), in, &qual);
sb_terminate (&qual);
if (qual.len == 0)
as_bad_where (macro->file,
macro->line,
_("Missing parameter qualifier for `%s' in macro `%s'"),
name,
macro->name);
else if (strcmp (qual.ptr, "req") == 0)
formal->type = FORMAL_REQUIRED;
else if (strcmp (qual.ptr, "vararg") == 0)
formal->type = FORMAL_VARARG;
else
as_bad_where (macro->file,
macro->line,
_("`%s' is not a valid parameter qualifier for `%s' in macro `%s'"),
qual.ptr,
name,
macro->name);
sb_kill (&qual);
idx = sb_skip_white (idx, in);
}
if (idx < in->len && in->ptr[idx] == '=')
{
/* Got a default. */
idx = get_any_string (idx + 1, in, &formal->def);
idx = sb_skip_white (idx, in);
if (formal->type == FORMAL_REQUIRED)
{
sb_reset (&formal->def);
as_warn_where (macro->file,
macro->line,
_("Pointless default value for required parameter `%s' in macro `%s'"),
name,
macro->name);
}
}
/* Add to macro's hash table. */
if (! hash_find (macro->formal_hash, name))
hash_jam (macro->formal_hash, name, formal);
else
as_bad_where (macro->file,
macro->line,
_("A parameter named `%s' already exists for macro `%s'"),
name,
macro->name);
formal->index = macro->formal_count++;
*p = formal;
p = &formal->next;
if (formal->type == FORMAL_VARARG)
break;
cidx = idx;
idx = sb_skip_comma (idx, in);
if (idx != cidx && idx >= in->len)
{
idx = cidx;
break;
}
}
if (macro_mri)
{
formal_entry *formal = new_formal ();
/* Add a special NARG formal, which macro_expand will set to the
number of arguments. */
/* The same MRI assemblers which treat '@' characters also use
the name $NARG. At least until we find an exception. */
if (macro_strip_at)
name = "$NARG";
else
name = "NARG";
sb_add_string (&formal->name, name);
/* Add to macro's hash table. */
if (hash_find (macro->formal_hash, name))
as_bad_where (macro->file,
macro->line,
_("Reserved word `%s' used as parameter in macro `%s'"),
name,
macro->name);
hash_jam (macro->formal_hash, name, formal);
formal->index = NARG_INDEX;
*p = formal;
}
return idx;
}
const char *
expand_irp (int irpc, int idx, sb *in, sb *out, int (*get_line) (sb *))
{
sb sub;
formal_entry f;
struct hash_control *h;
const char *err;
idx = sb_skip_white (idx, in);
sb_new (&sub);
if (! buffer_and_nest (NULL, "ENDR", &sub, get_line))
return _("unexpected end of file in irp or irpc");
sb_new (&f.name);
sb_new (&f.def);
sb_new (&f.actual);
idx = get_token (idx, in, &f.name);
if (f.name.len == 0)
return _("missing model parameter");
h = hash_new ();
err = hash_jam (h, sb_terminate (&f.name), &f);
if (err != NULL)
return err;
f.index = 1;
f.next = NULL;
f.type = FORMAL_OPTIONAL;
sb_reset (out);
idx = sb_skip_comma (idx, in);
if (idx >= in->len)
{
/* Expand once with a null string. */
err = macro_expand_body (&sub, out, &f, h, 0);
}
else
{
bfd_boolean in_quotes = FALSE;
if (irpc && in->ptr[idx] == '"')
{
in_quotes = TRUE;
++idx;
}
while (idx < in->len)
{
if (!irpc)
idx = get_any_string (idx, in, &f.actual);
else
{
if (in->ptr[idx] == '"')
{
int nxt;
if (irpc)
in_quotes = ! in_quotes;
nxt = sb_skip_white (idx + 1, in);
if (nxt >= in->len)
{
idx = nxt;
break;
}
}
sb_reset (&f.actual);
sb_add_char (&f.actual, in->ptr[idx]);
++idx;
}
err = macro_expand_body (&sub, out, &f, h, 0);
if (err != NULL)
break;
if (!irpc)
idx = sb_skip_comma (idx, in);
else if (! in_quotes)
idx = sb_skip_white (idx, in);
}
}
hash_die (h);
sb_kill (&f.actual);
sb_kill (&f.def);
sb_kill (&f.name);
sb_kill (&sub);
return err;
}
/*
* Returns:
* 0 Success
* 1 Incorrect usage (i.e., command-line syntax error).
* 2 No such parameter or node. Error message written.
* 3 System error. Error message written.
*/
int main(
int argc,
char* argv[])
{
int status;
const char* const progname = basename(argv[0]);
(void)log_init(progname);
if ((status = sb_new(&_valuePath, 80))) {
log_error("Couldn't initialize utility");
status = SYSTEM_ERROR;
}
else {
enum {
UNKNOWN,
CREATE,
PRINT,
PUT_BOOL,
PUT_STRING,
PUT_UINT,
PUT_SIGNATURE,
PUT_TIME,
RESET,
REMOVE
} action = UNKNOWN;
const char* string;
signaturet signature;
timestampt timestamp;
unsigned long uint;
int boolean;
int ch;
int quiet = 0;
opterr = 0; /* supress getopt(3) error messages */
while (0 == status && (ch = getopt(argc, argv, ":b:cd:h:qRrs:t:u:vx"))
!= -1) {
switch (ch) {
case 'b': {
if (strcasecmp(optarg, "TRUE") == 0) {
boolean = 1;
}
else if (strcasecmp(optarg, "FALSE") == 0) {
boolean = 0;
}
else {
log_add("Not a boolean value: \"%s\"", optarg);
status = COMMAND_SYNTAX;
}
if (status == 0) {
if (CREATE == action) {
log_error("Create option ignored");
}
action = PUT_BOOL;
}
break;
}
case 'c': {
if (UNKNOWN != action) {
log_add("Can't mix create action with other actions");
status = COMMAND_SYNTAX;
}
else {
action = CREATE;
}
break;
}
case 'd': {
if ((status = reg_setDirectory(optarg)))
status = SYSTEM_ERROR;
break;
}
case 'h': {
status = sigParse(optarg, &signature);
if (0 > status || 0 != optarg[status]) {
log_add("Not a signature: \"%s\"", optarg);
status = COMMAND_SYNTAX;
}
else {
if (CREATE == action) {
log_info("Create action ignored");
}
action = PUT_SIGNATURE;
status = 0;
}
break;
}
case 'q': {
quiet = 1;
break;
}
case 'R': {
if (UNKNOWN != action) {
log_add("Can't mix reset action with other actions");
status = COMMAND_SYNTAX;
}
else {
action = RESET;
}
break;
}
case 'r': {
if (UNKNOWN != action) {
log_add("Can't mix remove action with other actions");
status = COMMAND_SYNTAX;
}
else {
action = REMOVE;
}
break;
}
case 's': {
if (CREATE == action) {
log_info("Create action ignored");
}
string = optarg;
action = PUT_STRING;
break;
}
case 't': {
status = tsParse(optarg, ×tamp);
if (0 > status || 0 != optarg[status]) {
log_add("Not a timestamp: \"%s\"", optarg);
status = COMMAND_SYNTAX;
}
else {
if (CREATE == action) {
log_info("Create action ignored");
}
action = PUT_TIME;
status = 0;
}
break;
}
case 'u': {
char* end;
errno = 0;
uint = strtoul(optarg, &end, 0);
if (0 != *end || (0 == uint && 0 != errno)) {
log_add("Not an unsigned integer: \"%s\"", optarg);
status = COMMAND_SYNTAX;
}
else {
if (CREATE == action) {
log_info("Create option ignored");
}
action = PUT_UINT;
}
break;
}
case 'v': {
if (!log_is_enabled_info)
(void)log_set_level(LOG_LEVEL_INFO);
break;
}
case 'x': {
(void)log_set_level(LOG_LEVEL_DEBUG);
break;
}
case ':': {
log_add("Option \"-%c\" requires an operand", optopt);
status = COMMAND_SYNTAX;
break;
}
default:
log_add("Unknown option: \"%c\"", optopt);
status = COMMAND_SYNTAX;
/* no break */
}
} /* options loop */
if (status) {
log_flush_error();
if (COMMAND_SYNTAX == status)
usage(progname);
}
else {
const int argCount = argc - optind;
if (UNKNOWN == action)
action = PRINT;
switch (action) {
case CREATE: {
if (0 < argCount) {
log_error("Too many arguments");
usage(progname);
status = COMMAND_SYNTAX;
}
else {
status = createRegistry();
}
break;
}
case RESET: {
if (0 < argCount) {
log_error("Too many arguments");
usage(progname);
status = COMMAND_SYNTAX;
}
else {
status = resetRegistry();
}
break;
}
case REMOVE: {
if (0 == argCount) {
log_error(
"Removal action requires absolute pathname(s)");
usage(progname);
status = COMMAND_SYNTAX;
}
else {
log_debug("Removing registry");
status = actUponPathList(argv + optind, deletePath,
quiet);
}
break;
}
case PRINT: {
log_debug("Printing registry");
status = (0 == argCount)
? printPath("/", quiet)
: actUponPathList(argv + optind, printPath, quiet);
break;
}
default: {
/*
* Must be some kind of "put".
*/
if (0 == argCount) {
log_error("Put action requires value pathname");
usage(progname);
status = COMMAND_SYNTAX;
}
else {
switch (action) {
case PUT_BOOL:
status = reg_putBool(argv[optind], boolean);
break;
case PUT_UINT:
status = reg_putUint(argv[optind], uint);
break;
case PUT_STRING:
status = reg_putString(argv[optind], string);
break;
case PUT_TIME:
status = reg_putTime(argv[optind], ×tamp);
break;
case PUT_SIGNATURE:
status = reg_putSignature(argv[optind], signature);
break;
default:
abort();
}
if (status) {
log_flush_error();
status = SYSTEM_ERROR;
}
}
} /* put switch */
/* no break */
} /* "action" switch */
} /* decoded options */
sb_free(_valuePath);
} /* "_valuePath" allocated */
return status;
}
static const char *
macro_expand (int idx, sb *in, macro_entry *m, sb *out)
{
sb t;
formal_entry *ptr;
formal_entry *f;
int is_keyword = 0;
int narg = 0;
const char *err = NULL;
sb_new (&t);
/* Reset any old value the actuals may have. */
for (f = m->formals; f; f = f->next)
sb_reset (&f->actual);
f = m->formals;
while (f != NULL && f->index < 0)
f = f->next;
if (macro_mri)
{
/* The macro may be called with an optional qualifier, which may
be referred to in the macro body as \0. */
if (idx < in->len && in->ptr[idx] == '.')
{
/* The Microtec assembler ignores this if followed by a white space.
(Macro invocation with empty extension) */
idx++;
if ( idx < in->len
&& in->ptr[idx] != ' '
&& in->ptr[idx] != '\t')
{
formal_entry *n = new_formal ();
n->index = QUAL_INDEX;
n->next = m->formals;
m->formals = n;
idx = get_any_string (idx, in, &n->actual);
}
}
}
/* Peel off the actuals and store them away in the hash tables' actuals. */
idx = sb_skip_white (idx, in);
while (idx < in->len)
{
int scan;
/* Look and see if it's a positional or keyword arg. */
scan = idx;
while (scan < in->len
&& !ISSEP (in->ptr[scan])
&& !(macro_mri && in->ptr[scan] == '\'')
&& (!macro_alternate && in->ptr[scan] != '='))
scan++;
if (scan < in->len && !macro_alternate && in->ptr[scan] == '=')
{
is_keyword = 1;
/* It's OK to go from positional to keyword. */
/* This is a keyword arg, fetch the formal name and
then the actual stuff. */
sb_reset (&t);
idx = get_token (idx, in, &t);
if (in->ptr[idx] != '=')
{
err = _("confusion in formal parameters");
break;
}
/* Lookup the formal in the macro's list. */
ptr = (formal_entry *) hash_find (m->formal_hash, sb_terminate (&t));
if (!ptr)
as_bad (_("Parameter named `%s' does not exist for macro `%s'"),
t.ptr,
m->name);
else
{
/* Insert this value into the right place. */
if (ptr->actual.len)
{
as_warn (_("Value for parameter `%s' of macro `%s' was already specified"),
ptr->name.ptr,
m->name);
sb_reset (&ptr->actual);
}
idx = get_any_string (idx + 1, in, &ptr->actual);
if (ptr->actual.len > 0)
++narg;
}
}
else
{
if (is_keyword)
{
err = _("can't mix positional and keyword arguments");
break;
}
if (!f)
{
formal_entry **pf;
int c;
if (!macro_mri)
{
err = _("too many positional arguments");
break;
}
f = new_formal ();
c = -1;
for (pf = &m->formals; *pf != NULL; pf = &(*pf)->next)
if ((*pf)->index >= c)
c = (*pf)->index + 1;
if (c == -1)
c = 0;
*pf = f;
f->index = c;
}
if (f->type != FORMAL_VARARG)
idx = get_any_string (idx, in, &f->actual);
else
{
sb_add_buffer (&f->actual, in->ptr + idx, in->len - idx);
idx = in->len;
}
if (f->actual.len > 0)
++narg;
do
{
f = f->next;
}
while (f != NULL && f->index < 0);
}
if (! macro_mri)
idx = sb_skip_comma (idx, in);
else
{
if (in->ptr[idx] == ',')
++idx;
if (ISWHITE (in->ptr[idx]))
break;
}
}
if (! err)
{
for (ptr = m->formals; ptr; ptr = ptr->next)
{
if (ptr->type == FORMAL_REQUIRED && ptr->actual.len == 0)
as_bad (_("Missing value for required parameter `%s' of macro `%s'"),
ptr->name.ptr,
m->name);
}
if (macro_mri)
{
char buffer[20];
sb_reset (&t);
sb_add_string (&t, macro_strip_at ? "$NARG" : "NARG");
ptr = (formal_entry *) hash_find (m->formal_hash, sb_terminate (&t));
sprintf (buffer, "%d", narg);
sb_add_string (&ptr->actual, buffer);
}
err = macro_expand_body (&m->sub, out, m->formals, m->formal_hash, m);
}
/* Discard any unnamed formal arguments. */
if (macro_mri)
{
formal_entry **pf;
pf = &m->formals;
while (*pf != NULL)
{
if ((*pf)->name.len != 0)
pf = &(*pf)->next;
else
{
f = (*pf)->next;
del_formal (*pf);
*pf = f;
}
}
}
sb_kill (&t);
if (!err)
macro_number++;
return err;
}
static int
do_formals (macro_entry *macro, int idx, sb *in)
{
formal_entry **p = ¯o->formals;
macro->formal_count = 0;
macro->formal_hash = hash_new ();
while (idx < in->len)
{
formal_entry *formal;
formal = (formal_entry *) xmalloc (sizeof (formal_entry));
sb_new (&formal->name);
sb_new (&formal->def);
sb_new (&formal->actual);
idx = sb_skip_white (idx, in);
idx = get_token (idx, in, &formal->name);
if (formal->name.len == 0)
break;
idx = sb_skip_white (idx, in);
if (formal->name.len)
{
/* This is a formal. */
if (idx < in->len && in->ptr[idx] == '=')
{
/* Got a default. */
idx = get_any_string (idx + 1, in, &formal->def, 1, 0);
}
}
/* Add to macro's hash table. */
hash_jam (macro->formal_hash, sb_terminate (&formal->name), formal);
formal->index = macro->formal_count;
idx = sb_skip_comma (idx, in);
macro->formal_count++;
*p = formal;
p = &formal->next;
*p = NULL;
}
if (macro_mri)
{
formal_entry *formal;
const char *name;
/* Add a special NARG formal, which macro_expand will set to the
number of arguments. */
formal = (formal_entry *) xmalloc (sizeof (formal_entry));
sb_new (&formal->name);
sb_new (&formal->def);
sb_new (&formal->actual);
/* The same MRI assemblers which treat '@' characters also use
the name $NARG. At least until we find an exception. */
if (macro_strip_at)
name = "$NARG";
else
name = "NARG";
sb_add_string (&formal->name, name);
/* Add to macro's hash table. */
hash_jam (macro->formal_hash, name, formal);
formal->index = NARG_INDEX;
*p = formal;
formal->next = NULL;
}
return idx;
}
int main (int argc, char *argv[]){
char hostname[20];
int port ;
int lastopt=0;
int longindex=0;
int msg_type=EQUEUE_QUEUE;
char topic[255];
char message[255];
SAPO_BROKER_T * conn=0;
int role = ROLE_NONE;
strcpy(topic, "/sapo/adword\0");
strcpy (message, "Hello world\0");
strcpy(hostname,DEFAULT_HOST);
port = DEFAULT_PORT;
while (1) {
lastopt = getopt_long(argc,argv,"q:h:p:t:m:ris",long_options,&longindex);
if (lastopt == -1)
break;
switch (lastopt) {
case 0:
break;
case 'h':
printf ("hostname = %s\n", optarg);
strncpy(hostname, optarg, 20);
break;
case 'p':
printf ("port = %s\n", optarg);
port = atoi(optarg);
break;
case 't':
printf ("Using topic : %s\n",optarg);
strcpy(topic, optarg);
break;
case 'm':
printf ("Using message: %s\n", optarg);
strcpy(message, optarg);
break;
case 'r':
if (role){
printf("Cannot be receiver and sender/interactive at the same time\n");
exit(1);
}
printf ("Will subscribe the topic and receive only\n");
role = ROLE_RECEIVER;
break;
case 'c':
count = 0;
break;
case 'i':
if (role){
printf("Cannot be interactive and sender/receiver at the same time\n");
exit(1);
}
printf("Showing interactive menu\n");
role = ROLE_INTERACTIVE;
break;
case 's':
if (role){
printf("Cannot be sender and interactive/receiver at the same time\n");
exit(1);
}
printf("Will send to the topic only\n");
role = ROLE_SENDER;
break;
case 'q':
msg_type = atoi(optarg);
if ((msg_type< 1) || (msg_type>3)){
printf("Invalid message type %d. Only valid 1,2 or 3",msg_type);
usage(argv[0]);
exit(0);
}
break;
case '?':
usage(argv[0]);
exit(0);
default:
printf ("Bad param %c \n", lastopt);
usage(argv[0]);
exit(1);
}
}
conn = sb_new(hostname , port, SB_TYPE_TCP);
switch(role){
case ROLE_INTERACTIVE:
interactive(conn, msg_type, topic, message);
break;
case ROLE_SENDER:
sender(conn, msg_type, topic, message);
break;
case ROLE_RECEIVER :
receiver(conn, msg_type, topic);
break;
default:
printf("No role provided. Defaulting to interactive\n");
interactive(conn, msg_type, topic, message);
}
if (conn)
sb_destroy(conn);
return 0;
}
/**
* ngt_embed - Turn one or more template files into C code for embedding into programs
*/
int ngt_embed(const char* code_template, FILE* out, int argc, char** argv) {
int i;
ngt_template* tpl;
ngt_dictionary* dict;
char* output;
char file[PATH_MAX];
char name[PATH_MAX];
if (argc == 1) {
fprintf(stderr, "USAGE: ngtembed file1[=name1] file2[=name2] ... fileN[=nameN] [>out_file]\n");
return -1;
}
tpl = ngt_new();
dict = ngt_dictionary_new();
ngt_add_modifier(tpl, "breakup_lines", _breakup_lines_modifier_cb);
ngt_set_delimiters(tpl, "@", "@");
ngt_set_dictionary(tpl, dict);
tpl->tmpl = (char*)code_template;
for (i = 1; i < argc; i++) {
char* p;
int m, has_name;
p = argv[i];
m = 0;
has_name = 0;
while (*p) {
if (m < PATH_MAX && *p == '=') {
// Setting an explicit name. Throw out what we've done so far
has_name = 1;
m = 0;
p++;
continue;
}
if (*p == '.' || *p == '\\' || *p == '/') {
name[m] = '_';
} else {
name[m] = *p;
}
if (!has_name) {
file[m] = *p;
file[m+1] = '\0';
}
p++;
m++;
}
name[m] = '\0';
if (m) {
stringbuilder* sb;
FILE* fd;
int ch;
fd = fopen(file, "r");
if (!fd) {
fprintf(stderr, "Could not open '%s' for reading\n", file);
return -1;
}
ngt_dictionary* section = ngt_dictionary_new();
ngt_set_string(section, "TemplateName", name);
sb = sb_new();
while ((ch = fgetc(fd)) != EOF) {
sb_append_ch(sb, (char)ch);
}
ngt_set_string(section, "TemplateBody", sb_cstring(sb));
sb_destroy(sb, 1);
ngt_add_dictionary(dict, "Template", section, NGT_SECTION_VISIBLE);
fclose(fd);
}
}
ngt_expand(tpl, &output);
fprintf(out, "%s\n", output);
ngt_destroy(tpl);
ngt_dictionary_destroy(dict);
free(output);
}
