no_ignore static ubik_error
_print_interface(struct ubik_ast_interface *i, int indent)
{
struct ubik_type_params *p;
struct ubik_ast_member_list *m;
ubik_error err;
_indent(indent);
printf("interface %s:%s\n", i->name.package, i->name.name);
_indent(indent + 4);
printf("params:");
for (p = i->params; p != NULL; p = p->next)
printf(" %s:%s", p->name.package, p->name.name);
printf("\n");
_indent(indent + 4);
printf("members:\n");
for (m = i->members; m != NULL; m = m->next)
{
_indent(indent + 8);
printf(". %s ^ ", m->name);
err = ubik_type_expr_print(m->type);
if (err != OK)
return err;
printf("\n");
}
return OK;
}
no_ignore ubik_error
_print_implementation(struct ubik_ast_implementation *i, int indent)
{
struct ubik_type_list *p;
struct ubik_ast_member_list *m;
ubik_error err;
_indent(indent);
printf("implementation of %s\n", i->iface_name);
_indent(indent + 4);
printf("params:\n");
for (p = i->params; p != NULL; p = p->next)
{
_indent(indent + 8);
err = ubik_type_expr_print(p->type_expr);
if (err != OK)
return err;
printf("\n");
}
_indent(indent + 4);
printf("members:\n");
for (m = i->members; m != NULL; m = m->next)
{
_indent(indent + 8);
printf(". %s = ", m->name);
err = _print_expr(m->value, indent + 8);
if (err != OK)
return err;
printf("\n");
}
return OK;
}
int
cint_variable_print(cint_variable_t* v, int indent, const char* vname)
{
if((v->dt.cap &&
v->dt.cap->format &&
v->dt.desc.num_dimensions == v->dt.type_num_dimensions) ||
v->dt.desc.num_dimensions == 0) {
return __cint_variable_print(v, indent, vname);
}
else {
int elementSize;
cint_variable_t pv = *v;
_indent(indent);
CINT_PRINTF("%s %s = {\n", cint_datatype_format(&v->dt, 0), vname);
pv.dt.desc.num_dimensions = 0;
elementSize = cint_datatype_size(&pv.dt);
__cint_variable_print_array(
v,
&pv,
0,
elementSize,
vname,
indent + 4);
_indent(indent);
CINT_PRINTF("}\n");
}
return 0;
}
//
// addKeyValuePairToList()
//
void XHTMLR::addKeyValuePairToList(const std::string &key,const std::string &value){
_indent();
_ss << "<" << _listItemTag << " class=\"" << key << "\">" << value << "</" << _listItemTag << ">" << std::endl;
}
no_ignore static ubik_error
_print_case_stmts(struct ubik_ast_case *case_stmt, int indent)
{
ubik_error err;
while (case_stmt != NULL)
{
_indent(indent);
printf("( ");
if (case_stmt->head != NULL)
{
err = _print_expr(case_stmt->head, indent);
if (err != OK)
return err;
}
printf(" => ");
err = _print_expr(case_stmt->tail, indent);
if (err != OK)
return err;
printf(" )\n");
case_stmt = case_stmt->next;
}
return OK;
}
//
// addKeyValuePair
//
void XHTMLR::addKeyValuePair(const std::string &key,const std::string &value){
_indent();
std::string humanReadableKey = key;
BasicLatin::segmentize(humanReadableKey);
_ss << "<" << _keyValuePairTag << " class=\"" << key << "\">" << "<span class=\"key\">" << humanReadableKey << "</span>: <span class=\"val\">" << value << "</span></" << _keyValuePairTag << ">" << std::endl;
}
//
// startList()
//
void XHTMLR::startList(const std::string &key){
_indent();
_start(key);
_setAsListContainer();
_ss << "<" << _startListTag << " class=\"" << key << "\">" << std::endl;
}
//
// endList
//
void XHTMLR::endList(const std::string &key){
_end(key);
_indent();
//
// 'start' and 'end' tag have to match
// and we just decided to call the tag '_startListTag'
// because it was easy to remember that way:
//
_ss << "</" << _startListTag << ">" << std::endl;
}
void StackTrace::add(bool is, ssh_wcs func, ssh_wcs file, int line)
{
is_disabled = true;
String tmp;
if(!is) indent--;
if(cdepth >= depth) remove_node();
cdepth++;
if(indent < 0) indent = 0;
String _indent(L' ', indent * 2);
add_node(file ? tmp.fmt(L"%s%c%s() - (%s:%i)", _indent, (is ? L'+' : L'-'), func, file, line) : tmp.fmt(L"%s%c%s()", _indent, (is ? L'+' : L'-'), func));
if(is) indent++;
is_disabled = false;
}
static no_ignore ubik_error
_print_test(struct ubik_ast_test *test, int indent)
{
ubik_error err;
_indent(indent);
printf("?: ");
err = _print_expr(test->actual, indent + 4);
if (err != OK)
return err;
printf(" = ");
err = _print_expr(test->expected, indent + 4);
if (err != OK)
return err;
printf("\n");
return OK;
}
//
// start
//
void XHTMLR::start(const std::string &key){
_indent();
//
// We need to know if the *parent* is a list
// container, so this must come before _start(key):
//
bool isAListContainer = _isAListContainer();
_start(key);
if(isAListContainer){
_ss << "<" << _listItemTag << " class=\"" << key << "\">" << std::endl;
}else{
_ss << "<" << _startTag << " class=\"" << key << "\">" << std::endl;
}
}
static void
_parcDisplayIndented_Print(int indentation, char *string)
{
char *start = string;
char *end = strchr(start, '\n');
while (start != NULL) {
_indent(indentation);
if (end != NULL) {
ssize_t nwritten = write(1, start, end - start + 1);
assertTrue(nwritten >= 0, "Error calling write");
start = end + 1;
} else {
ssize_t nwritten = write(1, start, strlen(start));
assertTrue(nwritten >= 0, "Error calling write");
break;
}
end = strchr(start, '\n');
}
}
//
// end
//
void XHTMLR::end(const std::string &key){
_end(key);
_indent();
//
// We need to know if the *parent* is a list:
//
if( _isAListContainer() ){
_ss << "</" << _listItemTag << ">" << std::endl;
}else{
//
// 'start' and 'end' tag have to match
// and we just decided to call the tag '_startTag'
// because it was easy to remember that way:
//
_ss << "</" << _startTag << ">" << std::endl;
}
}
no_ignore ubik_error
_print_ast(struct ubik_ast *ast, int indent)
{
size_t i;
ubik_error err;
struct ubik_ast_binding *b;
struct ubik_ast_import_list *imports;
_indent(indent);
printf("package %s\n", ast->package_name);
imports = ast->imports;
while (imports != NULL)
{
_indent(indent);
printf("import %s as %s\n", imports->canonical, imports->name);
imports = imports->next;
}
if (ast->types.n > 0)
{
_indent(indent);
printf("%lu types:\n", ast->types.n);
for (i = 0; i < ast->types.n; i++)
{
err = _print_type(ast->types.elems[i], indent + 4);
if (err != OK)
return err;
}
}
if (ast->interfaces.n > 0)
{
_indent(indent);
printf("%lu interfaces:\n", ast->interfaces.n);
for (i = 0; i < ast->interfaces.n; i++)
{
err = _print_interface(
ast->interfaces.elems[i], indent + 4);
if (err != OK)
return err;
}
}
if (ast->implementations.n > 0)
{
_indent(indent);
printf("%lu implementations:\n", ast->implementations.n);
for (i = 0; i < ast->implementations.n; i++)
{
err = _print_implementation(
ast->implementations.elems[i], indent + 4);
if (err != OK)
return err;
}
}
_indent(indent);
if (ast->bindings.n > 0)
printf("%lu bindings:\n", ast->bindings.n);
else
printf("bindings: none\n");
for (i = 0; i < ast->bindings.n; i++)
{
b = ast->bindings.elems[i];
_indent(indent + 4);
printf("bind %s", b->name);
if (b->type_expr != NULL)
{
printf(" ^ ");
err = ubik_type_expr_print(b->type_expr);
if (err != OK)
return err;
}
printf(" = ");
err = _print_expr(b->expr, indent);
if (err != OK)
return err;
printf("\n");
}
if (ast->tests.n > 0)
{
_indent(indent);
printf("%lu tests:\n", ast->tests.n);
for (i = 0; i < ast->tests.n; i++)
{
err = _print_test(ast->tests.elems[i], indent + 4);
if (err != OK)
return err;
}
}
if (ast->immediate != NULL)
{
_indent(indent);
printf("immediate = ");
err = _print_expr(ast->immediate, indent);
if (err != OK)
return err;
printf("\n");
}
return OK;
}
std::string xml_formatter::end_tag(std::string name)
{
_indent();
return indent() + "</" + name + ">";
}
void AXmlElement::emit(AOutputBuffer& target, int indent) const
{
if (!m_Name.isEmpty())
{
//a_Element has a name
if (indent >= 0)
{
if (indent)
target.append(AConstant::ASTRING_CRLF); //a_End of line
for (int i=0; i<indent; ++i) target.append(AConstant::ASTRING_TWOSPACES); //a_Indentation
}
target.append(AXmlElement::sstr_Start);
target.append(m_Name);
//a_Display attributes of this element
if (m_Attributes.size() > 0)
{
target.append(AConstant::ASTRING_SPACE);
m_Attributes.emit(target);
}
CONTAINER::const_iterator cit = m_Content.begin();
int iSubElementCount = 0;
if (cit != m_Content.end())
{
target.append(AXmlElement::sstr_End);
while (cit != m_Content.end())
{
if ((*cit)->isData())
{
(*cit)->emit(target, indent);
}
else
{
(*cit)->emit(target, (indent >= 0 ? indent+1 : indent));
++iSubElementCount;
}
++cit;
}
if (iSubElementCount > 0 && indent >= 0)
{
target.append(AConstant::ASTRING_CRLF); //a_End of line
_indent(target, indent);
}
target.append(AXmlElement::sstr_StartEnd);
target.append(m_Name);
target.append(AXmlElement::sstr_End);
}
else
{
target.append(AXmlElement::sstr_EndSingular);
}
}
else
{
//a_Element has no name, just iterate the children if any
CONTAINER::const_iterator cit = m_Content.begin();
if (cit != m_Content.end())
{
while (cit != m_Content.end())
{
(*cit)->emit(target, indent);
++cit;
}
}
}
}
/*
* Used for interactive interpreter "print" command
*/
static int
__cint_variable_print(cint_variable_t* v, int indent, const char* vname)
{
char fbuffer[CINT_CONFIG_MAX_STACK_PRINT_BUFFER];
const char* datatype;
if(v == NULL) {
return CINT_E_BAD_VARIABLE;
}
if(vname == NULL) {
vname = v->name;
}
if(vname[0] == '_' &&
vname[1] == '_' &&
vname[2] == 'a' &&
vname[3] == 'u' &&
vname[4] == 't' &&
vname[5] == 'o') {
vname = "$$";
}
datatype = cint_datatype_format(&v->dt, 0);
if(v->dt.desc.pcount || (v->dt.flags & CINT_DATATYPE_F_FUNC_POINTER)) {
/*
* This is a pointer
*/
_indent(indent);
CINT_PRINTF("%s %s = ", datatype, vname);
__pointer_print((void**)v->data);
CINT_PRINTF("\n");
return 0;
}
/*
* Atomic or structure types
*/
if(v->dt.cap && v->dt.cap->format) {
_indent(indent);
CINT_PRINTF("%s %s = ", datatype, vname);
v->dt.cap->format(v->data, fbuffer, sizeof(fbuffer), cintAtomicFormatCintPrintVariable);
CINT_PRINTF("%s\n", fbuffer);
}
else if(v->dt.flags & CINT_DATATYPE_F_ATOMIC) {
_indent(indent);
CINT_PRINTF("%s %s = ", datatype, vname);
v->dt.basetype.ap->format(v->data, fbuffer, sizeof(fbuffer), cintAtomicFormatCintPrintVariable);
CINT_PRINTF("%s\n", fbuffer);
}
else if(v->dt.flags & CINT_DATATYPE_F_ENUM) {
cint_enum_map_t* em = _enum_find(v->data, v->dt.basetype.ep->enum_map);
_indent(indent);
CINT_PRINTF("%s %s = %s (%d)\n", datatype, vname,
(em) ? em->name : "<invalid enum>", (em) ? em->value : *(int*)v->data);
}
else if(v->dt.flags & CINT_DATATYPE_F_STRUCT) {
const cint_parameter_desc_t* sm;
int i = 0;
_indent(indent);
CINT_PRINTF("%s %s = {\n", datatype, vname);
for(sm = v->dt.basetype.sp->struct_members; sm->basetype; sm++) {
/*
* Get the address of this member
*/
cint_variable_t* av;
void* maddr;
maddr = v->dt.basetype.sp->maddr(v->data, i, v->dt.basetype.sp);
/*
* Create an autovariable of the same type pointing to the address of this member
*/
{
cint_datatype_t sdt;
int rc;
sdt.desc = *sm;
cint_strlcpy(sdt.type, sm->basetype, sizeof(sdt.type));
if((rc = cint_variable_create(&av, NULL, &sdt.desc,
CINT_VARIABLE_F_SDATA,
maddr)) < 0) {
if(rc == CINT_E_TYPE_NOT_FOUND) {
/*
* A description for this datatype is missing.
*/
_indent(indent+4);
cint_warn(NULL, 0, "unknown type '%s'", cint_datatype_format(&sdt, 0));
/* Keep going */
i++;
continue;
}
else {
return rc;
}
}
}
/*
* Print the autovar with this member's name
*/
cint_variable_print(av, indent+4, sm->name);
i++;
}
_indent(indent);
CINT_PRINTF("}\n");
}
else if(v->dt.flags & (CINT_DATATYPE_F_FUNC | CINT_DATATYPE_F_FUNC_DYNAMIC)) {
/* Function pointer variable */
_indent(indent);
CINT_PRINTF("%s = %s function ",
vname,
(v->dt.flags & CINT_DATATYPE_F_FUNC) ?
"compiled" : "dynamic");
if (v->dt.basetype.fp->params) {
CINT_PRINTF("'%s %s",
cint_datatype_format_pd(v->dt.basetype.fp->params, 0),
v->dt.basetype.fp->name);
cint_fparams_print(v->dt.basetype.fp->params+1);
} else {
/* CINT vararg functions are special and always return int */
CINT_PRINTF("'int %s(...)",
v->dt.basetype.fp->name);
}
CINT_PRINTF("'\n");
}
return CINT_E_NONE;
}
template <typename Iter> void value::_serialize(Iter oi, int indent) const {
switch (type_) {
case string_type:
serialize_str(*u_.string_, oi);
break;
case array_type: {
*oi++ = '[';
if (indent != -1) {
++indent;
}
for (array::const_iterator i = u_.array_->begin();
i != u_.array_->end();
++i) {
if (i != u_.array_->begin()) {
*oi++ = ',';
}
if (indent != -1) {
_indent(oi, indent);
}
i->_serialize(oi, indent);
}
if (indent != -1) {
--indent;
if (! u_.array_->empty()) {
_indent(oi, indent);
}
}
*oi++ = ']';
break;
}
case object_type: {
*oi++ = '{';
if (indent != -1) {
++indent;
}
for (object::const_iterator i = u_.object_->begin();
i != u_.object_->end();
++i) {
if (i != u_.object_->begin()) {
*oi++ = ',';
}
if (indent != -1) {
_indent(oi, indent);
}
serialize_str(i->first, oi);
*oi++ = ':';
if (indent != -1) {
*oi++ = ' ';
}
i->second._serialize(oi, indent);
}
if (indent != -1) {
--indent;
if (! u_.object_->empty()) {
_indent(oi, indent);
}
}
*oi++ = '}';
break;
}
default:
copy(to_str(), oi);
break;
}
if (indent == 0) {
*oi++ = '\n';
}
}
no_ignore static ubik_error
_print_expr(struct ubik_ast_expr *expr, int indent)
{
ubik_error err;
switch (expr->expr_type)
{
case EXPR_ATOM:
return _print_atom(expr->atom);
case EXPR_APPLY:
printf("(");
err = _print_expr(expr->apply.head, indent);
if (err != OK)
return err;
printf(" ");
if (expr->apply.recursive_app)
printf("$");
err = _print_expr(expr->apply.tail, indent);
if (err != OK)
return err;
printf(")");
return OK;
case EXPR_LAMBDA:
printf("\\ ");
err = _print_arg_list(expr->lambda.args);
if (err != OK)
return err;
printf(" -> ");
err = _print_expr(expr->lambda.body, indent);
if (err != OK)
return err;
return OK;
case EXPR_BLOCK:
printf("{\n");
err = _print_ast(expr->block, indent + 8);
if (err != OK)
return err;
_indent(indent + 4);
printf("}");
return OK;
case EXPR_COND_BLOCK:
printf("(?");
if (expr->cond_block.block_type == COND_PATTERN)
{
printf("pat ");
err = _print_expr(
expr->cond_block.to_match, indent + 4);
if (err != OK)
return err;
printf(")");
}
else
printf("pred)");
printf(" {\n");
err = _print_case_stmts(
expr->cond_block.case_stmts, indent + 4);
if (err != OK)
return err;
_indent(indent);
printf("}");
return OK;
}
return ubik_raise(ERR_UNKNOWN_TYPE, "unknown expr type");
}
no_ignore static ubik_error
_print_type(struct ubik_type *type, int indent)
{
struct ubik_ast_member_list *m;
struct ubik_type_params *p;
struct ubik_type_constraints *c;
struct ubik_ast_adt_ctors *ctor;
ubik_error err;
_indent(indent);
printf("type %s", type->name);
switch (type->type)
{
case TYPE_RECORD:
printf("\n");
m = type->members;
while (m != NULL)
{
_indent(indent + 4);
printf(". %s ^ ", m->name);
err = ubik_type_expr_print(m->type);
if (err != OK)
return err;
m = m->next;
printf("\n");
}
break;
case TYPE_ADT:
p = type->adt.params;
while (p != NULL)
{
printf(" %s:%s", p->name.name, p->name.package);
p = p->next;
if (p != NULL)
printf(" ");
}
printf("\n");
_indent(indent + 4);
printf("|");
c = type->adt.constraints;
while (c != NULL)
{
printf(" ' %s:%s",
c->interface.name, c->interface.package);
p = c->params;
while (p != NULL)
{
printf(" %s:%s",
p->name.name, p->name.package);
p = p->next;
if (p != NULL)
printf(" ");
}
c = c->next;
}
printf("\n");
ctor = type->adt.ctors;
while (ctor != NULL)
{
_indent(indent + 4);
printf("= %s ", ctor->name);
err = _print_type_list(ctor->params);
if (err != OK)
return err;
ctor = ctor->next;
printf("\n");
}
break;
case TYPE_ALIAS:
printf(" = ");
err = ubik_type_expr_print(type->aliases_to);
if (err != OK)
return err;
printf("\n");
}
return OK;
}
void AXmlElement::emitJson(
AOutputBuffer& target,
int indent // = -1
) const
{
if (indent >=0) _indent(target, indent);
target.append(m_Name);
if (m_Content.size() + m_Attributes.size() == 0)
{
target.append(":\"\"",3);
if (indent >=0) target.append(AConstant::ASTRING_CRLF);
return;
}
target.append(':');
if (!hasElements() && !m_Attributes.size())
{
//a_Just content and no attributes or elements
target.append('\"');
emitContent(target);
target.append('\"');
return;
}
bool needsBraces = m_Content.size() > 0 || m_Attributes.size() > 0;
if (needsBraces)
{
target.append('{');
if (indent >=0) target.append(AConstant::ASTRING_CRLF);
}
//a_Add content
size_t attrSize = m_Attributes.size();
if (m_Content.size() > 0)
{
CONTAINER::const_iterator cit = m_Content.begin();
while(cit != m_Content.end())
{
(*cit)->emitJson(target, (indent >= 0 ? indent+1 : indent));
++cit;
if (cit != m_Content.end() || attrSize > 0)
{
target.append(',');
if (indent >=0) target.append(AConstant::ASTRING_CRLF);
}
}
}
//a_Attributes become name:value pairs
if (attrSize > 0)
{
SET_AString names;
m_Attributes.getNames(names);
AXmlAttributes::CONTAINER::const_iterator cit = m_Attributes.getAttributeContainer().begin();
const AXmlAttributes::CONTAINER& container = m_Attributes.getAttributeContainer();
while(cit != container.end())
{
if (indent >=0) _indent(target, indent+1);
target.append((*cit)->getName());
target.append(":\"",2);
target.append((*cit)->getValue());
target.append('\"');
++cit;
if (cit != container.end())
{
target.append(',');
if (indent >= 0) target.append(AConstant::ASTRING_CRLF);
}
}
}
if (needsBraces)
{
if (indent >=0)
{
target.append(AConstant::ASTRING_CRLF);
_indent(target, indent);
}
target.append('}');
}
}
