summaryrefslogtreecommitdiff
path: root/fluid/io/code.cxx
diff options
context:
space:
mode:
Diffstat (limited to 'fluid/io/code.cxx')
-rw-r--r--fluid/io/code.cxx1107
1 files changed, 1107 insertions, 0 deletions
diff --git a/fluid/io/code.cxx b/fluid/io/code.cxx
new file mode 100644
index 000000000..b77cad147
--- /dev/null
+++ b/fluid/io/code.cxx
@@ -0,0 +1,1107 @@
+//
+// Code output routines for the Fast Light Tool Kit (FLTK).
+//
+// Copyright 1998-2025 by Bill Spitzak and others.
+//
+// This library is free software. Distribution and use rights are outlined in
+// the file "COPYING" which should have been included with this file. If this
+// file is missing or damaged, see the license at:
+//
+// https://www.fltk.org/COPYING.php
+//
+// Please see the following page on how to report bugs and issues:
+//
+// https://www.fltk.org/bugs.php
+//
+
+#include "io/code.h"
+
+#include "app/fluid.h"
+#include "app/undo.h"
+#include "io/file.h"
+#include "nodes/Fl_Group_Type.h"
+#include "nodes/Fl_Window_Type.h"
+#include "nodes/Fl_Function_Type.h"
+#include "tools/fluid_filename.h"
+
+#include <FL/Fl.H>
+#include <FL/fl_string_functions.h>
+#include <FL/fl_ask.H>
+#include "../src/flstring.h"
+
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#include <zlib.h>
+
+/// \defgroup cfile C Code File Operations
+/// \{
+
+
+/**
+ Return true if c can be in a C identifier.
+ I needed this so it is not messed up by locale settings.
+ \param[in] c a character, or the start of a utf-8 sequence
+ \return 1 if c is alphanumeric or '_'
+ */
+int is_id(char c) {
+ return (c>='a' && c<='z') || (c>='A' && c<='Z') || (c>='0' && c<='9') || c=='_';
+}
+
+/**
+ Write a string to a file, replacing all non-ASCII characters with octal codes.
+ \param[in] out output file
+ \param[in] text write this NUL terminated utf-8 string
+ \return EOF if any of the file access calls failed, 0 if OK
+ */
+int write_escaped_strings(FILE *out, const char *text) {
+ int ret = 0;
+ const unsigned char *utf8_text = (const unsigned char *)text;
+ for (const unsigned char *s = utf8_text; *s; ++s) {
+ unsigned char c = *s;
+ // escape control characters, delete, all utf-8, and the double quotes
+ // note: we should have an option in the project settings to allow utf-8
+ // characters in the output text and not escape them
+ if (c < 32 || c > 126 || c == '\"') {
+ if (c == '\r') {
+ ret = fputs("\\r", out);
+ } else if (c == '\n') {
+ ret = fputs("\\n", out);
+ } else {
+ ret = fprintf(out, "\\%03o", c);
+ }
+ } else {
+ ret = putc((int)c, out);
+ }
+ }
+ return ret;
+}
+
+/**
+ Write a file that contains all label and tooltip strings for internationalization.
+ The user is responsible to set the right file name extension. The file format
+ is determined by `g_project.i18n_type`.
+ \param[in] filename file path and name to a file that will hold the strings
+ \return 1 if the file could not be opened for writing, or the result of `fclose`.
+ */
+int write_strings(const std::string &filename) {
+ Fl_Type *p;
+ Fl_Widget_Type *w;
+ int i;
+
+ FILE *fp = fl_fopen(filename.c_str(), "wb");
+ if (!fp) return 1;
+
+ switch (g_project.i18n_type) {
+ case FD_I18N_NONE : /* None, just put static text out */
+ fprintf(fp, "# generated by Fast Light User Interface Designer (fluid) version %.4f\n",
+ FL_VERSION);
+ for (p = Fl_Type::first; p; p = p->next) {
+ if (p->is_widget()) {
+ w = (Fl_Widget_Type *)p;
+
+ if (w->label()) {
+ write_escaped_strings(fp, w->label());
+ putc('\n', fp);
+ }
+
+ if (w->tooltip()) {
+ write_escaped_strings(fp, w->tooltip());
+ putc('\n', fp);
+ }
+ }
+ }
+ break;
+ case FD_I18N_GNU : /* GNU gettext, put a .po file out */
+ fprintf(fp, "# generated by Fast Light User Interface Designer (fluid) version %.4f\n",
+ FL_VERSION);
+ for (p = Fl_Type::first; p; p = p->next) {
+ if (p->is_widget()) {
+ w = (Fl_Widget_Type *)p;
+
+ if (w->label()) {
+ fputs("msgid \"", fp);
+ write_escaped_strings(fp, w->label());
+ fputs("\"\n", fp);
+
+ fputs("msgstr \"", fp);
+ write_escaped_strings(fp, w->label());
+ fputs("\"\n", fp);
+ }
+
+ if (w->tooltip()) {
+ fputs("msgid \"", fp);
+ write_escaped_strings(fp, w->tooltip());
+ fputs("\"\n", fp);
+
+ fputs("msgstr \"", fp);
+ write_escaped_strings(fp, w->tooltip());
+ fputs("\"\n", fp);
+ }
+ }
+ }
+ break;
+ case FD_I18N_POSIX : /* POSIX catgets, put a .msg file out */
+ fprintf(fp, "$ generated by Fast Light User Interface Designer (fluid) version %.4f\n",
+ FL_VERSION);
+ fprintf(fp, "$set %s\n", g_project.i18n_pos_set.c_str());
+ fputs("$quote \"\n", fp);
+
+ for (i = 1, p = Fl_Type::first; p; p = p->next) {
+ if (p->is_widget()) {
+ w = (Fl_Widget_Type *)p;
+
+ if (w->label()) {
+ fprintf(fp, "%d \"", i ++);
+ write_escaped_strings(fp, w->label());
+ fputs("\"\n", fp);
+ }
+
+ if (w->tooltip()) {
+ fprintf(fp, "%d \"", i ++);
+ write_escaped_strings(fp, w->tooltip());
+ fputs("\"\n", fp);
+ }
+ }
+ }
+ break;
+ }
+
+ return fclose(fp);
+}
+
+////////////////////////////////////////////////////////////////
+// Generate unique but human-readable identifiers:
+
+/** A binary searchable tree storing identifiers for quick retrieval. */
+struct Fd_Identifier_Tree {
+ char* text;
+ void* object;
+ Fd_Identifier_Tree *left, *right;
+ Fd_Identifier_Tree (const char* t, void* o) : text(fl_strdup(t)), object(o) {left = right = 0;}
+ ~Fd_Identifier_Tree();
+};
+
+Fd_Identifier_Tree::~Fd_Identifier_Tree() {
+ delete left;
+ free((void *)text);
+ delete right;
+}
+
+/** \brief Return a unique name for the given object.
+
+ This function combines the name and label into an identifier. It then checks
+ if that id was already taken by another object, and if so, appends a
+ hexadecimal value which is incremented until the id is unique in this file.
+
+ If a new id was created, it is stored in the id tree.
+
+ \param[in] o create an ID for this object
+ \param[in] type is the first word of the ID
+ \param[in] name if name is set, it is appended to the ID
+ \param[in] label else if label is set, it is appended, skipping non-keyword characters
+ \return buffer to a unique identifier, managed by Fd_Code_Writer, so caller must NOT free() it
+ */
+const char* Fd_Code_Writer::unique_id(void* o, const char* type, const char* name, const char* label) {
+ char buffer[128];
+ char* q = buffer;
+ char* q_end = q + 128 - 8 - 1; // room for hex number and NUL
+ while (*type) *q++ = *type++;
+ *q++ = '_';
+ const char* n = name;
+ if (!n || !*n) n = label;
+ if (n && *n) {
+ while (*n && !is_id(*n)) n++;
+ while (is_id(*n) && (q < q_end)) *q++ = *n++;
+ }
+ *q = 0;
+ // okay, search the tree and see if the name was already used:
+ Fd_Identifier_Tree** p = &id_root;
+ int which = 0;
+ while (*p) {
+ int i = strcmp(buffer, (*p)->text);
+ if (!i) {
+ if ((*p)->object == o) return (*p)->text;
+ // already used, we need to pick a new name:
+ sprintf(q,"%x",++which);
+ p = &id_root;
+ continue;
+ }
+ else if (i < 0) p = &((*p)->left);
+ else p = &((*p)->right);
+ }
+ *p = new Fd_Identifier_Tree(buffer, o);
+ return (*p)->text;
+}
+
+////////////////////////////////////////////////////////////////
+// return current indentation:
+
+
+/**
+ Return a C string that indents code to the given depth.
+
+ Indentation can be changed by modifying the multiplicator (``*2`` to keep
+ the FLTK indent style). Changing `spaces` to a list of tabs would generate
+ tab indents instead. This function can also be used for fixed depth indents
+ in the header file.
+
+ Do *not* ever make this a user preference, or you will end up writing a
+ fully featured code formatter.
+
+ \param[in] set generate this indent depth
+ \return pointer to a static string
+ */
+const char *Fd_Code_Writer::indent(int set) {
+ static const char* spaces = " ";
+ int i = set * 2;
+ if (i>32) i = 32;
+ if (i<0) i = 0;
+ return spaces+32-i;
+}
+
+/**
+ Return a C string that indents code to the current source file depth.
+ \return pointer to a static string
+ */
+const char *Fd_Code_Writer::indent() {
+ return indent(indentation);
+}
+
+/**
+ Return a C string that indents code to the current source file depth plus an offset.
+ \param[in] offset adds a temporary offset for this call only; this does not
+ change the `indentation` variable; offset can be negative
+ \return pointer to a static string
+ */
+const char *Fd_Code_Writer::indent_plus(int offset) {
+ return indent(indentation+offset);
+}
+
+
+////////////////////////////////////////////////////////////////
+// declarations/include files:
+// Each string generated by write_h_once is written only once to
+// the header file. This is done by keeping a binary tree of all
+// the calls so far and not printing it if it is in the tree.
+
+/** A binary searchable tree storing text for quick retrieval. */
+struct Fd_Text_Tree {
+ char *text;
+ Fd_Text_Tree *left, *right;
+ Fd_Text_Tree(const char *t) {
+ text = fl_strdup(t);
+ left = right = 0;
+ }
+ ~Fd_Text_Tree();
+};
+
+Fd_Text_Tree::~Fd_Text_Tree() {
+ delete left;
+ free((void *)text);
+ delete right;
+}
+
+/** A binary searchable tree storing pointers for quick retrieval. */
+struct Fd_Pointer_Tree {
+ void *ptr;
+ Fd_Pointer_Tree *left, *right;
+ Fd_Pointer_Tree(void *p) {
+ ptr = p;
+ left = right = 0;
+ }
+ ~Fd_Pointer_Tree();
+};
+
+Fd_Pointer_Tree::~Fd_Pointer_Tree() {
+ delete left;
+ delete right;
+}
+
+/**
+ Print a formatted line to the header file, unless the same line was produced before in this header file.
+ \note Resulting line is cropped at 1023 bytes.
+ \param[in] format printf-style formatting text, followed by a vararg list
+ \return 1 if the text was written to the file, 0 if it was previously written.
+ */
+int Fd_Code_Writer::write_h_once(const char *format, ...) {
+ va_list args;
+ char buf[1024];
+ va_start(args, format);
+ vsnprintf(buf, sizeof(buf), format, args);
+ va_end(args);
+ Fd_Text_Tree **p = &text_in_header;
+ while (*p) {
+ int i = strcmp(buf,(*p)->text);
+ if (!i) return 0;
+ else if (i < 0) p = &((*p)->left);
+ else p = &((*p)->right);
+ }
+ fprintf(header_file,"%s\n",buf);
+ *p = new Fd_Text_Tree(buf);
+ return 1;
+}
+
+/**
+ Print a formatted line to the source file, unless the same line was produced before in this code file.
+ \note Resulting line is cropped at 1023 bytes.
+ \param[in] format printf-style formatting text, followed by a vararg list
+ \return 1 if the text was written to the file, 0 if it was previously written.
+ */
+int Fd_Code_Writer::write_c_once(const char *format, ...) {
+ va_list args;
+ char buf[1024];
+ va_start(args, format);
+ vsnprintf(buf, sizeof(buf), format, args);
+ va_end(args);
+ Fd_Text_Tree **p = &text_in_header;
+ while (*p) {
+ int i = strcmp(buf,(*p)->text);
+ if (!i) return 0;
+ else if (i < 0) p = &((*p)->left);
+ else p = &((*p)->right);
+ }
+ p = &text_in_code;
+ while (*p) {
+ int i = strcmp(buf,(*p)->text);
+ if (!i) return 0;
+ else if (i < 0) p = &((*p)->left);
+ else p = &((*p)->right);
+ }
+ crc_printf("%s\n", buf);
+ *p = new Fd_Text_Tree(buf);
+ return 1;
+}
+
+/**
+ Return true if this pointer was already included in the code file.
+ If it was not, add it to the list and return false.
+ \param[in] pp ay pointer
+ \return true if found in the tree, false if added to the tree
+ */
+bool Fd_Code_Writer::c_contains(void *pp) {
+ Fd_Pointer_Tree **p = &ptr_in_code;
+ while (*p) {
+ if ((*p)->ptr == pp) return true;
+ else if ((*p)->ptr < pp) p = &((*p)->left);
+ else p = &((*p)->right);
+ }
+ *p = new Fd_Pointer_Tree(pp);
+ return false;
+}
+
+/**
+ Write a C string to the code file, escaping non-ASCII characters.
+
+ Text is broken into lines of 78 character.
+ FLUID " before and after every line text.
+
+ A list of control characters and ", ', and \\ are escaped by adding a \\ in
+ front of them. Escape ?? by writing ?\\?. All other characters that are not
+ between 32 and 126 inclusive will be escaped as octal characters.
+
+ This function is utf8 agnostic.
+
+ \param[in] s write this string
+ \param[in] length write so many bytes in this string
+
+ \see f.write_cstring(const char*)
+ */
+void Fd_Code_Writer::write_cstring(const char *s, int length) {
+ const char *next_line = "\"\n\"";
+ if (varused_test) {
+ varused = 1;
+ return;
+ }
+ // if we are rendering to the source code preview window, and the text is
+ // longer than four lines, we only render a placeholder.
+ if (write_codeview && ((s==NULL) || (length>300))) {
+ if (length>=0)
+ crc_printf("\" ... %d bytes of text... \"", length);
+ else
+ crc_puts("\" ... text... \"");
+ return;
+ }
+ if (length==-1 || s==0L) {
+ crc_puts("\n#error string not found\n");
+ crc_puts("\" ... undefined size text... \"");
+ return;
+ }
+
+ const char *p = s;
+ const char *e = s+length;
+ int linelength = 1;
+ crc_putc('\"');
+ for (; p < e;) {
+ int c = *p++;
+ switch (c) {
+ case '\b': c = 'b'; goto QUOTED;
+ case '\t': c = 't'; goto QUOTED;
+ case '\n': c = 'n'; goto QUOTED;
+ case '\f': c = 'f'; goto QUOTED;
+ case '\r': c = 'r'; goto QUOTED;
+ case '\"':
+ case '\'':
+ case '\\':
+ QUOTED:
+ if (linelength >= 77) { crc_puts(next_line); linelength = 0; }
+ crc_putc('\\');
+ crc_putc(c);
+ linelength += 2;
+ break;
+ case '?': // prevent trigraphs by writing ?? as ?\?
+ if (p-2 >= s && *(p-2) == '?') goto QUOTED;
+ // else fall through:
+ default:
+ if (c >= ' ' && c < 127) {
+ // a legal ASCII character
+ if (linelength >= 78) { crc_puts(next_line); linelength = 0; }
+ crc_putc(c);
+ linelength++;
+ break;
+ }
+ // if the UTF-8 option is checked, write unicode characters verbatim
+ if (g_project.utf8_in_src && (c&0x80)) {
+ if ((c&0x40)) {
+ // This is the first character in a utf-8 sequence (0b11......).
+ // A line break would be ok here. Do not put linebreak in front of
+ // following characters (0b10......)
+ if (linelength >= 78) { crc_puts(next_line); linelength = 0; }
+ }
+ crc_putc(c);
+ linelength++;
+ break;
+ }
+ // otherwise we must print it as an octal constant:
+ c &= 255;
+ if (linelength >= 74) { crc_puts(next_line); linelength = 0; }
+ crc_printf("\\%03o", c);
+ linelength += 4;
+ break;
+ }
+ }
+ crc_putc('\"');
+}
+
+/**
+ Write a C string, escaping non-ASCII characters.
+ \param[in] s write this string
+ \see f.write_cstring(const char*, int)
+ */
+void Fd_Code_Writer::write_cstring(const char *s) {
+ write_cstring(s, (int)strlen(s));
+}
+
+/**
+ Write an array of C binary data (does not add a null).
+ The output is bracketed in { and }. The content is written
+ as decimal bytes, i.e. `{ 1, 2, 200 }`
+
+ \param[in] s a block of binary data, interpreted as unsigned bytes
+ \param[in] length size of the block in bytes
+ */
+void Fd_Code_Writer::write_cdata(const char *s, int length) {
+ if (varused_test) {
+ varused = 1;
+ return;
+ }
+ if (write_codeview) {
+ if (length>=0)
+ crc_printf("{ /* ... %d bytes of binary data... */ }", length);
+ else
+ crc_puts("{ /* ... binary data... */ }");
+ return;
+ }
+ if (length==-1) {
+ crc_puts("\n#error data not found\n");
+ crc_puts("{ /* ... undefined size binary data... */ }");
+ return;
+ }
+ const unsigned char *w = (const unsigned char *)s;
+ const unsigned char *e = w+length;
+ int linelength = 1;
+ crc_putc('{');
+ for (; w < e;) {
+ unsigned char c = *w++;
+ if (c>99) linelength += 4;
+ else if (c>9) linelength += 3;
+ else linelength += 2;
+ if (linelength >= 77) {crc_puts("\n"); linelength = 0;}
+ crc_printf("%d", c);
+ if (w<e) crc_putc(',');
+ }
+ crc_putc('}');
+}
+
+/**
+ Print a formatted line to the source file.
+ \param[in] format printf-style formatting text
+ \param[in] args list of arguments
+ */
+void Fd_Code_Writer::vwrite_c(const char* format, va_list args) {
+ if (varused_test) {
+ varused = 1;
+ return;
+ }
+ crc_vprintf(format, args);
+}
+
+/**
+ Print a formatted line to the source file.
+ \param[in] format printf-style formatting text, followed by a vararg list
+ */
+void Fd_Code_Writer::write_c(const char* format,...) {
+ va_list args;
+ va_start(args, format);
+ vwrite_c(format, args);
+ va_end(args);
+}
+
+/**
+ Write code (c) of size (n) to C file, with optional comment (com) w/o trailing space.
+ if the code line does not end in a ';' or '}', a ';' will be added.
+ \param[in] indent indentation string for all lines
+ \param[in] n number of bytes in code line
+ \param[in] c line of code
+ \param[in] com optional commentary
+ */
+void Fd_Code_Writer::write_cc(const char *indent, int n, const char *c, const char *com) {
+ write_c("%s%.*s", indent, n, c);
+ char cc = c[n-1];
+ if (cc!='}' && cc!=';')
+ write_c(";");
+ if (*com)
+ write_c(" %s", com);
+ write_c("\n");
+}
+
+/**
+ Print a formatted line to the header file.
+ \param[in] format printf-style formatting text, followed by a vararg list
+ */
+void Fd_Code_Writer::write_h(const char* format,...) {
+ if (varused_test) return;
+ va_list args;
+ va_start(args, format);
+ vfprintf(header_file, format, args);
+ va_end(args);
+}
+
+/**
+ Write code (c) of size (n) to H file, with optional comment (com) w/o trailing space.
+ if the code line does not end in a ';' or '}', a ';' will be added.
+ \param[in] indent indentation string for all lines
+ \param[in] n number of bytes in code line
+ \param[in] c line of code
+ \param[in] com optional commentary
+ */
+void Fd_Code_Writer::write_hc(const char *indent, int n, const char* c, const char *com) {
+ write_h("%s%.*s", indent, n, c);
+ char cc = c[n-1];
+ if (cc!='}' && cc!=';')
+ write_h(";");
+ if (*com)
+ write_h(" %s", com);
+ write_h("\n");
+}
+
+/**
+ Write one or more lines of code, indenting each one of them.
+ \param[in] textlines one or more lines of text, separated by \\n
+ \param[in] inIndent increment indentation by this amount
+ \param[in] inTrailWith append this character if the last line did not end with
+ a newline, usually 0 or newline.
+ */
+void Fd_Code_Writer::write_c_indented(const char *textlines, int inIndent, char inTrailWith) {
+ if (textlines) {
+ indentation += inIndent;
+ for (;;) {
+ int line_len;
+ const char *newline = strchr(textlines, '\n');
+ if (newline)
+ line_len = (int)(newline-textlines);
+ else
+ line_len = (int)strlen(textlines);
+ if (textlines[0]=='\n') {
+ // avoid trailing spaces
+ } else if (textlines[0]=='#') {
+ // don't indent preprocessor statments starting with '#'
+ write_c("%.*s", line_len, textlines);
+ } else {
+ // indent all other text lines
+ write_c("%s%.*s", indent(), line_len, textlines);
+ }
+ if (newline) {
+ write_c("\n");
+ } else {
+ if (inTrailWith)
+ write_c("%c", inTrailWith);
+ break;
+ }
+ textlines = newline+1;
+ }
+ indentation -= inIndent;
+ }
+}
+
+/**
+ Return true if the type would be the member of a class.
+ Some types are treated differently if they are inside class. Especially within
+ a Widget Class, children that are widgets are written as part of the
+ constructor whereas functions, declarations, and inline data are seen as
+ members of the class itself.
+ */
+bool is_class_member(Fl_Type *t) {
+ return t->is_a(ID_Function)
+ || t->is_a(ID_Decl)
+ || t->is_a(ID_Data);
+// || t->is_a(ID_Class) // FLUID can't handle a class inside a class
+// || t->is_a(ID_Widget_Class)
+// || t->is_a(ID_DeclBlock) // Declaration blocks are generally not handled well
+}
+
+/**
+ Return true, if this is a comment, and if it is followed by a class member.
+ This must only be called if q is inside a widget class.
+ Widget classes can have widgets and members (functions/methods, declarations,
+ etc.) intermixed.
+ \param[in] q should be a comment type
+ \return true if this comment is followed by a class member
+ \return false if it is followed by a widget or code
+ \see is_class_member(Fl_Type *t)
+ */
+bool is_comment_before_class_member(Fl_Type *q) {
+ if (q->is_a(ID_Comment) && q->next && q->next->level==q->level) {
+ if (q->next->is_a(ID_Comment))
+ return is_comment_before_class_member(q->next);
+ if (is_class_member(q->next))
+ return true;
+ }
+ return false;
+}
+
+/**
+ Recursively write static code and declarations
+ \param[in] p write this type and all its children
+ \return pointer to the next sibling
+ */
+Fl_Type* Fd_Code_Writer::write_static(Fl_Type* p) {
+ if (write_codeview) p->header_static_start = (int)ftell(header_file);
+ if (write_codeview) p->code_static_start = (int)ftell(code_file);
+ p->write_static(*this);
+ if (write_codeview) p->code_static_end = (int)ftell(code_file);
+ if (write_codeview) p->header_static_end = (int)ftell(header_file);
+
+ Fl_Type* q;
+ for (q = p->next; q && q->level > p->level;) {
+ q = write_static(q);
+ }
+
+ p->write_static_after(*this);
+
+ return q;
+}
+
+/**
+ Recursively write code, putting children between the two parts of the parent code.
+ \param[in] p write this type and all its children
+ \return pointer to the next sibling
+ */
+Fl_Type* Fd_Code_Writer::write_code(Fl_Type* p) {
+ // write all code that comes before the children code
+ // (but don't write the last comment until the very end)
+ if (!(p==Fl_Type::last && p->is_a(ID_Comment))) {
+ if (write_codeview) p->code1_start = (int)ftell(code_file);
+ if (write_codeview) p->header1_start = (int)ftell(header_file);
+ p->write_code1(*this);
+ if (write_codeview) p->code1_end = (int)ftell(code_file);
+ if (write_codeview) p->header1_end = (int)ftell(header_file);
+ }
+ // recursively write the code of all children
+ Fl_Type* q;
+ if (p->is_widget() && p->is_class()) {
+ // Handle widget classes specially
+ for (q = p->next; q && q->level > p->level;) {
+ // note: maybe declaration blocks should be handled like comments in the context
+ if (!is_class_member(q) && !is_comment_before_class_member(q)) {
+ q = write_code(q);
+ } else {
+ int level = q->level;
+ do {
+ q = q->next;
+ } while (q && q->level > level);
+ }
+ }
+
+ // write all code that come after the children
+ if (write_codeview) p->code2_start = (int)ftell(code_file);
+ if (write_codeview) p->header2_start = (int)ftell(header_file);
+ p->write_code2(*this);
+ if (write_codeview) p->code2_end = (int)ftell(code_file);
+ if (write_codeview) p->header2_end = (int)ftell(header_file);
+
+ for (q = p->next; q && q->level > p->level;) {
+ if (is_class_member(q) || is_comment_before_class_member(q)) {
+ q = write_code(q);
+ } else {
+ int level = q->level;
+ do {
+ q = q->next;
+ } while (q && q->level > level);
+ }
+ }
+
+ write_h("};\n");
+ current_widget_class = 0L;
+ } else {
+ for (q = p->next; q && q->level > p->level;) q = write_code(q);
+ // write all code that come after the children
+ if (write_codeview) p->code2_start = (int)ftell(code_file);
+ if (write_codeview) p->header2_start = (int)ftell(header_file);
+ p->write_code2(*this);
+ if (write_codeview) p->code2_end = (int)ftell(code_file);
+ if (write_codeview) p->header2_end = (int)ftell(header_file);
+ }
+ return q;
+}
+
+/**
+ Write the source and header files for the current design.
+
+ If the files already exist, they will be overwritten.
+
+ \note There is no true error checking here.
+
+ \param[in] s filename of source code file
+ \param[in] t filename of the header file
+ \return 0 if the operation failed, 1 if it was successful
+ */
+int Fd_Code_Writer::write_code(const char *s, const char *t, bool to_codeview) {
+ write_codeview = to_codeview;
+ delete id_root; id_root = 0;
+ indentation = 0;
+ current_class = 0L;
+ current_widget_class = 0L;
+ if (!s) code_file = stdout;
+ else {
+ FILE *f = fl_fopen(s, "wb");
+ if (!f) return 0;
+ code_file = f;
+ }
+ if (!t) header_file = stdout;
+ else {
+ FILE *f = fl_fopen(t, "wb");
+ if (!f) {fclose(code_file); return 0;}
+ header_file = f;
+ }
+ // Remember the last code file location for MergeBack
+ if (s && g_project.write_mergeback_data && !to_codeview) {
+ std::string proj_filename = g_project.projectfile_path() + g_project.projectfile_name();
+ int i, n = (int)proj_filename.size();
+ for (i=0; i<n; i++) if (proj_filename[i]=='\\') proj_filename[i] = '/';
+ Fl_Preferences build_records(Fl_Preferences::USER_L, "fltk.org", "fluid-build");
+ Fl_Preferences path(build_records, proj_filename.c_str());
+ path.set("code", s);
+ }
+ // if the first entry in the Type tree is a comment, then it is probably
+ // a copyright notice. We print that before anything else in the file!
+ Fl_Type* first_type = Fl_Type::first;
+ if (first_type && first_type->is_a(ID_Comment)) {
+ if (write_codeview) {
+ first_type->code1_start = first_type->code2_start = (int)ftell(code_file);
+ first_type->header1_start = first_type->header2_start = (int)ftell(header_file);
+ }
+ // it is ok to write non-recursive code here, because comments have no children or code2 blocks
+ first_type->write_code1(*this);
+ if (write_codeview) {
+ first_type->code1_end = first_type->code2_end = (int)ftell(code_file);
+ first_type->header1_end = first_type->header2_end = (int)ftell(header_file);
+ }
+ first_type = first_type->next;
+ }
+
+ const char *hdr = "\
+// generated by Fast Light User Interface Designer (fluid) version %.4f\n\n";
+ fprintf(header_file, hdr, FL_VERSION);
+ crc_printf(hdr, FL_VERSION);
+
+ {char define_name[102];
+ const char* a = fl_filename_name(t);
+ char* b = define_name;
+ if (!isalpha(*a)) {*b++ = '_';}
+ while (*a) {*b++ = isalnum(*a) ? *a : '_'; a++;}
+ *b = 0;
+ fprintf(header_file, "#ifndef %s\n", define_name);
+ fprintf(header_file, "#define %s\n", define_name);
+ }
+
+ if (g_project.avoid_early_includes==0) {
+ write_h_once("#include <FL/Fl.H>");
+ }
+ if (t && g_project.include_H_from_C) {
+ if (to_codeview) {
+ write_c("#include \"CodeView.h\"\n");
+ } else if (g_project.header_file_name[0] == '.' && strchr(g_project.header_file_name.c_str(), '/') == NULL) {
+ write_c("#include \"%s\"\n", fl_filename_name(t));
+ } else {
+ write_c("#include \"%s\"\n", g_project.header_file_name.c_str());
+ }
+ }
+ std::string loc_include, loc_conditional;
+ if (g_project.i18n_type==FD_I18N_GNU) {
+ loc_include = g_project.i18n_gnu_include;
+ loc_conditional = g_project.i18n_gnu_conditional;
+ } else {
+ loc_include = g_project.i18n_pos_include;
+ loc_conditional = g_project.i18n_pos_conditional;
+ }
+ if (g_project.i18n_type && !loc_include.empty()) {
+ int conditional = !loc_conditional.empty();
+ if (conditional) {
+ write_c("#ifdef %s\n", loc_conditional.c_str());
+ indentation++;
+ }
+ if (loc_include[0] != '<' && loc_include[0] != '\"')
+ write_c("#%sinclude \"%s\"\n", indent(), loc_include.c_str());
+ else
+ write_c("#%sinclude %s\n", indent(), loc_include.c_str());
+ if (g_project.i18n_type == FD_I18N_POSIX) {
+ if (!g_project.i18n_pos_file.empty()) {
+ write_c("extern nl_catd %s;\n", g_project.i18n_pos_file.c_str());
+ } else {
+ write_c("// Initialize I18N stuff now for menus...\n");
+ write_c("#%sinclude <locale.h>\n", indent());
+ write_c("static char *_locale = setlocale(LC_MESSAGES, \"\");\n");
+ write_c("static nl_catd _catalog = catopen(\"%s\", 0);\n", g_project.basename().c_str());
+ }
+ }
+ if (conditional) {
+ write_c("#else\n");
+ if (g_project.i18n_type == FD_I18N_GNU) {
+ if (!g_project.i18n_gnu_function.empty()) {
+ write_c("#%sifndef %s\n", indent(), g_project.i18n_gnu_function.c_str());
+ write_c("#%sdefine %s(text) text\n", indent_plus(1), g_project.i18n_gnu_function.c_str());
+ write_c("#%sendif\n", indent());
+ }
+ }
+ if (g_project.i18n_type == FD_I18N_POSIX) {
+ write_c("#%sifndef catgets\n", indent());
+ write_c("#%sdefine catgets(catalog, set, msgid, text) text\n", indent_plus(1));
+ write_c("#%sendif\n", indent());
+ }
+ indentation--;
+ write_c("#endif\n");
+ }
+ if (g_project.i18n_type == FD_I18N_GNU && g_project.i18n_gnu_static_function[0]) {
+ write_c("#ifndef %s\n", g_project.i18n_gnu_static_function.c_str());
+ write_c("#%sdefine %s(text) text\n", indent_plus(1), g_project.i18n_gnu_static_function.c_str());
+ write_c("#endif\n");
+ }
+ }
+ for (Fl_Type* p = first_type; p;) {
+ // write all static data for this & all children first
+ write_static(p);
+ // then write the nested code:
+ p = write_code(p);
+ }
+
+ if (!s) return 1;
+
+ fprintf(header_file, "#endif\n");
+
+ Fl_Type* last_type = Fl_Type::last;
+ if (last_type && (last_type != Fl_Type::first) && last_type->is_a(ID_Comment)) {
+ if (write_codeview) {
+ last_type->code1_start = last_type->code2_start = (int)ftell(code_file);
+ last_type->header1_start = last_type->header2_start = (int)ftell(header_file);
+ }
+ last_type->write_code1(*this);
+ if (write_codeview) {
+ last_type->code1_end = last_type->code2_end = (int)ftell(code_file);
+ last_type->header1_end = last_type->header2_end = (int)ftell(header_file);
+ }
+ }
+ int x = 0, y = 0;
+
+ if (code_file != stdout)
+ x = fclose(code_file);
+ code_file = 0;
+ if (header_file != stdout)
+ y = fclose(header_file);
+ header_file = 0;
+ return x >= 0 && y >= 0;
+}
+
+
+/**
+ Write the public/private/protected keywords inside the class.
+ This avoids repeating these words if the mode is already set.
+ \param[in] state 0 for private, 1 for public, 2 for protected
+ */
+void Fd_Code_Writer::write_public(int state) {
+ if (!current_class && !current_widget_class) return;
+ if (current_class && current_class->write_public_state == state) return;
+ if (current_widget_class && current_widget_class->write_public_state == state) return;
+ if (current_class) current_class->write_public_state = state;
+ if (current_widget_class) current_widget_class->write_public_state = state;
+ switch (state) {
+ case 0: write_h("private:\n"); break;
+ case 1: write_h("public:\n"); break;
+ case 2: write_h("protected:\n"); break;
+ }
+}
+
+/**
+ Create and initialize a new C++ source code writer.
+ */
+Fd_Code_Writer::Fd_Code_Writer()
+: code_file(NULL),
+ header_file(NULL),
+ id_root(NULL),
+ text_in_header(NULL),
+ text_in_code(NULL),
+ ptr_in_code(NULL),
+ block_crc_(0),
+ block_line_start_(true),
+ block_buffer_(NULL),
+ block_buffer_size_(0),
+ indentation(0),
+ write_codeview(false),
+ varused_test(0),
+ varused(0)
+{
+ block_crc_ = crc32(0, NULL, 0);
+}
+
+/**
+ Release all resources.
+ */
+Fd_Code_Writer::~Fd_Code_Writer()
+{
+ delete id_root;
+ delete ptr_in_code;
+ delete text_in_code;
+ delete text_in_header;
+ if (block_buffer_) ::free(block_buffer_);
+}
+
+/**
+ Write a MergeBack tag as a separate line of C++ comment.
+ The tag contains information about the type of tag that we are writing, a
+ link back to the type using its unique id, and the CRC of all code written
+ after the previous tag up to this point.
+ \param[in] type FD_TAG_GENERIC, FD_TAG_CODE, FD_TAG_MENU_CALLBACK, or FD_TAG_WIDGET_CALLBACK
+ \param[in] uid the unique id of the current type
+ */
+void Fd_Code_Writer::tag(int type, unsigned short uid) {
+ if (g_project.write_mergeback_data)
+ fprintf(code_file, "//~fl~%d~%04x~%08x~~\n", type, (int)uid, (unsigned int)block_crc_);
+ block_crc_ = crc32(0, NULL, 0);
+}
+
+/**
+ Static function to calculate the CRC32 of a block of C source code.
+ Calculation of the CRC ignores leading whitespace in a line and all linefeed
+ characters ('\\r').
+ \param[in] data a pointer to the data block
+ \param[in] n the size of the data in bytes, or -1 to use strlen()
+ \param[in] in_crc add to this CRC, 0 by default to start a new block
+ \param[inout] inout_line_start optional pointer to flag that determines
+ if we are the start of a line, used to find leading whitespace
+ \return the new CRC
+ */
+unsigned long Fd_Code_Writer::block_crc(const void *data, int n, unsigned long in_crc, bool *inout_line_start) {
+ if (!data) return 0;
+ if (n==-1) n = (int)strlen((const char*)data);
+ bool line_start = true;
+ if (inout_line_start) line_start = *inout_line_start;
+ const char *s = (const char*)data;
+ for ( ; n>0; --n, ++s) {
+ if (line_start) {
+ // don't count leading spaces and tabs in a line
+ while (n>0 && *s>0 && isspace(*s)) { s++; n--; }
+ if (*s) line_start = false;
+ }
+ // don't count '\r' that may be introduced by Windows
+ if (n>0 && *s=='\r') { s++; n--; }
+ if (n>0 && *s=='\n') line_start = true;
+ if (n>0) {
+ in_crc = crc32(in_crc, (const Bytef*)s, 1);
+ }
+ }
+ if (inout_line_start) *inout_line_start = line_start;
+ return in_crc;
+}
+
+/** Add the following block of text to the CRC of this class.
+ \param[in] data a pointer to the data block
+ \param[in] n the size of the data in bytes, or -1 to use strlen()
+ */
+void Fd_Code_Writer::crc_add(const void *data, int n) {
+ block_crc_ = block_crc(data, n, block_crc_, &block_line_start_);
+}
+
+/** Write formatted text to the code file.
+ If MergeBack is enabled, the CRC calculation is continued.
+ \param[in] format printf style formatting string
+ \return see fprintf(FILE *, *const char*, ...)
+ */
+int Fd_Code_Writer::crc_printf(const char *format, ...) {
+ va_list args;
+ va_start(args, format);
+ int ret = crc_vprintf(format, args);
+ va_end(args);
+ return ret;
+}
+
+/** Write formatted text to the code file.
+ If MergeBack is enabled, the CRC calculation is continued.
+ \param[in] format printf style formatting string
+ \param[in] args list of arguments
+ \return see fprintf(FILE *, *const char*, ...)
+ */
+int Fd_Code_Writer::crc_vprintf(const char *format, va_list args) {
+ if (g_project.write_mergeback_data) {
+ int n = vsnprintf(block_buffer_, block_buffer_size_, format, args);
+ if (n > block_buffer_size_) {
+ block_buffer_size_ = n + 128;
+ if (block_buffer_) ::free(block_buffer_);
+ block_buffer_ = (char*)::malloc(block_buffer_size_+1);
+ n = vsnprintf(block_buffer_, block_buffer_size_, format, args);
+ }
+ crc_add(block_buffer_, n);
+ return fputs(block_buffer_, code_file);
+ } else {
+ return vfprintf(code_file, format, args);
+ }
+}
+
+/** Write some text to the code file.
+ If MergeBack is enabled, the CRC calculation is continued.
+ \param[in] text any text, no requirements to end in a newline or such
+ \return see fputs(const char*, FILE*)
+ */
+int Fd_Code_Writer::crc_puts(const char *text) {
+ if (g_project.write_mergeback_data) {
+ crc_add(text);
+ }
+ return fputs(text, code_file);
+}
+
+/** Write a single ASCII character to the code file.
+ If MergeBack is enabled, the CRC calculation is continued.
+ \note to write UTF-8 characters, use Fd_Code_Writer::crc_puts(const char *text)
+ \param[in] c any character between 0 and 127 inclusive
+ \return see fputc(int, FILE*)
+ */
+int Fd_Code_Writer::crc_putc(int c) {
+ if (g_project.write_mergeback_data) {
+ uchar uc = (uchar)c;
+ crc_add(&uc, 1);
+ }
+ return fputc(c, code_file);
+}
+
+/// \}
+
generated by cgit v1.2.3 (git 2.25.1) at 2026-02-08 10:11:08 +0000