/*
* Test 3: (f3 (f2 (f1 (f0 ccc))))
*/
static void test3(pp_t *pp) {
pp_push_token(pp, tag_open(opens + 3)); // f3
pp_push_token(pp, tag_open(opens + 2)); // f2
pp_push_token(pp, tag_open(opens + 1)); // f1
pp_push_token(pp, tag_open(opens + 0)); // f0
pp_push_token(pp, tag_atomic(atoms + 2)); // cc
pp_push_token(pp, tag_close(closes + 0));
pp_push_token(pp, tag_close(closes + 0));
pp_push_token(pp, tag_close(closes + 0));
pp_push_token(pp, tag_close(closes + 0));
flush_pp(pp);
}
/*
* Test1: (f0 aaa (h50000 (f2 bbb ccc)) ddd)
*/
static void test1(pp_t *pp) {
pp_push_token(pp, tag_open(opens + 0)); // f0
pp_push_token(pp, tag_atomic(atoms + 0)); // aaa
pp_push_token(pp, tag_open(opens + 9)); // h50000
pp_push_token(pp, tag_open(opens + 2)); // f2
pp_push_token(pp, tag_atomic(atoms + 1)); // bbb
pp_push_token(pp, tag_atomic(atoms + 2)); // ccc
pp_push_token(pp, tag_close(closes + 0));
pp_push_token(pp, tag_close(closes + 0));
pp_push_token(pp, tag_atomic(atoms + 3)); // ddd
pp_push_token(pp, tag_close(closes + 0));
flush_pp(pp);
}
/*
* Test 2: (g1000 aaa bbb eee fff g)
*/
static void test2(pp_t *pp) {
pp_push_token(pp, tag_open(opens + 5)); // g1000
pp_push_token(pp, tag_atomic(atoms + 0)); // aaa
pp_push_token(pp, tag_atomic(atoms + 1)); // bbb
pp_push_token(pp, tag_atomic(atoms + 4)); // eee
pp_push_token(pp, tag_atomic(atoms + 5)); // fff
pp_push_token(pp, tag_atomic(atoms + 6)); // g
pp_push_token(pp, tag_close(closes + 0));
flush_pp(pp);
}
void builder::font(int index) {
if (index <= 0 && m_counters[syntaxtag::T] > 0)
font_close(true);
if (index <= 0 || index == m_fontindex)
return;
if (m_lazy && m_counters[syntaxtag::T] > 0)
font_close(true);
m_counters[syntaxtag::T]++;
m_fontindex = index;
tag_open('T', std::to_string(index));
}
void builder::line_color(string color) {
if (color.empty() && m_counters[syntaxtag::U] > 0)
line_color_close(true);
if (color.empty() || color == m_colors[syntaxtag::U])
return;
if (m_lazy && m_counters[syntaxtag::U] > 0)
line_color_close(true);
m_counters[syntaxtag::U]++;
m_colors[syntaxtag::U] = color;
tag_open('U', color);
}
void vs_list_files(const char* path, int stage)
{
const char* ptr = path;
while (strncmp(ptr, "../", 3) == 0)
ptr += 3;
ptr = strchr(ptr, '/');
while (ptr != NULL)
ptr = strchr(ptr + 1, '/');
ptr = strrchr(path, '/');
ptr = (ptr == NULL) ? (char*)path : ptr + 1;
switch (stage)
{
case WST_OPENGROUP:
if (strlen(path) > 0 && !matches(ptr, ".."))
{
tag_open("Filter");
tag_attr("Name=\"%s\"", ptr);
tag_attr("Filter=\"\"");
}
break;
case WST_CLOSEGROUP:
if (strlen(path) > 0 && !matches(ptr, ".."))
tag_close("Filter", 1);
break;
case WST_SOURCEFILE:
tag_open("File");
tag_attr_open("RelativePath");
if (path[0] != '.')
io_print(".\\");
io_print(path_translate(path, "windows"));
tag_attr_close();
tag_close("File", 1);
break;
}
}
void soap::ctx::tok_push(void)
{
tok[tok_size]=0;
if(st==40)
{
if(tok_size)
tag_open(tok,tok_size);
tag_close("",0);
}else
{
if(st_close_tag)
tag_close(tok,tok_size);
else
tag_open(tok,tok_size);
}
tok_size=0;
st_close_tag=0;
st_quot=0;
st=0;
}
/*
* For any block B_i in the queue, we know that the bsize for
* that block is at least (f->length - B_i->col).
*
* If (f->length - B_0->col > f->max_width) then we can set B_0's
* bsize to infinity (PP_MAX_BSIZE), update the csize of the head
* token, and remove B_0 from the queue. The head token is ready to be
* printed at this point (since its csize, bsize and fsize fields are
* known).
*/
static void flush_wide_blocks(formatter_t *f) {
pp_block_t *b;
pp_open_token_t *tk, *head;
while (!block_queue_is_empty(&f->block_queue)) {
b = first_block(&f->block_queue);
assert(b->col <= f->length);
if (f->length - b->col <= f->max_width) break;
/*
* b has bsize > max_width: set its bsize to MAX
* then remove it from the block queue
*/
tk = b->token;
tk->bsize = PP_MAX_BSIZE;
head = f->head_token;
if (head != NULL) {
// update csize and fsize of the head token
head->csize = PP_MAX_BSIZE;
if (head->fsize == 0) {
head->fsize = PP_MAX_BSIZE;
}
}
// print all queued tokens, until tk
flush_tokens(f, tag_open(tk));
// tk becomes the head token
assert(ptr_queue_first(&f->token_queue) == tag_open(tk));
f->head_token = tk;
if (f->nclosed == f->queue_size) {
f->nclosed --;
}
pop_first_block(&f->block_queue);
f->queue_size --;
}
}
/*
* Initialize an open token tk and return the tagged pointer tag_open(tk).
* - formats = allowed formats for that token (PP_??_LAYOUT)
* - flags = whether '(' and space are required
* - lsize = label size
* - indent = indentation for V and M layouts
* - short_indent = indentation for the T layout
* - user_tag = whatever the converter needs
*/
void *init_open_token(pp_open_token_t *tk, uint32_t formats, uint32_t flags,
uint16_t lsize, uint16_t indent, uint16_t short_indent,
uint32_t user_tag) {
// formats must fit in the lower 4 bits
// and at least one of these bits must be set
assert((formats & ~((uint32_t) 15)) == 0 && formats != 0);
tk->formats = formats;
tk->flags = flags;
tk->label_size = lsize;
tk->indent = indent;
tk->short_indent = short_indent;
tk->user_tag = user_tag;
return tag_open(tk);
}
void builder::background(string color) {
if (color.length() == 2 || (color.find("#") == 0 && color.length() == 3)) {
color = "#" + color.substr(color.length() - 2);
auto bg = m_bar.background.source();
color += bg.substr(bg.length() - (bg.length() < 6 ? 3 : 6));
} else if (color.length() >= 7 && color == "#" + string(color.length() - 1, color[1])) {
color = color.substr(0, 4);
}
if (color.empty() && m_counters[syntaxtag::B] > 0)
background_close(true);
if (color.empty() || color == m_colors[syntaxtag::B])
return;
if (m_lazy && m_counters[syntaxtag::B] > 0)
background_close(true);
m_counters[syntaxtag::B]++;
m_colors[syntaxtag::B] = color;
tag_open('B', color);
}
void builder::color(string color_) {
auto color(color_);
if (color.length() == 2 || (color.find("#") == 0 && color.length() == 3)) {
color = "#" + color.substr(color.length() - 2);
auto fg = m_bar.foreground.source();
color += fg.substr(fg.length() - (fg.length() < 6 ? 3 : 6));
} else if (color.length() >= 7 && color == "#" + string(color.length() - 1, color[1])) {
color = color.substr(0, 4);
}
if (color.empty() && m_counters[syntaxtag::F] > 0)
color_close(true);
if (color.empty() || color == m_colors[syntaxtag::F])
return;
if (m_lazy && m_counters[syntaxtag::F] > 0)
color_close(true);
m_counters[syntaxtag::F]++;
m_colors[syntaxtag::F] = color;
tag_open('F', color);
}
static int tag_open_dir(const char *user_path, struct fuse_file_info *fi)
{
return tag_open(user_path, fi, 1);
}
void vs_list_files(const char* path, int stage)
{
int i;
const char* pchHeader = prj_get_pch_header();
const char* pchSource = prj_get_pch_source();
const char* trimPrefix = prj_get_trimprefix();
const char* ptr = path;
while (strncmp(ptr, "../", 3) == 0)
ptr += 3;
ptr = strchr(ptr, '/');
while (ptr != NULL)
ptr = strchr(ptr + 1, '/');
ptr = strrchr(path, '/');
ptr = (ptr == NULL) ? (char*)path : ptr + 1;
switch (stage)
{
case WST_OPENGROUP:
if (strlen(path) > 0 && !matches(ptr, "..") && (!trimPrefix || strncmp(path, trimPrefix, strlen(trimPrefix)) == 0))
{
tag_open("Filter");
tag_attr("Name=\"%s\"", ptr);
tag_attr("Filter=\"\"");
}
break;
case WST_CLOSEGROUP:
if (strlen(path) > 0 && !matches(ptr, "..") && (!trimPrefix || strncmp(path, trimPrefix, strlen(trimPrefix)) == 0))
tag_close("Filter", 1);
break;
case WST_SOURCEFILE:
tag_open("File");
tag_attr_open("RelativePath");
if (path[0] != '.')
io_print(".\\");
io_print(path_translate(path, "windows"));
tag_attr_close();
/* Add FileConfiguration section if this is a special PCH file, or
if it's a custom-built .asm */
if (matches(path_getname(path), pchSource) || endsWith(path, ".asm")
|| (prj_is_kind("cxxtestgen") && endsWith(path, ".h")))
{
for (i = 0; i < prj_get_numconfigs(); ++i)
{
prj_select_config(i);
tag_open("FileConfiguration");
tag_attr("Name=\"%s|Win32\"", prj_get_cfgname());
if (endsWith(path, ".asm"))
{
tag_open("Tool");
tag_attr("Name=\"VCCustomBuildTool\"");
tag_attr("Description=\"Assembling $(InputPath)\"");
{
// note: copy into our strings because path_* use static buffers.
char nasm_path[512]; // PATH_MAX isn't defined
char input_dir[512];
strcpy(nasm_path, path_translate(prj_get_nasmpath(), "windows"));
// note: NASM chokes on -i"path" and says "no input file".
// we therefore use the *relative* input directory, not VC's $(InputDir) -
// this is more likely not to contain a space in directory name.
strcpy(input_dir, path_translate(path_getdir(path) , "windows"));
// required - NASM just concatenates include path and filename.
strcat(input_dir, "\\");
tag_attr("CommandLine=\"%s -i %s -f win32 "$(InputPath)" -o "$(IntDir)\\$(InputName).obj"\"",
nasm_path, input_dir);
}
tag_attr("Outputs=\"$(IntDir)\\$(InputName).obj\"");
tag_close("Tool", 0);
}
else if (prj_is_kind("cxxtestgen") && endsWith(path, ".h"))
{
char *targetname = strdup(path_swapextension(path, ".h", ".cpp"));
char *testoptions = strdup(prj_get_cxxtest_options());
// use relative file path instead of $(InputPath) to bypass cxxtestgen command line argument parsing weirdness
const char *sourcename = path;
tag_open("Tool");
tag_attr("Name=\"VCCustomBuildTool\"");
tag_attr("Description=\"Generating %s\"", targetname);
tag_attr("CommandLine=\"%s%s --part %s -o "%s" "%s"\"",
endsWith(prj_get_cxxtestpath(), ".pl")?"perl ":"",
path_translate(prj_get_cxxtestpath(), "windows"),
testoptions,
targetname,
sourcename
);
tag_attr("Outputs=\"%s\"", targetname);
tag_close("Tool", 0);
free(targetname);
free(testoptions);
}
else /* (.asm doesn't need PCH) */
{
tag_open("Tool");
tag_attr("Name=\"VCCLCompilerTool\"");
tag_attr("UsePrecompiledHeader=\"1\"");
tag_close("Tool", 0);
}
tag_close("FileConfiguration", 1);
}
}
tag_close("File", 1);
break;
}
}
int vs_write_cpp()
{
const char* str;
int i, b;
VsPkgData* data = (VsPkgData*)prj_get_data();
/* Open the file and write the header */
if (!io_openfile(path_join(prj_get_pkgpath(), prj_get_pkgname(), "vcproj")))
return 0;
prj_select_config(0);
io_print("<?xml version=\"1.0\" encoding=\"Windows-1252\"?>\n");
tag_open("VisualStudioProject");
tag_attr("ProjectType=\"Visual C++\"");
switch (version)
{
case VS2002:
str = "7.00";
break;
case VS2003:
str = "7.10";
break;
case VS2005:
str = "8.00";
break;
case VS2008:
str = "9.00";
break;
}
tag_attr("Version=\"%s\"", str);
tag_attr("Name=\"%s\"", prj_get_pkgname());
tag_attr("ProjectGUID=\"{%s}\"", data->projGuid);
if (version >= VS2005)
tag_attr("RootNamespace=\"%s\"", prj_get_pkgname());
tag_attr("Keyword=\"%s\"", prj_has_flag("managed") ? "ManagedCProj" : "Win32Proj");
tag_open("Platforms");
tag_open("Platform");
tag_attr("Name=\"Win32\"");
tag_close("Platform", 0);
tag_close("Platforms", 1);
if (version >= VS2005)
{
tag_open("ToolFiles");
tag_close("ToolFiles", 1);
}
/* Write configurations */
tag_open("Configurations");
for (i = 0; i < prj_get_numconfigs(); ++i)
{
int optimization, debug, runtime, symbols, configTypeId;
const char* pchHeader = prj_get_pch_header();
prj_select_config(i);
if (prj_is_kind("winexe") || prj_is_kind("exe") || prj_is_kind("cxxtestgen") || prj_is_kind("run"))
{
configTypeId = 1;
}
else if (prj_is_kind("dll"))
{
configTypeId = 2;
}
else if (prj_is_kind("lib"))
{
configTypeId = 4;
}
else if (prj_is_kind("aspnet"))
{
puts("** Error: C++ ASP.NET projects are not supported");
return 0;
}
else
{
printf("** Error: unknown package kind '%s'\n", prj_get_kind());
return 0;
}
if (prj_has_flag("optimize-speed"))
optimization = 2;
else if (prj_has_flag("optimize-size"))
optimization = 1;
else if (prj_has_flag("optimize"))
optimization = 3;
else
optimization = 0;
debug = (optimization ==0);
if (prj_has_flag("static-runtime"))
runtime = (debug) ? 1 : 0;
else
runtime = (debug) ? 3 : 2;
if (prj_has_flag("no-symbols"))
symbols = 0;
else
symbols = (prj_has_flag("managed") || prj_has_flag("no-edit-and-continue")) ? 3 : 4;
tag_open("Configuration");
tag_attr("Name=\"%s|Win32\"", prj_get_cfgname());
tag_attr("OutputDirectory=\"%s\"", prj_get_outdir());
tag_attr("IntermediateDirectory=\"%s\"", prj_get_objdir());
tag_attr("ConfigurationType=\"%d\"", configTypeId);
tag_attr("CharacterSet=\"%d\"", prj_has_flag("unicode") ? 1 : 2);
if (prj_has_flag("managed"))
tag_attr("ManagedExtensions=\"%s\"", S_TRUE);
/* Write out tool blocks */
for (b = 0; blocks[version][b] != BlocksEnd; ++b)
{
tag_open("Tool");
switch (blocks[version][b])
{
case VCPreBuildEventTool:
tag_attr("Name=\"VCPreBuildEventTool\"");
break;
case VCCustomBuildTool:
tag_attr("Name=\"VCCustomBuildTool\"");
if (prj_is_kind("run"))
{
tag_attr("Description=\"Running CxxTest Test Suite\"");
tag_attr_open("CommandLine");
print_list(prj_get_links(), "", "", " ", vs_filter_links);
print_list(prj_get_buildoptions(), " ", "", "", NULL);
tag_attr_close();
// This so that we're always run (and never "up-to-date")
tag_attr("Outputs=\".\\dummy.file.thats.never.created\"");
}
else if (prj_is_kind("cxxtestgen"))
{
char *rootfile = strdup(prj_get_cxxtest_rootfile());
char *ctpath = strdup(path_translate(prj_get_cxxtestpath(), "windows"));
char *options = strdup(prj_get_cxxtest_rootoptions());
tag_attr("Description=\"Generating test_root.cpp\"");
tag_attr("CommandLine=\"%s%s --root %s -o "%s"\"",
endsWith(prj_get_cxxtestpath(), ".pl")?"perl ":"",
ctpath,
options,
rootfile);
tag_attr("Outputs=\"%s\"", rootfile);
free(options);
free(ctpath);
free(rootfile);
}
break;
case VCXMLDataGeneratorTool:
tag_attr("Name=\"VCXMLDataGeneratorTool\"");
break;
case VCManagedWrapperGeneratorTool:
tag_attr("Name=\"VCManagedWrapperGeneratorTool\"");
break;
case VCAuxiliaryManagedWrapperGeneratorTool:
tag_attr("Name=\"VCAuxiliaryManagedWrapperGeneratorTool\"");
break;
case VCWebServiceProxyGeneratorTool:
tag_attr("Name=\"VCWebServiceProxyGeneratorTool\"");
break;
case VCMIDLTool:
tag_attr("Name=\"VCMIDLTool\"");
break;
case VCManagedResourceCompilerTool:
tag_attr("Name=\"VCManagedResourceCompilerTool\"");
break;
case VCResourceCompilerTool:
tag_attr("Name=\"VCResourceCompilerTool\"");
if (prj_get_numincpaths() > 0)
{
tag_attr_open("AdditionalIncludeDirectories");
print_list(prj_get_incpaths(), "", "", ";", NULL);
tag_attr_close();
}
break;
case VCPreLinkEventTool:
tag_attr("Name=\"VCPreLinkEventTool\"");
break;
case VCALinkTool:
tag_attr("Name=\"VCALinkTool\"");
break;
case VCManifestTool:
tag_attr("Name=\"VCManifestTool\"");
break;
case VCXDCMakeTool:
tag_attr("Name=\"VCXDCMakeTool\"");
break;
case VCBscMakeTool:
tag_attr("Name=\"VCBscMakeTool\"");
break;
case VCFxCopTool:
tag_attr("Name=\"VCFxCopTool\"");
break;
case VCAppVerifierTool:
tag_attr("Name=\"VCAppVerifierTool\"");
break;
case VCWebDeploymentTool:
tag_attr("Name=\"VCWebDeploymentTool\"");
break;
case VCPostBuildEventTool:
tag_attr("Name=\"VCPostBuildEventTool\"");
break;
case VCCLCompilerTool:
tag_attr("Name=\"VCCLCompilerTool\"");
if (prj_get_numbuildoptions() > 0)
{
tag_attr_open("AdditionalOptions");
print_list(prj_get_buildoptions(), "", "", " ", NULL);
tag_attr_close();
}
tag_attr("Optimization=\"%d\"", optimization);
if (prj_has_flag("no-frame-pointer"))
tag_attr("OmitFramePointers=\"%s\"", S_TRUE);
if (prj_get_numincpaths() > 0)
{
tag_attr_open("AdditionalIncludeDirectories");
print_list(prj_get_incpaths(), "", "", ";", NULL);
tag_attr_close();
}
if (prj_has_flag("managed"))
tag_attr("AdditionalUsingDirectories=\"%s\"", prj_get_bindir());
if (prj_get_numdefines() > 0)
{
tag_attr_open("PreprocessorDefinitions");
print_list(prj_get_defines(), "", "", ";", NULL);
tag_attr_close();
}
if (debug && !prj_has_flag("managed"))
tag_attr("MinimalRebuild=\"%s\"", S_TRUE);
if (prj_has_flag("no-exceptions"))
tag_attr("ExceptionHandling=\"%s\"", S_FALSE);
if (debug && !prj_has_flag("managed"))
tag_attr("BasicRuntimeChecks=\"3\"");
if (!debug)
tag_attr("StringPooling=\"%s\"", S_TRUE);
tag_attr("RuntimeLibrary=\"%d\"", runtime);
tag_attr("EnableFunctionLevelLinking=\"%s\"", S_TRUE);
if (version < VS2005 && !prj_has_flag("no-rtti"))
tag_attr("RuntimeTypeInfo=\"%s\"", S_TRUE);
if (version >= VS2005 && prj_has_flag("no-rtti"))
tag_attr("RuntimeTypeInfo=\"%s\"", S_FALSE);
if (version < VS2005 && prj_has_flag("native-wchar_t"))
tag_attr("TreatWChar_tAsBuiltInType=\"%s\"", S_TRUE);
if (version >= VS2005 && prj_has_flag("no-native-wchar_t"))
tag_attr("TreatWChar_tAsBuiltInType=\"%s\"", S_FALSE);
if (pchHeader)
{
tag_attr("UsePrecompiledHeader=\"%d\"", version < VS2005 ? 3 : 2);
tag_attr("PrecompiledHeaderThrough=\"%s\"", pchHeader);
}
else
tag_attr("UsePrecompiledHeader=\"%d\"", version < VS2005 ? 2 : 0);
tag_attr("WarningLevel=\"%d\"", prj_has_flag("extra-warnings") ? 4 : 3);
if (prj_has_flag("fatal-warnings"))
tag_attr("WarnAsError=\"%s\"", S_TRUE);
if (version < VS2008 && !prj_has_flag("managed"))
tag_attr("Detect64BitPortabilityProblems=\"%s\"", prj_has_flag("no-64bit-checks") ? S_FALSE : S_TRUE);
tag_attr("DebugInformationFormat=\"%d\"", symbols);
break;
case VCLinkerTool:
if (!prj_is_kind("lib"))
{
tag_attr("Name=\"VCLinkerTool\"");
if (prj_has_flag("no-import-lib"))
tag_attr("IgnoreImportLibrary=\"%s\"", S_TRUE);
if (prj_has_flag("use-library-dep-inputs") && version >= VS2005)
tag_attr("UseLibraryDependencyInputs=\"%s\"", S_TRUE);
if (prj_get_numlinkoptions() > 0)
{
tag_attr_open("AdditionalOptions");
print_list(prj_get_linkoptions(), " ", "", "", NULL);
tag_attr_close();
}
if (prj_get_numlinks() > 0)
{
tag_attr_open("AdditionalDependencies");
print_list(prj_get_links(), "", ".lib", " ", vs_filter_links);
tag_attr_close();
}
tag_attr("OutputFile=\"$(OutDir)/%s\"", path_getname(prj_get_target()));
tag_attr("LinkIncremental=\"%d\"", debug ? 2 : 1);
tag_attr_open("AdditionalLibraryDirectories");
io_print(prj_get_libdir());
print_list(prj_get_libpaths(), ";", "", "", NULL);
tag_attr_close();
/* Look for a .def file for DLLs */
if (prj_find_filetype(".def") != NULL)
tag_attr("ModuleDefinitionFile=\"%s\"", prj_find_filetype(".def"));
if (prj_has_flag("no-manifest"))
tag_attr("GenerateManifest=\"%s\"", S_FALSE);
tag_attr("GenerateDebugInformation=\"%s\"", symbols ? S_TRUE : S_FALSE);
if (symbols)
tag_attr("ProgramDatabaseFile=\"$(OutDir)/%s.pdb\"", path_getbasename(prj_get_target()));
tag_attr("SubSystem=\"%d\"", prj_is_kind("exe") ? 1 : 2);
if (!debug) tag_attr("OptimizeReferences=\"2\"");
if (!debug) tag_attr("EnableCOMDATFolding=\"2\"");
if ((prj_is_kind("exe") || prj_is_kind("winexe")) && !prj_has_flag("no-main"))
{
tag_attr("EntryPointSymbol=\"mainCRTStartup\"");
}
else if (prj_is_kind("dll"))
{
tag_attr_open("ImportLibrary");
if (prj_has_flag("no-import-lib"))
io_print(prj_get_objdir());
else
io_print(prj_get_libdir());
io_print("/%s.lib", path_getbasename(prj_get_target()));
tag_attr_close();
}
tag_attr("TargetMachine=\"1\"");
}
else
{
tag_attr("Name=\"VCLibrarianTool\"");
tag_attr("OutputFile=\"$(OutDir)/%s.lib\"", path_getbasename(prj_get_target()));
}
break;
}
tag_close("", 0);
}
tag_close("Configuration", 1);
}
tag_close("Configurations", 1);
if (version > VS2002)
{
tag_open("References");
tag_close("References", 1);
}
tag_open("Files");
print_source_tree("", vs_list_files);
/*if (prj_is_kind("cxxtestgen"))
{
char *rootfile = strdup(prj_get_cxxtest_rootfile());
char *ctpath = strdup(path_translate(prj_get_cxxtestpath(), "windows"));
int i;
tag_open("File");
tag_attr_open("RelativePath");
if (rootfile[0] != '.')
io_print(".\\");
io_print(rootfile);
tag_attr_close();
for (i = 0; i < prj_get_numconfigs(); ++i)
{
char *options;
prj_select_config(i);
options = strdup(prj_get_cxxtest_rootoptions());
tag_open("FileConfiguration");
tag_attr("Name=\"%s|Win32\"", prj_get_cfgname());
tag_open("Tool");
tag_attr("Name=\"VCCustomBuildTool\"");
tag_attr("Description=\"Generating test_root.cpp\"");
tag_attr("CommandLine=\"%s%s --root %s -o "%s"\"",
endsWith(prj_get_cxxtestpath(), ".pl")?"perl ":"",
ctpath,
options,
rootfile);
tag_attr("Outputs=\"%s\"", rootfile);
tag_close("Tool", 0);
tag_close("FileConfiguration", 1);
free(options);
}
tag_close("File", 1);
free(ctpath);
free(rootfile);
}*/
tag_close("Files", 1);
tag_open("Globals");
tag_close("Globals", 1);
tag_close("VisualStudioProject", 1);
io_closefile();
return 1;
}
/*
* Print the label and '(' for open block tk
*/
static void print_open_token(printer_t *p, pp_open_token_t *tk) {
uint32_t new_col;
if (p->area.truncate) {
if (p->col + 4 <= p->margin) {
/*
* truncate mode, line not full, nothing pending
*/
assert(!p->full_line && p->pending_tokens.size == 0);
print_blank(p);
new_col = p->col + tk->label_size + tk_has_par(tk);
if (new_col + 4 <= p->margin) {
// tk fits and there's room for ' ...' after it
print_label(p, tk);
} else if (new_col <= p->margin) {
// we can't tell whether tk fits yet
// because we may need ellipsis
p->pending_col = p->col;
p->col = new_col;
pvector_push(&p->pending_tokens, tag_open(tk));
} else {
// tk does not fit: print it truncated
print_label_truncated(p, tk);
p->full_line = true;;
}
} else if (!p->full_line) {
/*
* truncate mode, line not full, tokens pending
*/
assert(p->col <= p->margin && p->pending_tokens.size > 0);
// add tk to the pending tokens if it fits
new_col = p->col + tk->bsize + tk_has_par(tk) + (! p->no_space);
if (new_col <= p->margin) {
p->col = new_col;
pvector_push(&p->pending_tokens, tag_open(tk));
} else {
// the pending tokens don't fit
// print what we can + ellipsis
print_pending_truncated(p);
free_open_token(p, tk);
p->full_line = true;
}
} else {
/*
* truncate mode, line full, nothing pending
*/
assert(p->pending_tokens.size == 0);
free_open_token(p, tk);
}
} else {
/*
* don't truncate
*/
print_blank(p);
print_label(p, tk);
}
}
void builder::offset(int pixels) {
if (pixels != 0)
tag_open('O', std::to_string(pixels));
}
void builder::invert() {
tag_open('R', "");
}
