static void write_function_type(const function_type_t *type)
{
fprintf(out, "(func(");
function_parameter_t *parameter = type->parameters;
int first = 1;
while(parameter != NULL) {
if(!first) {
fprintf(out, ", ");
} else {
first = 0;
}
#if 0
if(parameter->symbol != NULL) {
fprintf(out, "%s : ", parameter->symbol->string);
} else {
/* TODO make up some unused names (or allow _ in fluffy?) */
fprintf(out, "_ : ");
}
#endif
fputs("_ : ", out);
write_type(parameter->type);
parameter = parameter->next;
}
fprintf(out, ") : ");
write_type(type->return_type);
fprintf(out, ")");
}
void test() {
/* Matrix:
* 0 1 0
* 0 | 0
* 1 & 1
* 0 1 0 */
printf("Test: Sblock Matrix\n");
write_lut(LUT_SELF, 0);
write_lut(LUT_AND4, 1);
write_lut(LUT_OR, 2);
write_type(0,1,1, 2);
write_type(0,2,1, 1);
write_state(0,0,1, 1);
write_state(0,2,0, 1);
write_state(0,2,2, 1);
write_state(0,3,1, 1);
swap_cell_storage();
config();
step(1);
readback();
swap_cell_storage();
read_state(0,0,1);
read_state(0,1,1);
read_state(0,2,1);
read_state(0,3,1);
step(1);
readback();
swap_cell_storage();
read_state(0,0,1);
read_state(0,1,1);
read_state(0,2,1);
read_state(0,3,1);
assert_uint32(1, get_state());
assert_uint32(1, get_state());
assert_uint32(0, get_state());
assert_uint32(1, get_state());
assert_uint32(1, get_state());
assert_uint32(1, get_state());
assert_uint32(1, get_state());
assert_uint32(1, get_state());
}
static gboolean
do_typedef(TreeState *state)
{
IDL_tree type = IDL_TYPE_DCL(state->tree).type_spec;
IDL_tree dcls = IDL_TYPE_DCL(state->tree).dcls;
IDL_tree complex;
GSList *doc_comments;
if (IDL_NODE_TYPE(type) == IDLN_TYPE_SEQUENCE) {
XPIDL_WARNING((state->tree, IDL_WARNING1,
"sequences not supported, ignored"));
} else {
if (IDL_NODE_TYPE(complex = IDL_LIST(dcls).data) == IDLN_TYPE_ARRAY) {
IDL_tree dim = IDL_TYPE_ARRAY(complex).size_list;
doc_comments = IDL_IDENT(IDL_TYPE_ARRAY(complex).ident).comments;
if (doc_comments != NULL)
printlist(state->file, doc_comments);
fputs("typedef ", state->file);
if (!write_type(type, FALSE, state->file))
return FALSE;
fputs(" ", state->file);
fprintf(state->file, "%s",
IDL_IDENT(IDL_TYPE_ARRAY(complex).ident).str);
do {
fputc('[', state->file);
if (IDL_LIST(dim).data) {
fprintf(state->file, "%ld",
(long)IDL_INTEGER(IDL_LIST(dim).data).value);
}
fputc(']', state->file);
} while ((dim = IDL_LIST(dim).next) != NULL);
} else {
doc_comments = IDL_IDENT(IDL_LIST(dcls).data).comments;
if (doc_comments != NULL)
printlist(state->file, doc_comments);
fputs("typedef ", state->file);
if (!write_type(type, FALSE, state->file))
return FALSE;
fputs(" ", state->file);
fputs(IDL_IDENT(IDL_LIST(dcls).data).str, state->file);
}
fputs(";\n\n", state->file);
}
return TRUE;
}
/* <typeOfReference></typeOfReference> */
static int
get_type_issuance( fields *f, param *p )
{
int type = TYPE_UNKNOWN;
int i, monographic = 0, monographic_level = 0;
// int text = 0;
for ( i=0; i<f->n; ++i ) {
if ( !strcasecmp( f->tag[i].data, "issuance" ) &&
!strcasecmp( f->data[i].data, "MONOGRAPHIC" ) ){
monographic = 1;
monographic_level = f->level[i];
}
// if ( !strcasecmp( f->tag[i].data, "typeOfResource" ) &&
// !strcasecmp( f->data[i].data,"text") ) {
// text = 1;
// }
}
// if ( monographic && text ) {
if ( monographic ) {
if ( monographic_level==0 ) type=TYPE_BOOK;
else if ( monographic_level>0 ) type=TYPE_INBOOK;
}
if ( p->verbose ) {
if ( p->progname ) fprintf( stderr, "%s: ", p->progname );
fprintf( stderr, "Type from issuance/typeOfReference elements: " );
write_type( stderr, type );
fprintf( stderr, "\n" );
}
return type;
}
void UmlOperation::write_cpp_returntype(FileOut & out, QCString decl) {
// doesn't manage function pointer
// manage keywords
int index;
if ((index = decl.find("${static}")) != -1)
decl.remove(index, 9);
if ((index = decl.find("${friend}")) != -1)
decl.remove(index, 9);
if ((index = decl.find("${virtual}")) != -1)
decl.remove(index, 10);
if ((index = decl.find("${inline}")) != -1)
decl.remove(index, 9);
if ((index = decl.find("${(}")) == -1)
decl = "${type} ${name}";
else
decl.truncate(index);
UmlTypeSpec t = returnType();
if ((t.type != 0) ||
!(t.explicit_type = CppSettings::type(t.explicit_type)).isEmpty())
write_type(out, t, decl, "${name}", "${type}");
}
void UmlOperation::write_java_returntype(FileOut & out, QCString decl) {
// manage keywords
int index;
if ((index = decl.find("${visibility}")) != -1)
decl.remove(index, 13);
if ((index = decl.find("${final}")) != -1)
decl.remove(index, 8);
if ((index = decl.find("${static}")) != -1)
decl.remove(index, 9);
if ((index = decl.find("${abstract}")) != -1)
decl.remove(index, 11);
if ((index = decl.find("${synchronized}")) != -1)
decl.remove(index, 15);
if ((index = decl.find("${@}")) != -1)
decl.remove(index, 4);
if ((index = decl.find("${(}")) == -1)
decl = "${type} ${name}";
else
decl.truncate(index);
UmlTypeSpec t = returnType();
if ((t.type != 0) ||
!(t.explicit_type = JavaSettings::type(t.explicit_type)).isEmpty())
write_type(out, t, decl, "${name}", "${type}");
}
void UmlAttribute::write_cpp_type(FileOut & out)
{
// note : doesn't manage function/operation pointer
Q3CString s = cppDecl();
int index;
remove_comments(s);
// remove keywords not linked to the type
if ((index = s.find("${static}")) != -1)
s.replace(index, 9, " ");
if ((index = s.find("${mutable}")) != -1)
s.replace(index, 10, (isCppMutable()) ? "mutable " : "");
if ((index = s.find("${volatile}")) != -1)
s.replace(index, 11, (isVolatile()) ? "volatile " : "");
if ((index = s.find("${value}")) != -1)
s.replace(index, 8, " ");
if ((index = s.find("${h_value}")) != -1)
s.replace(index, 10, " ");
// replace keywords linked to the type
if ((index = s.find("${const}")) != -1)
s.replace(index, 8, isReadOnly() ? "const" : "");
UmlTypeSpec t = type();
if (t.type == 0)
t.explicit_type = CppSettings::type(t.explicit_type);
write_type(out, t, s, "${name}", "${type}");
}
void UmlOperation::write_cpp_java_params(FileOut & out, QCString decl) {
int index1 = decl.find("${(}");
if (index1 == -1)
return;
int index2 = decl.find("${)}", index1 + 4);
if (index2 == -1)
return;
decl = decl.mid(index1 + 4, index2 - index1 - 4);
index1 = 0;
const QValueList<UmlParameter> p = params();
QCString sparam;
QCString kname;
QCString ktype;
int rank;
if ((name() == "unload") && (parent()->name() == "UmlBasePackage"))
rank = 123;
while (get_param(decl, index1, sparam, kname, ktype, rank)) {
if (rank < (int) p.count()) {
const UmlParameter & pa = p[rank];
out.indent();
out << "<UML:Parameter name=\"" << pa.name
<< "\" xmi.id=\"BOUML_op_param_"
<< ++param_id << "\" kind =\"";
switch (pa.dir) {
case InputOutputDirection: out << "inout\">\n"; break;
case OutputDirection: out << "out\">\n"; break;
default: out << "in\">\n";
}
UmlTypeSpec t = pa.type;
if ((t.type != 0) ||
!(t.explicit_type = (_lang == Cpp)
? CppSettings::type(t.explicit_type)
: JavaSettings::type(t.explicit_type)).isEmpty()) {
out.indent();
out << "\t<UML:Parameter.type>\n";
out.indent();
out << "\t\t<UML:DataType";
write_type(out, t, sparam, kname, ktype);
out << "/>\n";
out.indent();
out << "\t</UML:Parameter.type>\n";
}
out.indent();
out << "</UML:Parameter>\n";
}
}
}
static void write_function(const entity_t *entity)
{
if (entity->function.statement != NULL) {
fprintf(stderr, "Warning: can't convert function bodies (at %s)\n",
entity->base.symbol->string);
}
fprintf(out, "func extern %s(", entity->base.symbol->string);
const function_type_t *function_type
= (const function_type_t*) entity->declaration.type;
entity_t *parameter = entity->function.parameters.entities;
int first = 1;
for( ; parameter != NULL; parameter = parameter->base.next) {
assert(parameter->kind == ENTITY_PARAMETER);
if(!first) {
fprintf(out, ", ");
} else {
first = 0;
}
if(parameter->base.symbol != NULL) {
fprintf(out, "%s : ", parameter->base.symbol->string);
} else {
fputs("_ : ", out);
}
write_type(parameter->declaration.type);
}
if(function_type->variadic) {
if(!first) {
fprintf(out, ", ");
} else {
first = 0;
}
fputs("...", out);
}
fprintf(out, ")");
const type_t *return_type = skip_typeref(function_type->return_type);
if(!is_type_atomic(return_type, ATOMIC_TYPE_VOID)) {
fprintf(out, " : ");
write_type(return_type);
}
fputc('\n', out);
}
Stream Stream::create( const char* path, utf_t type )
{
FILE* file = fopen( path, "wt" );
if( file == 0 ) throw File_Open_Failed( path );
write_type( file, type );
return Stream( file, type, true );
}
/* If notype is true, just write the param name. */
static gboolean
write_param(IDL_tree param_tree, FILE *outfile)
{
IDL_tree param_type_spec = IDL_PARAM_DCL(param_tree).param_type_spec;
gboolean is_in = IDL_PARAM_DCL(param_tree).attr == IDL_PARAM_IN;
/* in string, wstring, nsid, domstring, utf8string, cstring and
* astring any explicitly marked [const] are const
*/
if (is_in &&
(IDL_NODE_TYPE(param_type_spec) == IDLN_TYPE_STRING ||
IDL_NODE_TYPE(param_type_spec) == IDLN_TYPE_WIDE_STRING ||
IDL_tree_property_get(IDL_PARAM_DCL(param_tree).simple_declarator,
"const") ||
IDL_tree_property_get(param_type_spec, "nsid") ||
IDL_tree_property_get(param_type_spec, "domstring") ||
IDL_tree_property_get(param_type_spec, "utf8string") ||
IDL_tree_property_get(param_type_spec, "cstring") ||
IDL_tree_property_get(param_type_spec, "astring"))) {
fputs("const ", outfile);
}
else if (IDL_PARAM_DCL(param_tree).attr == IDL_PARAM_OUT &&
IDL_tree_property_get(IDL_PARAM_DCL(param_tree).simple_declarator,
"shared")) {
fputs("const ", outfile);
}
if (!write_type(param_type_spec, !is_in, outfile))
return FALSE;
/* unless the type ended in a *, add a space */
if (!STARRED_TYPE(param_type_spec))
fputc(' ', outfile);
/* out and inout params get a bonus '*' (unless this is type that has a
* 'dipper' class that is passed in to receive 'out' data)
*/
if (IDL_PARAM_DCL(param_tree).attr != IDL_PARAM_IN &&
!DIPPER_TYPE(param_type_spec)) {
fputc('*', outfile);
}
/* arrays get a bonus * too */
/* XXX Should this be a leading '*' or a trailing "[]" ?*/
if (IDL_tree_property_get(IDL_PARAM_DCL(param_tree).simple_declarator,
"array"))
fputc('*', outfile);
fputs(IDL_IDENT(IDL_PARAM_DCL(param_tree).simple_declarator).str, outfile);
if (IDL_PARAM_DCL(param_tree).attr == IDL_PARAM_OUT) {
fputs(" NS_OUTPARAM", outfile);
} else if (IDL_PARAM_DCL(param_tree).attr == IDL_PARAM_INOUT) {
fputs(" NS_INOUTPARAM", outfile);
}
return TRUE;
}
/*
* AS_DECL writes 'NS_IMETHOD foo(string bar, long sil)'
* AS_IMPL writes 'NS_IMETHODIMP className::foo(string bar, long sil)'
* AS_CALL writes 'foo(bar, sil)'
*/
static gboolean
write_attr_accessor(IDL_tree attr_tree, FILE * outfile,
gboolean getter, int mode, const char *className)
{
char *attrname = ATTR_IDENT(attr_tree).str;
const char *binaryname;
IDL_tree ident = IDL_LIST(IDL_ATTR_DCL(attr_tree).simple_declarations).data;
if (mode == AS_DECL) {
if (IDL_tree_property_get(ident, "deprecated"))
fputs("NS_DEPRECATED ", outfile);
if (is_method_scriptable(attr_tree, ident))
fputs("NS_SCRIPTABLE ", outfile);
fputs("NS_IMETHOD ", outfile);
} else if (mode == AS_IMPL) {
fprintf(outfile, "NS_IMETHODIMP %s::", className);
}
fprintf(outfile, "%cet",
getter ? 'G' : 'S');
binaryname = IDL_tree_property_get(ATTR_DECLS(attr_tree), "binaryname");
if (binaryname) {
fprintf(outfile, "%s(",
binaryname);
} else {
fprintf(outfile, "%c%s(",
toupper(*attrname),
attrname + 1);
}
if (mode == AS_DECL || mode == AS_IMPL) {
/* Setters for string, wstring, nsid, domstring, utf8string,
* cstring and astring get const.
*/
if (!getter &&
(IDL_NODE_TYPE(ATTR_TYPE_DECL(attr_tree)) == IDLN_TYPE_STRING ||
IDL_NODE_TYPE(ATTR_TYPE_DECL(attr_tree)) == IDLN_TYPE_WIDE_STRING ||
IDL_tree_property_get(ATTR_TYPE_DECL(attr_tree), "nsid") ||
IDL_tree_property_get(ATTR_TYPE_DECL(attr_tree), "domstring") ||
IDL_tree_property_get(ATTR_TYPE_DECL(attr_tree), "utf8string") ||
IDL_tree_property_get(ATTR_TYPE_DECL(attr_tree), "cstring") ||
IDL_tree_property_get(ATTR_TYPE_DECL(attr_tree), "astring")))
{
fputs("const ", outfile);
}
if (!write_type(ATTR_TYPE_DECL(attr_tree), getter, outfile))
return FALSE;
fprintf(outfile, "%s%s",
(STARRED_TYPE(attr_tree) ? "" : " "),
(getter && !DIPPER_TYPE(ATTR_TYPE_DECL(attr_tree)))? "*" : "");
}
fprintf(outfile, "a%c%s)", toupper(attrname[0]), attrname + 1);
return TRUE;
}
write_type (type t, struct put_fnct *put)
{
switch (t->k)
{
case TYPE_ORD:
sput ("O", put);
break;
case TYPE_FNC:
if (t->fnc.arg->k == TYPE_FNC)
sput ("(", put);
write_type (t->fnc.arg, put);
if (t->fnc.arg->k == TYPE_FNC)
sput (")", put);
sput ("->", put);
write_type (t->fnc.res, put);
break;
default:
sput ("?", put);
}
}
/* Try to determine type of reference from
* <TypeOfResource></TypeOfResource>
*/
static int
get_type_resource( fields *f, param *p )
{
match_type match_res[] = {
{ "software, multimedia", TYPE_PROGRAM },
{ "cartographic", TYPE_MAP },
};
int nmatch_res = sizeof( match_res ) / sizeof( match_res[0] );
int type, i, j;
char *value;
vplist a;
type = TYPE_UNKNOWN;
vplist_init( &a );
fields_findv_each( f, LEVEL_ANY, FIELDS_CHRP, &a, "RESOURCE" );
for ( i=0; i<a.n; ++i ) {
value = ( char * ) vplist_get( &a, i );
for ( j=0; j<nmatch_res; ++j ) {
if ( !strcasecmp( value, match_res[j].name ) )
type = match_res[j].type;
}
if ( p->verbose ) {
if ( p->progname ) fprintf( stderr, "%s: ", p->progname );
fprintf( stderr, "Type from tag 'RESOURCE' data '%s': ", value );
write_type( stderr, type );
fprintf( stderr, "\n" );
}
}
if ( p->verbose ) {
if ( p->progname ) fprintf( stderr, "%s: ", p->progname );
fprintf( stderr, "Type from resource element: " );
write_type( stderr, type );
fprintf( stderr, "\n" );
}
vplist_free( &a );
return type;
}
term ap (term fnc, term arg)
{
type tf, ta;
tf = type_term (fnc);
if (tf->k != TYPE_FNC)
sput ("ap: invalid function\n", err);
ta = type_term (arg);
if (!equal_type (ta, tf->fnc.arg))
{
sput ("ap: bad type\n\tfunction ", err);
write_term (fnc, err);
sput (" has type ", err);
write_type (tf, err);
sput ("\n\targument ", err);
write_term (arg, err);
sput (" has type ", err);
write_type (ta, err);
sput ("\n", err);
}
return ap1 (fnc, arg);
}
static void write_function(const entity_t *entity)
{
if (entity->function.body != NULL) {
fprintf(stderr, "Warning: can't convert function bodies (at %s)\n",
entity->base.symbol->string);
return;
}
const function_type_t *function_type
= (const function_type_t*) entity->declaration.type;
fputc('\n', out);
fprintf(out, "\tpublic static native ");
type_t *return_type = skip_typeref(function_type->return_type);
write_type(return_type);
fprintf(out, " %s(", entity->base.symbol->string);
entity_t *parameter = entity->function.parameters.entities;
separator_t sep = { "", ", " };
int n = 0;
for ( ; parameter != NULL; parameter = parameter->base.next) {
assert(parameter->kind == ENTITY_PARAMETER);
fputs(sep_next(&sep), out);
write_type(parameter->declaration.type);
if (parameter->base.symbol != NULL) {
fprintf(out, " %s", fix_builtin_names(parameter->base.symbol->string));
} else {
fprintf(out, " _%d", n++);
}
}
if (function_type->variadic) {
fputs(sep_next(&sep), out);
fputs("Object ... args", out);
}
fprintf(out, ");\n");
}
static int write_entries(scconf_context * config, scconf_block * block, scconf_entry * entry, int depth)
{
int r, idx;
scconf_entry *e;
if (config->debug) {
fprintf(stderr, "write_entries called, depth %d\n", depth);
}
for (idx = 0; entry[idx].name; idx++) {
e = &entry[idx];
r = write_type(config, block, e, depth);
if (r) {
return r;
}
}
return 0;
}
type type_term (term x)
{
type t;
#ifdef TRACE
sput ("Type of ", err);
write_term (x, err);
sput ("...\n", err);
#endif
t = type_term_1 (x);
#ifdef TRACE
sput ("type of ", err);
write_term (x, err);
sput ("is ", err);
write_type (t, err);
sput (".\n", err);
#endif
return t;
}
/*
* AS_DECL writes 'NS_IMETHOD foo(string bar, long sil)'
* AS_IMPL writes 'NS_IMETHODIMP className::foo(string bar, long sil)'
* AS_CALL writes 'foo(bar, sil)'
*/
static gboolean
write_attr_accessor(IDL_tree attr_tree, FILE * outfile,
gboolean getter, int mode, const char *className)
{
char *attrname = ATTR_IDENT(attr_tree).str;
if (mode == AS_DECL) {
fputs("NS_IMETHOD ", outfile);
} else if (mode == AS_IMPL) {
fprintf(outfile, "NS_IMETHODIMP %s::", className);
}
fprintf(outfile, "%cet%c%s(",
getter ? 'G' : 'S',
toupper(*attrname), attrname + 1);
if (mode == AS_DECL || mode == AS_IMPL) {
/* Setters for string, wstring, nsid, domstring, utf8string,
* cstring and astring get const.
*/
if (!getter &&
(IDL_NODE_TYPE(ATTR_TYPE_DECL(attr_tree)) == IDLN_TYPE_STRING ||
IDL_NODE_TYPE(ATTR_TYPE_DECL(attr_tree)) == IDLN_TYPE_WIDE_STRING ||
IDL_tree_property_get(ATTR_TYPE_DECL(attr_tree), "nsid") ||
IDL_tree_property_get(ATTR_TYPE_DECL(attr_tree), "domstring") ||
IDL_tree_property_get(ATTR_TYPE_DECL(attr_tree), "utf8string") ||
IDL_tree_property_get(ATTR_TYPE_DECL(attr_tree), "cstring") ||
IDL_tree_property_get(ATTR_TYPE_DECL(attr_tree), "astring")))
{
fputs("const ", outfile);
}
if (!write_type(ATTR_TYPE_DECL(attr_tree), getter, outfile))
return FALSE;
fprintf(outfile, "%s%s",
(STARRED_TYPE(attr_tree) ? "" : " "),
(getter && !DIPPER_TYPE(ATTR_TYPE_DECL(attr_tree)))? "*" : "");
}
fprintf(outfile, "a%c%s)", toupper(attrname[0]), attrname + 1);
return TRUE;
}
static int
get_type( fields *f, param *p )
{
int type;
type = get_type_genre( f, p );
if ( type==TYPE_UNKNOWN ) type = get_type_resource( f, p );
if ( type==TYPE_UNKNOWN ) type = get_type_issuance( f, p );
if ( type==TYPE_UNKNOWN ) {
if ( fields_maxlevel( f ) > 0 ) type = TYPE_INBOOK;
else type = TYPE_STD;
}
if ( p->verbose ) {
if ( p->progname ) fprintf( stderr, "%s: ", p->progname );
fprintf( stderr, "Final type: " );
write_type( stderr, type );
fprintf( stderr, "\n" );
}
return type;
}
void UmlAttribute::write_java_type(FileOut & out)
{
Q3CString s = javaDecl();
int index;
remove_comments(s);
// remove keywords not linked to the type
if ((index = s.find("${visibility}")) != -1)
s.replace(index, 13, " ");
if ((index = s.find("${static}")) != -1)
s.replace(index, 9, " ");
if ((index = s.find("${final}")) != -1)
s.replace(index, 8, " ");
if ((index = s.find("${transient}")) != -1)
s.replace(index, 12, " ");
if ((index = s.find("${volatile}")) != -1)
s.replace(index, 11, " ");
if ((index = s.find("${value}")) != -1)
s.replace(index, 8, " ");
if ((index = s.find("${@}")) != -1)
s.replace(index, 4, " ");
UmlTypeSpec t = type();
if (t.type == 0)
t.explicit_type = JavaSettings::type(t.explicit_type);
write_type(out, t, s, "${name}", "${type}");
}
/* Try to determine type of reference from
* <genre></genre>
*/
static int
get_type_genre( fields *f, param *p )
{
match_type match_genres[] = {
{ "academic journal", TYPE_ARTICLE },
{ "article", TYPE_ARTICLE },
{ "journal article", TYPE_ARTICLE },
{ "magazine", TYPE_MAGARTICLE },
{ "conference publication", TYPE_CONF },
{ "newspaper", TYPE_NEWS },
{ "legislation", TYPE_STATUTE },
{ "communication", TYPE_PCOMM },
{ "hearing", TYPE_HEAR },
{ "electronic", TYPE_ELEC },
{ "legal case and case notes", TYPE_CASE },
{ "book chapter", TYPE_INBOOK },
{ "Ph.D. thesis", TYPE_PHDTHESIS },
{ "Masters thesis", TYPE_MASTERSTHESIS },
{ "Diploma thesis", TYPE_DIPLOMATHESIS },
{ "Doctoral thesis", TYPE_DOCTORALTHESIS },
{ "Habilitation thesis", TYPE_HABILITATIONTHESIS },
{ "report", TYPE_REPORT },
{ "abstract or summary", TYPE_ABSTRACT },
{ "patent", TYPE_PATENT },
{ "unpublished", TYPE_UNPUBLISHED },
{ "map", TYPE_MAP },
};
int nmatch_genres = sizeof( match_genres ) / sizeof( match_genres[0] );
int type, i, j;
char *tag, *value;
type = TYPE_UNKNOWN;
for ( i=0; i<fields_num( f ); ++i ) {
if ( !fields_match_tag( f, i, "GENRE" ) &&
!fields_match_tag( f, i, "NGENRE" ) )
continue;
value = ( char * ) fields_value( f, i, FIELDS_CHRP );
for ( j=0; j<nmatch_genres; ++j )
if ( !strcasecmp( match_genres[j].name, value ) )
type = match_genres[j].type;
if ( p->verbose ) {
tag = ( char * ) fields_tag( f, i, FIELDS_CHRP );
if ( p->progname ) fprintf( stderr, "%s: ", p->progname );
fprintf( stderr, "Type from tag '%s' data '%s': ", tag, value );
write_type( stderr, type );
fprintf( stderr, "\n" );
}
if ( type==TYPE_UNKNOWN ) {
if ( !strcasecmp( value, "periodical" ) )
type = TYPE_ARTICLE;
else if ( !strcasecmp( value, "thesis" ) )
type = TYPE_THESIS;
else if ( !strcasecmp( value, "book" ) ) {
if ( fields_level( f, i )==0 ) type=TYPE_BOOK;
else type=TYPE_INBOOK;
}
else if ( !strcasecmp( value, "collection" ) ) {
if ( fields_level( f, i )==0 ) type=TYPE_BOOK;
else type=TYPE_INBOOK;
}
}
}
if ( p->verbose ) {
if ( p->progname ) fprintf( stderr, "%s: ", p->progname );
fprintf( stderr, "Type from genre element: " );
write_type( stderr, type );
fprintf( stderr, "\n" );
}
return type;
}
/*
* Shared between the interface class declaration and the NS_DECL_IFOO macro
* provided to aid declaration of implementation classes.
* mode...
* AS_DECL writes 'NS_IMETHOD foo(string bar, long sil)'
* AS_IMPL writes 'NS_IMETHODIMP className::foo(string bar, long sil)'
* AS_CALL writes 'foo(bar, sil)'
*/
static gboolean
write_method_signature(IDL_tree method_tree, FILE *outfile, int mode,
const char *className)
{
struct _IDL_OP_DCL *op = &IDL_OP_DCL(method_tree);
gboolean no_generated_args = TRUE;
gboolean op_notxpcom =
(IDL_tree_property_get(op->ident, "notxpcom") != NULL);
const char *name;
IDL_tree iter;
if (mode == AS_DECL) {
if (op_notxpcom) {
fputs("NS_IMETHOD_(", outfile);
if (!write_type(op->op_type_spec, FALSE, outfile))
return FALSE;
fputc(')', outfile);
} else {
fputs("NS_IMETHOD", outfile);
}
fputc(' ', outfile);
}
else if (mode == AS_IMPL) {
if (op_notxpcom) {
fputs("NS_IMETHODIMP_(", outfile);
if (!write_type(op->op_type_spec, FALSE, outfile))
return FALSE;
fputc(')', outfile);
} else {
fputs("NS_IMETHODIMP", outfile);
}
fputc(' ', outfile);
}
name = IDL_IDENT(op->ident).str;
if (mode == AS_IMPL) {
fprintf(outfile, "%s::%c%s(", className, toupper(*name), name + 1);
} else {
fprintf(outfile, "%c%s(", toupper(*name), name + 1);
}
for (iter = op->parameter_dcls; iter; iter = IDL_LIST(iter).next) {
if (mode == AS_DECL || mode == AS_IMPL) {
if (!write_param(IDL_LIST(iter).data, outfile))
return FALSE;
} else {
fputs(IDL_IDENT(IDL_PARAM_DCL(IDL_LIST(iter).data)
.simple_declarator).str,
outfile);
}
if ((IDL_LIST(iter).next ||
(!op_notxpcom && op->op_type_spec) || op->f_varargs))
fputs(", ", outfile);
no_generated_args = FALSE;
}
/* make IDL return value into trailing out argument */
if (op->op_type_spec && !op_notxpcom) {
IDL_tree fake_param = IDL_param_dcl_new(IDL_PARAM_OUT,
op->op_type_spec,
IDL_ident_new("_retval"));
if (!fake_param)
return FALSE;
if (mode == AS_DECL || mode == AS_IMPL) {
if (!write_param(fake_param, outfile))
return FALSE;
} else {
fputs("_retval", outfile);
}
if (op->f_varargs)
fputs(", ", outfile);
no_generated_args = FALSE;
}
/* varargs go last */
if (op->f_varargs) {
if (mode == AS_DECL || mode == AS_IMPL) {
fputs("nsVarArgs *", outfile);
}
fputs("_varargs", outfile);
no_generated_args = FALSE;
}
/*
* If generated method has no arguments, output 'void' to avoid C legacy
* behavior of disabling type checking.
*/
if (no_generated_args && mode == AS_DECL) {
fputs("void", outfile);
}
fputc(')', outfile);
return TRUE;
}
static void write_variable(const entity_t *entity)
{
fprintf(out, "var %s : ", entity->base.symbol->string);
write_type(entity->declaration.type);
fprintf(out, "\n");
}
/**
* Determines the transaction code based on the enumeration value received
*
* @return buffer after transaction text line is composed and concatenated for file write
**/
char* Transaction::write(char* dest){
//prepare the code
switch (this->code){
case Transaction::Test:{
//write code
if( debug_transaction) printf("writing code\n");
char* curr = write_code( dest, this->code);
if( error) break;
if( debug_transaction) printf("writing token\n");
curr = write_token( curr);
//write username
if( debug_transaction) printf("writing username\n");
curr = write_username( curr, this->username);
if( error) break;
if( debug_transaction) printf("writing token\n");
curr = write_token( curr);
//write buyer username
if( debug_transaction) printf("writing buyer username\n");
curr = write_username( curr, this->buyer);
if( error) break;
if( debug_transaction) printf("writing token\n");
curr = write_token( curr);
//write seller username
if( debug_transaction) printf("writing seller username\n");
curr = write_username( curr, this->seller);
if( error) break;
if( debug_transaction) printf("writing token\n");
curr = write_token( curr);
//write event name
if( debug_transaction) printf("writing event name\n");
curr = write_eventName( curr, this->eventName);
if( error) break;
if( debug_transaction) printf("writing token\n");
curr = write_token( curr);
//write type
if( debug_transaction) printf("writing type\n");
curr = write_type( curr, this->type);
if( error) break;
if( debug_transaction) printf("writing token\n");
curr = write_token( curr);
//write ticket amount
if( debug_transaction) printf("writing ticket amount\n");
curr = write_ticketAmount( curr, this->ticketAmount);
if( error) break;
if( debug_transaction) printf("writing token\n");
curr = write_token( curr);
//write ticket price
if( debug_transaction) printf("writing ticket price\n");
curr = write_ticketPrice( curr, this->ticketPrice);
if( error) break;
curr = write_token( curr);
//write credit
if( debug_transaction) printf("writing credit\n");
curr = write_credit( curr, this->totalCredits);
if( error) break;
if( debug_transaction) printf("writing token\n");
//good
if( debug_transaction) printf("done\n");
return dest;}
//01-create, 02-delete, 06-addcredit, 00-end of session
//(X field 2, U field 15, T field 2, C field 9, total 28 + 3 = 31)
//XX_UUUUUUUUUUUUUUU_TT_CCCCCCCCC
case Transaction::Create:
case Transaction::Delete:
case Transaction::AddCredit:{
//write code
char* curr = write_code( dest, this->code);
if( error) break;
curr = write_token( curr);
//write username
curr = write_username( curr, this->username);
if( error) break;
curr = write_token( curr);
//write type
curr = write_type( curr, this->type);
if( error) break;
curr = write_token( curr);
//write credit
curr = write_credit( curr, this->totalCredits);
if( error) break;
//done
return dest;}
//05-refund
//(X field 2, U field 15, S field 15, C field 9, total 44)
//XX_UUUUUUUUUUUUUUU_SSSSSSSSSSSSSSS_CCCCCCCCC
case Transaction::Refund:{
//write code
char* curr = write_code( dest, this->code);
if( error) break;
curr = write_token( curr);
//write buyer username
curr = write_username( curr, this->buyer);
if( error) break;
curr = write_token( curr);
//write seller username
curr = write_username( curr, this->seller);
if( error) break;
curr = write_token( curr);
//write credit
curr = write_credit( curr, this->totalCredits);
if( error) break;
//done
return dest;}
//03-sell, 04-buy
//(X field 2, E field 19, S field 15, T field 3, P field 6, total 45+4 = 49)
//XX_EEEEEEEEEEEEEEEEEEE_SSSSSSSSSSSSSSS_TTT_PPPPPP
case Transaction::Buy:
case Transaction::Sell:{
//write code
char* curr = write_code( dest, this->code);
if( error) break;
curr = write_token( curr);
//write seller username
curr = write_username( curr, this->seller);
if( error) break;
curr = write_token( curr);
//write ticket amount
curr = write_ticketAmount( curr, this->ticketAmount);
if( error) break;
curr = write_token( curr);
//write ticket price
curr = write_ticketPrice( curr, this->ticketPrice);
if( error) break;
//done
return dest;}
//manage the error case
default:{
printf("%s\n", Error::TransactionInvalidCode);
break;}}
//handle the error case
printf("%s\n", error_string);
dest[0] = '\0';
printf("transaction: {%s}\n", dest);
return buffer;
}
main ()
{
term x, n;
type t;
term plus_omega, omega_2, plus_omega_2, plus_omega_n, omega_n, omega_omega,
plus_omega_omega;
term f, p;
param_out.fd = stdout;
param_err.fd = stderr;
init ();
/* Exemple : construction de l'ordinal omega * 2 */
x = ap (LIM, ap (ap (S(ORD,ORD,ORD),
ap (ap (S(ORD,fnc(ORD,ORD),fnc(ORD,ORD)),rep(ORD)),
ap(K(fnc(ORD,ORD),ORD),SUC))),
ap(K(ORD,ORD),ap(LIM,I(ORD)))));
sput ("x = ", out);
write_term (x, out);
t = type_term (x);
sput ("\nt = ", out);
write_type (t, out);
sput ("\n", out);
n = var ("n", ORD);
/*
x = ap (LIM, lambda (n,
ap (ap (ap (rep(ORD), n), SUC), ap (LIM, I(ORD)))
));
*/
x = ap (ap (ap (rep(ORD), n), SUC), ap (LIM, I(ORD)));
/* x = ap (rep(ORD), n); */
sput ("x = ", out);
write_term (x, out);
t = type_term (x);
sput ("\nt = ", out);
write_type (t, out);
sput ("\n", out);
x = lambda (n, x);
sput ("x = ", out);
write_term (x, out);
t = type_term (x);
sput ("\nt = ", out);
write_type (t, out);
sput ("\n", out);
x = ap (LIM, x);
sput ("x = ", out);
write_term (x, out);
t = type_term (x);
sput ("\nt = ", out);
write_type (t, out);
sput ("\n", out);
x = var ("x", ORD);
plus_omega = lambda (x, lim (lambda (n,
rpt (ORD, n, SUC, x)
)));
omega_2 = lim (lambda (n, rpt (ORD, n, plus_omega, ZERO)));
t = type_term (omega_2);
sput ("Type of omega_2 = ", out);
write_type (t, out);
sput ("\n", out);
plus_omega_2 = lambda (x, lim (lambda (n,
rpt (ORD, n, plus_omega, x))));
t = type_term (plus_omega_2);
sput ("Type of plus_omega_2 is ", out);
write_type (t, out);
f = var ("f", fnc(ORD,ORD));
p = var ("p", ORD);
plus_omega_n = lambda (n, rpt (fnc(ORD,ORD), n, lambda (f,
lambda (x, lim (lambda (p, rpt (ORD, p, f, x)))) ),
SUC));
/*
next_power = lambda (f,
lambda (x, lim (lambda (p, rpt (ORD, p, f, x)))));
plus_omega_n = lambda (n, rpt (fnc(ORD,ORD), n,
*/
t = type_term (plus_omega_n);
sput ("\nType of plus_omega_n is ", out);
write_type (t, out);
omega_n = lambda (n, ap (ap (plus_omega_n, n), ZERO));
t = type_term (omega_n);
sput ("\nType of omega_n is ", out);
write_type (t, out);
omega_omega = lim (omega_n);
t = type_term (omega_omega);
sput ("\nType of omega_omega is ", out);
write_type (t, out);
plus_omega_omega = lambda (x, lim (lambda (n,
ap (ap (plus_omega_n, n), x) )));
t = type_term (plus_omega_omega);
sput ("\nType of plus_omega_omega is ", out);
write_type (t, out);
sput ("\n", out);
}
write_term (term x, struct put_fnct *put)
{
switch (x->k)
{
case TERM_I:
sput (" I [", put);
write_type (x->I.a, put);
sput ("] ", put);
break;
case TERM_K:
sput (" K [", put);
write_type (x->K.a, put);
sput (", ", put);
write_type (x->K.b, put);
sput ("] ", put);
break;
case TERM_S:
sput (" S [", put);
write_type (x->S.a, put);
sput (", ", put);
write_type (x->S.b, put);
sput (", ", put);
write_type (x->S.c, put);
sput ("] ", put);
break;
case TERM_Y:
sput (" Y [", put);
write_type (x->Y.a, put);
sput ("] ", put);
break;
case TERM_ZERO:
sput (" 0 ", put);
break;
case TERM_SUC:
sput (" suc ", put);
break;
case TERM_LIM:
sput (" lim ", put);
break;
case TERM_REP:
sput (" rep [", put);
write_type (x->rep.a, put);
sput ("] ", put);
break;
case TERM_AP:
sput ("-", put);
write_term (x->ap.fnc, put);
write_term (x->ap.arg, put);
break;
case TERM_VAR:
sput (" <", put);
sput (x->var.name, put);
sput (":", put);
write_type (x->var.typ, put);
sput ("> ", put);
break;
case TERM_UNDEF:
sput (" U ", put);
break;
default:
sput ("?", put);
}
}
static void write_compound_entry(const entity_t *entity)
{
fprintf(out, "\t%s : ", entity->base.symbol->string);
write_type(entity->declaration.type);
fprintf(out, "\n");
}
void io::write(std::ostream& os, const std::string& key, const tag& t)
{
write_type(os, t.get_type());
write_str(os, key);
t.write_payload(os);
}
static void write_pointer_type(const pointer_type_t *type)
{
write_type(type->points_to);
fputc('*', out);
}
