static void enableNumberingForStyle(CSSStyle *style)
{
int level = style->headingLevel;
DFBuffer *reset = DFBufferNew();
for (int after = level+1; after <= 6; after++) {
if (reset->len == 0)
DFBufferFormat(reset,"h%d",after);
else
DFBufferFormat(reset," h%d",after);
}
DFBuffer *content = DFBufferNew();
for (int upto = 1; upto <= level; upto++) {
if (content->len == 0)
DFBufferFormat(content,"counter(h%d)",upto);
else
DFBufferFormat(content," \".\" counter(h%d)",upto);
}
DFBufferFormat(content," \" \"");
CSSProperties *rule = CSSStyleRule(style);
CSSPut(rule,"counter-increment",style->elementName);
if (reset->len > 0)
CSSPut(rule,"counter-reset",reset->data);
CSSPut(CSSStyleBefore(style),"content",content->data);
style->latent = 0;
DFBufferRelease(reset);
DFBufferRelease(content);
}
char *CSSSheetCopyText(CSSSheet *sheet)
{
DFBuffer *result = DFBufferNew();
const char **allSelectors = CSSSheetCopySelectors(sheet);
DFSortStringsCaseInsensitive(allSelectors);
for (int selIndex = 0; allSelectors[selIndex]; selIndex++) {
CSSStyle *style = CSSSheetLookupSelector(sheet,allSelectors[selIndex],0,0);
DFBufferFormat(result,"%s\n",style->selector);
const char **sortedSuffixes = CSSStyleCopySuffixes(style);
DFSortStringsCaseInsensitive(sortedSuffixes);
for (int suffixIndex = 0; sortedSuffixes[suffixIndex]; suffixIndex++) {
const char *suffix = sortedSuffixes[suffixIndex];
char *quotedSuffix = DFQuote(suffix);
DFBufferFormat(result," %s\n",quotedSuffix);
free(quotedSuffix);
CSSProperties *properties = CSSStyleRuleForSuffix(style,suffix);
const char **sortedNames = CSSPropertiesCopyNames(properties);
DFSortStringsCaseInsensitive(sortedNames);
for (int nameIndex = 0; sortedNames[nameIndex]; nameIndex++) {
const char *name = sortedNames[nameIndex];
const char *value = CSSGet(properties,name);
DFBufferFormat(result," %s = %s\n",name,value);
}
free(sortedNames);
}
free(sortedSuffixes);
}
free(allSelectors);
char *str = xstrdup(result->data);
DFBufferRelease(result);
return str;
}
static void addSerializedBinary(DFBuffer *result, DFBuffer *data, const char *filename)
{
if (data != NULL) {
char *str = binaryToString(data);
DFBufferFormat(result,"#item %s\n",filename);
DFBufferFormat(result,"%s",str);
free(str);
}
}
static void addSerializedDoc(DFBuffer *result, DFDocument *doc, const char *filename)
{
if (doc != NULL) {
char *str = DFSerializeXMLString(doc,0,1);
DFBufferFormat(result,"#item %s\n",filename);
DFBufferFormat(result,"%s",str);
free(str);
}
}
static int parsePackage(TextPackage *package, const char *string, const char *path, DFError **error)
{
DFBuffer *replaced = DFBufferNew();
if (!strcmp(path,""))
path = ".";
if (!processIncludes(package,string,replaced,path,error)) {
DFBufferRelease(replaced);
return 0;
}
char *currentKey = strdup("");
DFBuffer *currentValue = DFBufferNew();
const char **lines = DFStringSplit(replaced->data,"\n",0);
for (int lineno = 0; lines[lineno]; lineno++) {
const char *line = lines[lineno];
if (!DFStringHasPrefix(line,"#")) {
DFBufferFormat(currentValue,"%s\n",line);
}
else if (DFStringHasPrefix(line,"#item ")) {
package->keys = (char **)realloc(package->keys,(package->nkeys+2)*sizeof(char *));
package->keys[package->nkeys++] = strdup(currentKey);
package->keys[package->nkeys] = NULL;
DFHashTableAdd(package->items,currentKey,currentValue->data);
free(currentKey);
DFBufferRelease(currentValue);
currentKey = DFSubstring(line,6,strlen(line));
currentValue = DFBufferNew();
}
else if (DFStringHasPrefix(line,"##")) {
DFBufferFormat(currentValue,"%s\n",&line[1]);
}
else {
DFErrorFormat(error,"Unknown command: %s on line %d",line,(lineno+1));
return 0;
}
}
package->keys = (char **)realloc(package->keys,(package->nkeys+2)*sizeof(char *));
package->keys[package->nkeys++] = strdup(currentKey);
package->keys[package->nkeys] = NULL;
DFHashTableAdd(package->items,currentKey,currentValue->data);
free(lines);
free(currentKey);
DFBufferRelease(currentValue);
DFBufferRelease(replaced);
return 1;
}
static int processIncludes(TextPackage *package, const char *input, DFBuffer *output, const char *path, DFError **error)
{
int ok = 1;
const char **lines = DFStringSplit(input,"\n",0);
for (int lineno = 0; lines[lineno] && ok; lineno++) {
const char *line = lines[lineno];
if (DFStringHasPrefix(line,"#include \"") && DFStringHasSuffix(line,"\"")) {
char *inclRelPath = DFSubstring(line,10,strlen(line)-1);
char *inclAbsPath = DFAppendPathComponent(path,inclRelPath);
char *inclDirName = DFPathDirName(inclAbsPath);
char *inclContent = DFStringReadFromFile(inclAbsPath,error);
if (inclContent == NULL) {
DFErrorFormat(error,"%s: %s",inclRelPath,DFErrorMessage(error));
ok = 0;
}
else if (!processIncludes(package,inclContent,output,inclDirName,error)) {
ok = 0;
}
free(inclRelPath);
free(inclAbsPath);
free(inclDirName);
free(inclContent);
}
else {
DFBufferFormat(output,"%s\n",line);
}
}
free(lines);
return ok;
}
static void SAXFatalError(void *ctx, const char *msg, ...)
{
DFSAXParser *parser = (DFSAXParser *)ctx;
va_list ap;
va_start(ap,msg);
DFBufferFormat(parser->fatalErrors,msg,ap);
va_end(ap);
}
static void SAXWarning(void *ctx, const char *msg, ...)
{
DFSAXParser *parser = (DFSAXParser *)ctx;
va_list ap;
va_start(ap,msg);
DFBufferFormat(parser->warnings,msg,ap);
va_end(ap);
}
static void test_create(void)
{
DFError *error = NULL;
DFStorage *htmlStorage = DFStorageNewMemory(DFFileFormatHTML);
DFDocument *htmlDoc = TestCaseGetHTML(htmlStorage,&error);
DFStorageRelease(htmlStorage);
if (htmlDoc == NULL) {
DFBufferFormat(utgetoutput(),"%s\n",DFErrorMessage(&error));
DFErrorRelease(error);
return;
}
HTML_normalizeDocument(htmlDoc);
char *latex = HTMLToLaTeX(htmlDoc);
DFBufferFormat(utgetoutput(),"%s",latex);
free(latex);
DFDocumentRelease(htmlDoc);
}
static void test_parse(void)
{
const char *inputCSS = DFHashTableLookup(utgetdata(),"input.css");
if (inputCSS == NULL) {
DFBufferFormat(utgetoutput(),"input.css not defined");
return;
}
CSSSheet *styleSheet = CSSSheetNew();
CSSSheetUpdateFromCSSText(styleSheet,inputCSS);
char *text = CSSSheetCopyText(styleSheet);
DFBufferFormat(utgetoutput(),"%s",text);
free(text);
DFBufferFormat(utgetoutput(),
"================================================================================\n");
char *cssText = CSSSheetCopyCSSText(styleSheet);
DFBufferFormat(utgetoutput(),"%s",cssText);
free(cssText);
CSSSheetRelease(styleSheet);
}
static void test_setHeadingNumbering(void)
{
const char *inputCSS = DFHashTableLookup(utgetdata(),"input.css");
if (inputCSS == NULL) {
DFBufferFormat(utgetoutput(),"CSS_setHeadingNumbering: input.css not defined");
return;
}
if (utgetargc() < 1) {
DFBufferFormat(utgetoutput(),"CSS_setHeadingNumbering: expected 1 argument");
return;
}
CSSSheet *styleSheet = CSSSheetNew();
CSSSheetUpdateFromCSSText(styleSheet,inputCSS);
int on = !strcasecmp(utgetargv()[0],"true");
CSSSheetSetHeadingNumbering(styleSheet,on);
char *cssText = CSSSheetCopyCSSText(styleSheet);
DFBufferFormat(utgetoutput(),"%s",cssText);
free(cssText);
CSSSheetRelease(styleSheet);
}
static void simplifyRecursive(WordSimplification *simp, DFNode *node)
{
switch (node->tag) {
case WORD_FLDCHAR: {
const char *type = DFGetAttribute(node,WORD_FLDCHARTYPE);
if (DFStringEquals(type,"begin")) {
if (simp->depth == 0) {
DFBufferRelease(simp->instrText);
simp->instrText = DFBufferNew();
simp->beginNode = node;
simp->endNode = NULL;
simp->inSeparate = 0;
}
simp->depth++;
}
else if (DFStringEquals(type,"end") && (simp->depth > 0)) {
simp->depth--;
if (simp->depth == 0) {
simp->endNode = node;
replaceField(simp);
}
}
else if (DFStringEquals(type,"separate")) {
if (simp->depth == 1)
simp->inSeparate = 1;
}
break;
}
case WORD_INSTRTEXT: {
if ((simp->depth == 1) && !simp->inSeparate) {
char *value = DFNodeTextToString(node);
DFBufferFormat(simp->instrText,"%s",value);
free(value);
}
break;
}
}
DFNode *next;
for (DFNode *child = node->first; child != NULL; child = next) {
next = child->next;
simplifyRecursive(simp,child);
}
}
static void extractPrefixRecursive(DFNode *node, const char *counterName, DFBuffer *result,
int *foundSeq, int *foundContent)
{
if (isSeqField(node)) {
if (result->len > 0)
DFBufferFormat(result," ");
DFBufferFormat(result,"counter(%s)",counterName);
*foundSeq = 1;
DFRemoveNode(node);
return;
}
if (node->tag == DOM_TEXT) {
size_t valueLen = strlen(node->value);
size_t pos = 0;
if (*foundSeq) {
size_t offset = 0;
uint32_t ch;
do {
pos = offset;
ch = DFNextChar(node->value,&offset);
} while ((ch != 0) && (DFCharIsWhitespaceOrNewline(ch) || DFCharIsPunctuation(ch)));
}
else {
pos = valueLen;
}
if (pos == valueLen) {
if (result->len > 0)
DFBufferFormat(result," ");
char *quotedValue = DFQuote(node->value);
DFBufferFormat(result,"%s",quotedValue);
free(quotedValue);
DFRemoveNode(node);
if (*foundSeq)
*foundContent = 1;
return;
}
else if (pos > 0) {
char *first = DFSubstring(node->value,0,pos);
char *rest = DFSubstring(node->value,pos,valueLen);
if (result->len > 0)
DFBufferFormat(result," ");
char *quotedFirst = DFQuote(first);
DFBufferFormat(result,"%s",quotedFirst);
free(quotedFirst);
DFSetNodeValue(node,rest);
if (*foundSeq)
*foundContent = 1;
free(first);
free(rest);
return;
}
}
int wasEmpty = (node->first == NULL);
DFNode *next;
for (DFNode *child = node->first; child != NULL; child = next) {
next = child->next;
if (*foundContent)
break;
extractPrefixRecursive(child,counterName,result,foundSeq,foundContent);
}
int isEmpty = (node->first == NULL);
if ((node->tag == HTML_SPAN) && isEmpty && !wasEmpty)
DFRemoveNode(node);
}
