int main(int argc, const char *argv[])
{
TContact_list contact_list = {contact_list.first = NULL, contact_list.last = NULL};
get_dir();
switch(get_mode(argc, argv)){
case DEL:
get_data(&contact_list);
remove_from_list(&contact_list, atoi(argv[2]));
save_csv(&contact_list);
generate_html(&contact_list);
free_list(&contact_list);
break;
case ADD:
get_data(&contact_list);
add_to_list(argv, &contact_list);
sort_list(&contact_list);
save_csv(&contact_list);
generate_html(&contact_list);
free_list(&contact_list);
break;
case LIST:
get_data(&contact_list);
sort_list(&contact_list);
print_list(&contact_list);
save_csv(&contact_list);
generate_html(&contact_list);
free_list(&contact_list);
break;
case SIN:
get_data(&contact_list);
print_single(&contact_list, atoi(argv[2]));
free_list(&contact_list);
break;
case FIND:
get_data(&contact_list);
find_in_list(&contact_list, (char *)argv[2]);
generate_html(&contact_list);
free_list(&contact_list);
break;
case PLIST:
get_data(&contact_list);
sort_list(&contact_list);
generate_plist(&contact_list);
free_list(&contact_list);
break;
case DELN:
get_data(&contact_list);
delete_by_name(&contact_list, (char *)argv[2], (char *)argv[3]);
save_csv(&contact_list);
generate_html(&contact_list);
free_list(&contact_list);
default:
handle_errors();
return EXIT_FAILURE;
}
if(handle_errors() != EXIT_SUCCESS) return EXIT_FAILURE;
else return EXIT_SUCCESS;
}
bool db_query_widget::export_html()
{
lb_status->setText(tr("Html export in progress..."));
if(!generate_html()){
std::cerr << "db_query_widget::" << __FUNCTION__ << ": Error while generating html" << std::endl;
lb_status->setText(tr("Error while generating html"));
return false;
}
pv_text_doc->setHtml(pv_html);
te_text->setDocument(pv_text_doc);
lb_status->setText(tr("Ready"));
return true;
}
bool db_query_widget::export_pdf()
{
generate_html();
QPrinter printer;
QPrintDialog printer_dialog(&printer, NULL);
printer_dialog.exec();
printer.setFullPage(true);
QTextDocument facture;
facture.setPlainText("Test");
facture.print(&printer);
//QPrinter printer;
/* pv_printer->setOrientation(QPrinter::Portrait);
pv_printer->setPageSize(QPrinter::A4);
pv_printer->setResolution(72);
pv_printer->setFullPage(false);
pv_printer->setNumCopies(1);
pv_printer->setOutputFileName("test.pdf");
pv_printer->setOutputFormat(QPrinter::PdfFormat);
*/
//QPrintDialog printer_dialog(&printer, this);
//pv_text_doc->setHtml("hello");
//pv_text_doc->setHtml("<table width=\"100%\" border=\"1\" cellspacing=0>\nhello\n</table>\n");
//te_text->setDocument(pv_text_doc);
//if(printer_dialog.exec()){
//QPainter painter(&printer);
//pv_painter->begin(pv_printer);
pv_text_doc->setHtml(pv_html);
//pv_text_doc->print(pv_printer);
//pv_painter->end();
//}
return false; // nothing's working here...
}
int main()
{
g_char_type = "::UChar32";
g_data_type = "icu_regex_traits::char_class_type";
ADD(L*, U_GC_L_MASK);
ADD(Letter, U_GC_L_MASK);
ADD(Lu, U_GC_LU_MASK);
ADD(Ll, U_GC_LL_MASK);
ADD(Lt, U_GC_LT_MASK);
ADD(Lm, U_GC_LM_MASK);
ADD(Lo, U_GC_LO_MASK);
ADD(Uppercase Letter, U_GC_LU_MASK);
ADD(Lowercase Letter, U_GC_LL_MASK);
ADD(Titlecase Letter, U_GC_LT_MASK);
ADD(Modifier Letter, U_GC_LM_MASK);
ADD(Other Letter, U_GC_LO_MASK);
ADD(M*, U_GC_M_MASK);
ADD(Mn, U_GC_MN_MASK);
ADD(Mc, U_GC_MC_MASK);
ADD(Me, U_GC_ME_MASK);
ADD(Mark, U_GC_M_MASK);
ADD(Non-Spacing Mark, U_GC_MN_MASK);
ADD(Spacing Combining Mark, U_GC_MC_MASK);
ADD(Enclosing Mark, U_GC_ME_MASK);
ADD(N*, U_GC_N_MASK);
ADD(Nd, U_GC_ND_MASK);
ADD(Nl, U_GC_NL_MASK);
ADD(No, U_GC_NO_MASK);
ADD(Number, U_GC_N_MASK);
ADD(Decimal Digit Number, U_GC_ND_MASK);
ADD(Letter Number, U_GC_NL_MASK);
ADD(Other Number, U_GC_NO_MASK);
ADD(S*, U_GC_S_MASK);
ADD(Sm, U_GC_SM_MASK);
ADD(Sc, U_GC_SC_MASK);
ADD(Sk, U_GC_SK_MASK);
ADD(So, U_GC_SO_MASK);
ADD(Symbol, U_GC_S_MASK);
ADD(Math Symbol, U_GC_SM_MASK);
ADD(Currency Symbol, U_GC_SC_MASK);
ADD(Modifier Symbol, U_GC_SK_MASK);
ADD(Other Symbol, U_GC_SO_MASK);
ADD(P*, U_GC_P_MASK);
ADD(Pc, U_GC_PC_MASK);
ADD(Pd, U_GC_PD_MASK);
ADD(Ps, U_GC_PS_MASK);
ADD(Pe, U_GC_PE_MASK);
ADD(Pi, U_GC_PI_MASK);
ADD(Pf, U_GC_PF_MASK);
ADD(Po, U_GC_PO_MASK);
ADD(Punctuation, U_GC_P_MASK);
ADD(Connector Punctuation, U_GC_PC_MASK);
ADD(Dash Punctuation, U_GC_PD_MASK);
ADD(Open Punctuation, U_GC_PS_MASK);
ADD(Close Punctuation, U_GC_PE_MASK);
ADD(Initial Punctuation, U_GC_PI_MASK);
ADD(Final Punctuation, U_GC_PF_MASK);
ADD(Other Punctuation, U_GC_PO_MASK);
ADD(Z*, U_GC_Z_MASK);
ADD(Zs, U_GC_ZS_MASK);
ADD(Zl, U_GC_ZL_MASK);
ADD(Zp, U_GC_ZP_MASK);
ADD(Separator, U_GC_Z_MASK);
ADD(Space Separator, U_GC_ZS_MASK);
ADD(Line Separator, U_GC_ZL_MASK);
ADD(Paragraph Separator, U_GC_ZP_MASK);
ADD(C*, U_GC_C_MASK);
ADD(Cc, U_GC_CC_MASK);
ADD(Cf, U_GC_CF_MASK);
ADD(Cs, U_GC_CS_MASK);
ADD(Co, U_GC_CO_MASK);
ADD(Cn, U_GC_CN_MASK);
ADD(Other, U_GC_C_MASK);
ADD(Control, U_GC_CC_MASK);
ADD(Format, U_GC_CF_MASK);
ADD(Surrogate, U_GC_CS_MASK);
ADD(Private Use, U_GC_CO_MASK);
ADD(Not Assigned, U_GC_CN_MASK);
ADD(Any, icu_regex_traits::mask_any);
ADD(Assigned, (0x3FFFFFFFu) & ~(U_GC_CN_MASK));
ADD(ASCII, icu_regex_traits::mask_ascii);
ADD(Titlecase, U_GC_LT_MASK);
generate_code();
generate_html();
return 0;
}
int generate_html(const std::string& s,
const TemplateNode& nodes,
std::string& output, std::vector<std::string>& failed_tags)
{
int ret = 0;
if (nodes.type_ != TemplateNode::kMap
&& nodes.type_ != TemplateNode::kNone)
ret = -1;
for(size_t i = 0; i < s.size();) {
//tag found
if (i + 4 < s.size() && s[i] == '[' && s[i + 1] == '&') {
//find end of current tag, care about recursive tags.
auto find_right = [&](const char *left, const char *needle) {
size_t sleft = (left ? strlen(left) : 0), sneedle = strlen(needle);
size_t j = i;
int sstack = 1;
while(j < s.size()) {
// dont care about safety for simplicity
if (left && (strncmp(left, &s[j], sleft) == 0)) {
sstack++;
} else if (strncmp(needle, &s[j], sneedle) == 0) {
sstack--;
if (sstack == 0) {
break;
}
}
j++;
}
return j;
};
//special tag
i += 2;
if (s[i] == '&') {
// is vector
i++;
// find key ' [&&key& '
size_t j = find_right(nullptr, "&");
string key = s.substr(i, j - i);
i = j + 1;
j = find_right("[&", "&]");
// range error
if (i >= s.size()) {
failed_tags.push_back("Bad template");
ret = -1;
break;
}
// cut down the recursive part
string subtemplate = s.substr(i, j - i);
i = j + 2;
auto it = nodes.val_map_.find(key);
if (it == nodes.val_map_.end()) {
// key not found, can not replace
failed_tags.push_back(key);
ret = -1;
continue;
}
for(auto i : it->second->val_vector_) {
string suboutput;
int ret2 = generate_html(subtemplate, *i, suboutput, failed_tags);
if (ret2)
ret = ret2;
output.append(suboutput);
}
} else {
size_t j = find_right("[&", "&]");
string key = s.substr(i, j - i);
i = j + 2;
auto it = nodes.val_map_.find(key);
if (it == nodes.val_map_.end()) {
// key not found, can not replace
failed_tags.push_back(key);
ret = -1;
continue;
}
output.append(it->second->val_string_);
}
} else {
output.append(1, s[i]);
i++;
}
}
return ret;
}
int main(int argc, char *argv[])
{
int i = 1;
ascii_col_sep = " ";
show_type = 0;
show_unit = 0;
show_format = 0;
show_description = 0;
show_quotes = 0;
show_hidden = 0;
show_expressions = 0;
show_parent_types = 0;
show_attributes = 0;
use_special_types = 1;
if (argc > 1)
{
if (strcmp(argv[i], "-h") == 0 || strcmp(argv[i], "--help") == 0)
{
print_help();
exit(0);
}
if (strcmp(argv[i], "-v") == 0 || strcmp(argv[i], "--version") == 0)
{
print_version();
exit(0);
}
}
if (i + 1 < argc && strcmp(argv[i], "-D") == 0)
{
coda_set_definition_path(argv[i + 1]);
i += 2;
}
else
{
#ifdef WIN32
const char *definition_path = "../definitions";
#else
const char *definition_path = "../share/" PACKAGE "/definitions";
#endif
if (coda_set_definition_path_conditional(argv[0], NULL, definition_path) != 0)
{
fprintf(stderr, "ERROR: %s\n", coda_errno_to_string(coda_errno));
exit(1);
}
}
coda_option_read_all_definitions = 1;
if (coda_init() != 0)
{
fprintf(stderr, "ERROR: %s\n", coda_errno_to_string(coda_errno));
exit(1);
}
if (i == argc)
{
coda_done();
exit(0);
}
coda_set_option_perform_conversions(0);
if (strcmp(argv[i], "doc") == 0)
{
i++;
if (i != argc - 1)
{
fprintf(stderr, "ERROR: invalid arguments\n");
print_help();
exit(1);
}
generate_html(argv[i]);
}
else if (strcmp(argv[i], "list") == 0)
{
const char *product_class = NULL;
const char *product_type = NULL;
int version = -1;
i++;
while (i < argc)
{
if (strcmp(argv[i], "-e") == 0 || strcmp(argv[i], "--expr") == 0)
{
show_expressions = 1;
}
else if (strcmp(argv[i], "-q") == 0 || strcmp(argv[i], "--quote_strings") == 0)
{
show_quotes = 1;
}
else if (strcmp(argv[i], "-t") == 0 || strcmp(argv[i], "--type") == 0)
{
show_type = 1;
}
else if (strcmp(argv[i], "-u") == 0 || strcmp(argv[i], "--unit") == 0)
{
show_unit = 1;
}
else if (strcmp(argv[i], "--description") == 0)
{
show_description = 1;
}
else if (strcmp(argv[i], "--hidden") == 0)
{
show_hidden = 1;
}
else if (strcmp(argv[i], "--parent-types") == 0)
{
show_parent_types = 1;
}
else if (strcmp(argv[i], "--attributes") == 0)
{
show_attributes = 1;
}
else if (strcmp(argv[i], "--no_special_types") == 0)
{
use_special_types = 0;
}
else if ((strcmp(argv[i], "-s") == 0 || strcmp(argv[i], "--column_separator") == 0) &&
i + 1 < argc && argv[i + 1][0] != '-')
{
i++;
ascii_col_sep = argv[i];
}
else if (argv[i][0] != '-')
{
break;
}
else
{
fprintf(stderr, "ERROR: invalid arguments\n");
print_help();
exit(1);
}
i++;
}
if (i < argc)
{
product_class = argv[i];
i++;
if (i < argc)
{
product_type = argv[i];
i++;
if (i < argc)
{
if (sscanf(argv[i], "%d", &version) != 1)
{
fprintf(stderr, "ERROR: invalid product version argument\n");
print_help();
exit(1);
}
i++;
if (i < argc)
{
fprintf(stderr, "ERROR: invalid arguments\n");
print_help();
exit(1);
}
}
}
}
generate_list(product_class, product_type, version);
}
else if (strcmp(argv[i], "xmlschema") == 0)
{
const char *output_file_name = NULL;
const char *product_class = NULL;
const char *product_type = NULL;
int version = -1;
i++;
while (i < argc)
{
if ((strcmp(argv[i], "-o") == 0 || strcmp(argv[i], "--output") == 0) &&
i + 1 < argc && argv[i + 1][0] != '-')
{
i++;
output_file_name = argv[i];
}
else if (argv[i][0] != '-')
{
break;
}
else
{
fprintf(stderr, "ERROR: invalid arguments\n");
print_help();
exit(1);
}
i++;
}
if (i != argc - 3)
{
fprintf(stderr, "ERROR: invalid arguments\n");
print_help();
exit(1);
}
product_class = argv[i];
i++;
product_type = argv[i];
i++;
if (sscanf(argv[i], "%d", &version) != 1)
{
fprintf(stderr, "ERROR: invalid product version argument\n");
print_help();
exit(1);
}
generate_xmlschema(output_file_name, product_class, product_type, version);
}
else if (strcmp(argv[i], "dtree") == 0)
{
coda_format format;
i++;
if (i != argc - 1)
{
fprintf(stderr, "ERROR: invalid arguments\n");
print_help();
exit(1);
}
if (coda_format_from_string(argv[i], &format) != 0)
{
fprintf(stderr, "ERROR: invalid arguments\n");
print_help();
exit(1);
}
generate_detection_tree(format);
}
else if (strcmp(argv[i], "definition") == 0)
{
const char *output_file_name = NULL;
i++;
while (i < argc)
{
if ((strcmp(argv[i], "-o") == 0 || strcmp(argv[i], "--output") == 0) &&
i + 1 < argc && argv[i + 1][0] != '-')
{
i++;
output_file_name = argv[i];
}
else if (argv[i][0] != '-')
{
break;
}
else
{
fprintf(stderr, "ERROR: invalid arguments\n");
print_help();
exit(1);
}
i++;
}
if (i != argc - 1)
{
fprintf(stderr, "ERROR: invalid arguments\n");
print_help();
exit(1);
}
generate_definition(output_file_name, argv[i]);
}
else
{
fprintf(stderr, "ERROR: invalid arguments\n");
print_help();
exit(1);
}
coda_done();
return 0;
}
