| /aoo42x/main/autodoc/source/exes/adc_uni/ |
| H A D | adc_cl.cxx | diff b32aa359 Sat Mar 10 09:06:22 UTC 2018 Damjan Jovanovic <damjan@apache.org> tr;dr: Don't use .map files for main/cppuhelper on Windows, control
symbol visibility using source-level declarations instead.
C++ symbols are mangled differently on Win64 and Win32, and extracting
new symbols from binaries and updating .DEF/.map files that control symbol
visibility is painful. Both Windows and *nix have moved from using .DEF
and .map files to using declarations in the source code instead, of the
form __declspec(dllexport) and __attribute__ ((visibility("default")))
(which we wrap in SAL_DLLPUBLIC_EXPORT).
The GBuild ported modules also have to replace .map files with source code
declarations (and all so far have), as the default symbol visibility in
GBuild is "hidden" and GBuild has no mechanism to use .map files so far.
So for the purpose of the Win64 port, but as a generally good idea and a
necessity for future GBuild ports, re-implement linker symbol visibility
in main/cppuhelper using SAL_DLLPUBLIC_EXPORT declarations in the source
code instead of using .map files. The purpose of .map files is to version
symbols in the ELF binary format on *nix instead of just controlling
visibility, so they still provide that benefit on *nix, but Windows has no
symbol versioning, all dmake does with .map files is convert them to
unversioned .DEF files, which are harder to maintain than source-level
declarations (as they are both mangled and in a separate file, and have
to be specified per method instead of only once per class).
This turned out to cause trouble, as our autodoc tool doesn't have a C
preprocessor, so the "CPPUHELPER_DLLPUBLIC" was breaking generating
documentation, which was breaking the build due to documentation
completeness checks in main/odk. Thus main/autodoc had to be patched to
allow command line parameters passed to it to specify parsing tokens to
ignore, and main/odk had to be patched to pass "CPPUHELPER_DLLPUBLIC" as
the token to ignore.
Patch by: me
git-svn-id: https://svn.apache.org/repos/asf/openoffice/trunk@1826398 13f79535-47bb-0310-9956-ffa450edef68
|
| H A D | adc_cmds.cxx | diff b32aa359 Sat Mar 10 09:06:22 UTC 2018 Damjan Jovanovic <damjan@apache.org> tr;dr: Don't use .map files for main/cppuhelper on Windows, control
symbol visibility using source-level declarations instead.
C++ symbols are mangled differently on Win64 and Win32, and extracting
new symbols from binaries and updating .DEF/.map files that control symbol
visibility is painful. Both Windows and *nix have moved from using .DEF
and .map files to using declarations in the source code instead, of the
form __declspec(dllexport) and __attribute__ ((visibility("default")))
(which we wrap in SAL_DLLPUBLIC_EXPORT).
The GBuild ported modules also have to replace .map files with source code
declarations (and all so far have), as the default symbol visibility in
GBuild is "hidden" and GBuild has no mechanism to use .map files so far.
So for the purpose of the Win64 port, but as a generally good idea and a
necessity for future GBuild ports, re-implement linker symbol visibility
in main/cppuhelper using SAL_DLLPUBLIC_EXPORT declarations in the source
code instead of using .map files. The purpose of .map files is to version
symbols in the ELF binary format on *nix instead of just controlling
visibility, so they still provide that benefit on *nix, but Windows has no
symbol versioning, all dmake does with .map files is convert them to
unversioned .DEF files, which are harder to maintain than source-level
declarations (as they are both mangled and in a separate file, and have
to be specified per method instead of only once per class).
This turned out to cause trouble, as our autodoc tool doesn't have a C
preprocessor, so the "CPPUHELPER_DLLPUBLIC" was breaking generating
documentation, which was breaking the build due to documentation
completeness checks in main/odk. Thus main/autodoc had to be patched to
allow command line parameters passed to it to specify parsing tokens to
ignore, and main/odk had to be patched to pass "CPPUHELPER_DLLPUBLIC" as
the token to ignore.
Patch by: me
git-svn-id: https://svn.apache.org/repos/asf/openoffice/trunk@1826398 13f79535-47bb-0310-9956-ffa450edef68
|
| H A D | adc_cmds.hxx | diff b32aa359 Sat Mar 10 09:06:22 UTC 2018 Damjan Jovanovic <damjan@apache.org> tr;dr: Don't use .map files for main/cppuhelper on Windows, control
symbol visibility using source-level declarations instead.
C++ symbols are mangled differently on Win64 and Win32, and extracting
new symbols from binaries and updating .DEF/.map files that control symbol
visibility is painful. Both Windows and *nix have moved from using .DEF
and .map files to using declarations in the source code instead, of the
form __declspec(dllexport) and __attribute__ ((visibility("default")))
(which we wrap in SAL_DLLPUBLIC_EXPORT).
The GBuild ported modules also have to replace .map files with source code
declarations (and all so far have), as the default symbol visibility in
GBuild is "hidden" and GBuild has no mechanism to use .map files so far.
So for the purpose of the Win64 port, but as a generally good idea and a
necessity for future GBuild ports, re-implement linker symbol visibility
in main/cppuhelper using SAL_DLLPUBLIC_EXPORT declarations in the source
code instead of using .map files. The purpose of .map files is to version
symbols in the ELF binary format on *nix instead of just controlling
visibility, so they still provide that benefit on *nix, but Windows has no
symbol versioning, all dmake does with .map files is convert them to
unversioned .DEF files, which are harder to maintain than source-level
declarations (as they are both mangled and in a separate file, and have
to be specified per method instead of only once per class).
This turned out to cause trouble, as our autodoc tool doesn't have a C
preprocessor, so the "CPPUHELPER_DLLPUBLIC" was breaking generating
documentation, which was breaking the build due to documentation
completeness checks in main/odk. Thus main/autodoc had to be patched to
allow command line parameters passed to it to specify parsing tokens to
ignore, and main/odk had to be patched to pass "CPPUHELPER_DLLPUBLIC" as
the token to ignore.
Patch by: me
git-svn-id: https://svn.apache.org/repos/asf/openoffice/trunk@1826398 13f79535-47bb-0310-9956-ffa450edef68
|
| H A D | cmd_run.cxx | diff b32aa359 Sat Mar 10 09:06:22 UTC 2018 Damjan Jovanovic <damjan@apache.org> tr;dr: Don't use .map files for main/cppuhelper on Windows, control
symbol visibility using source-level declarations instead.
C++ symbols are mangled differently on Win64 and Win32, and extracting
new symbols from binaries and updating .DEF/.map files that control symbol
visibility is painful. Both Windows and *nix have moved from using .DEF
and .map files to using declarations in the source code instead, of the
form __declspec(dllexport) and __attribute__ ((visibility("default")))
(which we wrap in SAL_DLLPUBLIC_EXPORT).
The GBuild ported modules also have to replace .map files with source code
declarations (and all so far have), as the default symbol visibility in
GBuild is "hidden" and GBuild has no mechanism to use .map files so far.
So for the purpose of the Win64 port, but as a generally good idea and a
necessity for future GBuild ports, re-implement linker symbol visibility
in main/cppuhelper using SAL_DLLPUBLIC_EXPORT declarations in the source
code instead of using .map files. The purpose of .map files is to version
symbols in the ELF binary format on *nix instead of just controlling
visibility, so they still provide that benefit on *nix, but Windows has no
symbol versioning, all dmake does with .map files is convert them to
unversioned .DEF files, which are harder to maintain than source-level
declarations (as they are both mangled and in a separate file, and have
to be specified per method instead of only once per class).
This turned out to cause trouble, as our autodoc tool doesn't have a C
preprocessor, so the "CPPUHELPER_DLLPUBLIC" was breaking generating
documentation, which was breaking the build due to documentation
completeness checks in main/odk. Thus main/autodoc had to be patched to
allow command line parameters passed to it to specify parsing tokens to
ignore, and main/odk had to be patched to pass "CPPUHELPER_DLLPUBLIC" as
the token to ignore.
Patch by: me
git-svn-id: https://svn.apache.org/repos/asf/openoffice/trunk@1826398 13f79535-47bb-0310-9956-ffa450edef68
|
| H A D | spec-CommandLine.txt | diff b32aa359 Sat Mar 10 09:06:22 UTC 2018 Damjan Jovanovic <damjan@apache.org> tr;dr: Don't use .map files for main/cppuhelper on Windows, control
symbol visibility using source-level declarations instead.
C++ symbols are mangled differently on Win64 and Win32, and extracting
new symbols from binaries and updating .DEF/.map files that control symbol
visibility is painful. Both Windows and *nix have moved from using .DEF
and .map files to using declarations in the source code instead, of the
form __declspec(dllexport) and __attribute__ ((visibility("default")))
(which we wrap in SAL_DLLPUBLIC_EXPORT).
The GBuild ported modules also have to replace .map files with source code
declarations (and all so far have), as the default symbol visibility in
GBuild is "hidden" and GBuild has no mechanism to use .map files so far.
So for the purpose of the Win64 port, but as a generally good idea and a
necessity for future GBuild ports, re-implement linker symbol visibility
in main/cppuhelper using SAL_DLLPUBLIC_EXPORT declarations in the source
code instead of using .map files. The purpose of .map files is to version
symbols in the ELF binary format on *nix instead of just controlling
visibility, so they still provide that benefit on *nix, but Windows has no
symbol versioning, all dmake does with .map files is convert them to
unversioned .DEF files, which are harder to maintain than source-level
declarations (as they are both mangled and in a separate file, and have
to be specified per method instead of only once per class).
This turned out to cause trouble, as our autodoc tool doesn't have a C
preprocessor, so the "CPPUHELPER_DLLPUBLIC" was breaking generating
documentation, which was breaking the build due to documentation
completeness checks in main/odk. Thus main/autodoc had to be patched to
allow command line parameters passed to it to specify parsing tokens to
ignore, and main/odk had to be patched to pass "CPPUHELPER_DLLPUBLIC" as
the token to ignore.
Patch by: me
git-svn-id: https://svn.apache.org/repos/asf/openoffice/trunk@1826398 13f79535-47bb-0310-9956-ffa450edef68
|
| /aoo42x/main/autodoc/source/inc/ |
| H A D | adc_cl.hxx | diff b32aa359 Sat Mar 10 09:06:22 UTC 2018 Damjan Jovanovic <damjan@apache.org> tr;dr: Don't use .map files for main/cppuhelper on Windows, control
symbol visibility using source-level declarations instead.
C++ symbols are mangled differently on Win64 and Win32, and extracting
new symbols from binaries and updating .DEF/.map files that control symbol
visibility is painful. Both Windows and *nix have moved from using .DEF
and .map files to using declarations in the source code instead, of the
form __declspec(dllexport) and __attribute__ ((visibility("default")))
(which we wrap in SAL_DLLPUBLIC_EXPORT).
The GBuild ported modules also have to replace .map files with source code
declarations (and all so far have), as the default symbol visibility in
GBuild is "hidden" and GBuild has no mechanism to use .map files so far.
So for the purpose of the Win64 port, but as a generally good idea and a
necessity for future GBuild ports, re-implement linker symbol visibility
in main/cppuhelper using SAL_DLLPUBLIC_EXPORT declarations in the source
code instead of using .map files. The purpose of .map files is to version
symbols in the ELF binary format on *nix instead of just controlling
visibility, so they still provide that benefit on *nix, but Windows has no
symbol versioning, all dmake does with .map files is convert them to
unversioned .DEF files, which are harder to maintain than source-level
declarations (as they are both mangled and in a separate file, and have
to be specified per method instead of only once per class).
This turned out to cause trouble, as our autodoc tool doesn't have a C
preprocessor, so the "CPPUHELPER_DLLPUBLIC" was breaking generating
documentation, which was breaking the build due to documentation
completeness checks in main/odk. Thus main/autodoc had to be patched to
allow command line parameters passed to it to specify parsing tokens to
ignore, and main/odk had to be patched to pass "CPPUHELPER_DLLPUBLIC" as
the token to ignore.
Patch by: me
git-svn-id: https://svn.apache.org/repos/asf/openoffice/trunk@1826398 13f79535-47bb-0310-9956-ffa450edef68
|
| /aoo42x/main/autodoc/source/parser/cpp/ |
| H A D | prs_cpp.cxx | diff b32aa359 Sat Mar 10 09:06:22 UTC 2018 Damjan Jovanovic <damjan@apache.org> tr;dr: Don't use .map files for main/cppuhelper on Windows, control
symbol visibility using source-level declarations instead.
C++ symbols are mangled differently on Win64 and Win32, and extracting
new symbols from binaries and updating .DEF/.map files that control symbol
visibility is painful. Both Windows and *nix have moved from using .DEF
and .map files to using declarations in the source code instead, of the
form __declspec(dllexport) and __attribute__ ((visibility("default")))
(which we wrap in SAL_DLLPUBLIC_EXPORT).
The GBuild ported modules also have to replace .map files with source code
declarations (and all so far have), as the default symbol visibility in
GBuild is "hidden" and GBuild has no mechanism to use .map files so far.
So for the purpose of the Win64 port, but as a generally good idea and a
necessity for future GBuild ports, re-implement linker symbol visibility
in main/cppuhelper using SAL_DLLPUBLIC_EXPORT declarations in the source
code instead of using .map files. The purpose of .map files is to version
symbols in the ELF binary format on *nix instead of just controlling
visibility, so they still provide that benefit on *nix, but Windows has no
symbol versioning, all dmake does with .map files is convert them to
unversioned .DEF files, which are harder to maintain than source-level
declarations (as they are both mangled and in a separate file, and have
to be specified per method instead of only once per class).
This turned out to cause trouble, as our autodoc tool doesn't have a C
preprocessor, so the "CPPUHELPER_DLLPUBLIC" was breaking generating
documentation, which was breaking the build due to documentation
completeness checks in main/odk. Thus main/autodoc had to be patched to
allow command line parameters passed to it to specify parsing tokens to
ignore, and main/odk had to be patched to pass "CPPUHELPER_DLLPUBLIC" as
the token to ignore.
Patch by: me
git-svn-id: https://svn.apache.org/repos/asf/openoffice/trunk@1826398 13f79535-47bb-0310-9956-ffa450edef68
|
| /aoo42x/main/autodoc/source/parser/inc/cpp/ |
| H A D | prs_cpp.hxx | diff b32aa359 Sat Mar 10 09:06:22 UTC 2018 Damjan Jovanovic <damjan@apache.org> tr;dr: Don't use .map files for main/cppuhelper on Windows, control
symbol visibility using source-level declarations instead.
C++ symbols are mangled differently on Win64 and Win32, and extracting
new symbols from binaries and updating .DEF/.map files that control symbol
visibility is painful. Both Windows and *nix have moved from using .DEF
and .map files to using declarations in the source code instead, of the
form __declspec(dllexport) and __attribute__ ((visibility("default")))
(which we wrap in SAL_DLLPUBLIC_EXPORT).
The GBuild ported modules also have to replace .map files with source code
declarations (and all so far have), as the default symbol visibility in
GBuild is "hidden" and GBuild has no mechanism to use .map files so far.
So for the purpose of the Win64 port, but as a generally good idea and a
necessity for future GBuild ports, re-implement linker symbol visibility
in main/cppuhelper using SAL_DLLPUBLIC_EXPORT declarations in the source
code instead of using .map files. The purpose of .map files is to version
symbols in the ELF binary format on *nix instead of just controlling
visibility, so they still provide that benefit on *nix, but Windows has no
symbol versioning, all dmake does with .map files is convert them to
unversioned .DEF files, which are harder to maintain than source-level
declarations (as they are both mangled and in a separate file, and have
to be specified per method instead of only once per class).
This turned out to cause trouble, as our autodoc tool doesn't have a C
preprocessor, so the "CPPUHELPER_DLLPUBLIC" was breaking generating
documentation, which was breaking the build due to documentation
completeness checks in main/odk. Thus main/autodoc had to be patched to
allow command line parameters passed to it to specify parsing tokens to
ignore, and main/odk had to be patched to pass "CPPUHELPER_DLLPUBLIC" as
the token to ignore.
Patch by: me
git-svn-id: https://svn.apache.org/repos/asf/openoffice/trunk@1826398 13f79535-47bb-0310-9956-ffa450edef68
|
| /aoo42x/main/autodoc/inc/autodoc/ |
| H A D | prs_code.hxx | diff b32aa359 Sat Mar 10 09:06:22 UTC 2018 Damjan Jovanovic <damjan@apache.org> tr;dr: Don't use .map files for main/cppuhelper on Windows, control
symbol visibility using source-level declarations instead.
C++ symbols are mangled differently on Win64 and Win32, and extracting
new symbols from binaries and updating .DEF/.map files that control symbol
visibility is painful. Both Windows and *nix have moved from using .DEF
and .map files to using declarations in the source code instead, of the
form __declspec(dllexport) and __attribute__ ((visibility("default")))
(which we wrap in SAL_DLLPUBLIC_EXPORT).
The GBuild ported modules also have to replace .map files with source code
declarations (and all so far have), as the default symbol visibility in
GBuild is "hidden" and GBuild has no mechanism to use .map files so far.
So for the purpose of the Win64 port, but as a generally good idea and a
necessity for future GBuild ports, re-implement linker symbol visibility
in main/cppuhelper using SAL_DLLPUBLIC_EXPORT declarations in the source
code instead of using .map files. The purpose of .map files is to version
symbols in the ELF binary format on *nix instead of just controlling
visibility, so they still provide that benefit on *nix, but Windows has no
symbol versioning, all dmake does with .map files is convert them to
unversioned .DEF files, which are harder to maintain than source-level
declarations (as they are both mangled and in a separate file, and have
to be specified per method instead of only once per class).
This turned out to cause trouble, as our autodoc tool doesn't have a C
preprocessor, so the "CPPUHELPER_DLLPUBLIC" was breaking generating
documentation, which was breaking the build due to documentation
completeness checks in main/odk. Thus main/autodoc had to be patched to
allow command line parameters passed to it to specify parsing tokens to
ignore, and main/odk had to be patched to pass "CPPUHELPER_DLLPUBLIC" as
the token to ignore.
Patch by: me
git-svn-id: https://svn.apache.org/repos/asf/openoffice/trunk@1826398 13f79535-47bb-0310-9956-ffa450edef68
|
| /aoo42x/main/cppuhelper/inc/cppuhelper/ |
| H A D | cppuhelperdllapi.h | b32aa359 Sat Mar 10 09:06:22 UTC 2018 Damjan Jovanovic <damjan@apache.org> tr;dr: Don't use .map files for main/cppuhelper on Windows, control
symbol visibility using source-level declarations instead.
C++ symbols are mangled differently on Win64 and Win32, and extracting
new symbols from binaries and updating .DEF/.map files that control symbol
visibility is painful. Both Windows and *nix have moved from using .DEF
and .map files to using declarations in the source code instead, of the
form __declspec(dllexport) and __attribute__ ((visibility("default")))
(which we wrap in SAL_DLLPUBLIC_EXPORT).
The GBuild ported modules also have to replace .map files with source code
declarations (and all so far have), as the default symbol visibility in
GBuild is "hidden" and GBuild has no mechanism to use .map files so far.
So for the purpose of the Win64 port, but as a generally good idea and a
necessity for future GBuild ports, re-implement linker symbol visibility
in main/cppuhelper using SAL_DLLPUBLIC_EXPORT declarations in the source
code instead of using .map files. The purpose of .map files is to version
symbols in the ELF binary format on *nix instead of just controlling
visibility, so they still provide that benefit on *nix, but Windows has no
symbol versioning, all dmake does with .map files is convert them to
unversioned .DEF files, which are harder to maintain than source-level
declarations (as they are both mangled and in a separate file, and have
to be specified per method instead of only once per class).
This turned out to cause trouble, as our autodoc tool doesn't have a C
preprocessor, so the "CPPUHELPER_DLLPUBLIC" was breaking generating
documentation, which was breaking the build due to documentation
completeness checks in main/odk. Thus main/autodoc had to be patched to
allow command line parameters passed to it to specify parsing tokens to
ignore, and main/odk had to be patched to pass "CPPUHELPER_DLLPUBLIC" as
the token to ignore.
Patch by: me
git-svn-id: https://svn.apache.org/repos/asf/openoffice/trunk@1826398 13f79535-47bb-0310-9956-ffa450edef68
|
| H A D | access_control.hxx | diff b32aa359 Sat Mar 10 09:06:22 UTC 2018 Damjan Jovanovic <damjan@apache.org> tr;dr: Don't use .map files for main/cppuhelper on Windows, control
symbol visibility using source-level declarations instead.
C++ symbols are mangled differently on Win64 and Win32, and extracting
new symbols from binaries and updating .DEF/.map files that control symbol
visibility is painful. Both Windows and *nix have moved from using .DEF
and .map files to using declarations in the source code instead, of the
form __declspec(dllexport) and __attribute__ ((visibility("default")))
(which we wrap in SAL_DLLPUBLIC_EXPORT).
The GBuild ported modules also have to replace .map files with source code
declarations (and all so far have), as the default symbol visibility in
GBuild is "hidden" and GBuild has no mechanism to use .map files so far.
So for the purpose of the Win64 port, but as a generally good idea and a
necessity for future GBuild ports, re-implement linker symbol visibility
in main/cppuhelper using SAL_DLLPUBLIC_EXPORT declarations in the source
code instead of using .map files. The purpose of .map files is to version
symbols in the ELF binary format on *nix instead of just controlling
visibility, so they still provide that benefit on *nix, but Windows has no
symbol versioning, all dmake does with .map files is convert them to
unversioned .DEF files, which are harder to maintain than source-level
declarations (as they are both mangled and in a separate file, and have
to be specified per method instead of only once per class).
This turned out to cause trouble, as our autodoc tool doesn't have a C
preprocessor, so the "CPPUHELPER_DLLPUBLIC" was breaking generating
documentation, which was breaking the build due to documentation
completeness checks in main/odk. Thus main/autodoc had to be patched to
allow command line parameters passed to it to specify parsing tokens to
ignore, and main/odk had to be patched to pass "CPPUHELPER_DLLPUBLIC" as
the token to ignore.
Patch by: me
git-svn-id: https://svn.apache.org/repos/asf/openoffice/trunk@1826398 13f79535-47bb-0310-9956-ffa450edef68
|
| H A D | bootstrap.hxx | diff b32aa359 Sat Mar 10 09:06:22 UTC 2018 Damjan Jovanovic <damjan@apache.org> tr;dr: Don't use .map files for main/cppuhelper on Windows, control
symbol visibility using source-level declarations instead.
C++ symbols are mangled differently on Win64 and Win32, and extracting
new symbols from binaries and updating .DEF/.map files that control symbol
visibility is painful. Both Windows and *nix have moved from using .DEF
and .map files to using declarations in the source code instead, of the
form __declspec(dllexport) and __attribute__ ((visibility("default")))
(which we wrap in SAL_DLLPUBLIC_EXPORT).
The GBuild ported modules also have to replace .map files with source code
declarations (and all so far have), as the default symbol visibility in
GBuild is "hidden" and GBuild has no mechanism to use .map files so far.
So for the purpose of the Win64 port, but as a generally good idea and a
necessity for future GBuild ports, re-implement linker symbol visibility
in main/cppuhelper using SAL_DLLPUBLIC_EXPORT declarations in the source
code instead of using .map files. The purpose of .map files is to version
symbols in the ELF binary format on *nix instead of just controlling
visibility, so they still provide that benefit on *nix, but Windows has no
symbol versioning, all dmake does with .map files is convert them to
unversioned .DEF files, which are harder to maintain than source-level
declarations (as they are both mangled and in a separate file, and have
to be specified per method instead of only once per class).
This turned out to cause trouble, as our autodoc tool doesn't have a C
preprocessor, so the "CPPUHELPER_DLLPUBLIC" was breaking generating
documentation, which was breaking the build due to documentation
completeness checks in main/odk. Thus main/autodoc had to be patched to
allow command line parameters passed to it to specify parsing tokens to
ignore, and main/odk had to be patched to pass "CPPUHELPER_DLLPUBLIC" as
the token to ignore.
Patch by: me
git-svn-id: https://svn.apache.org/repos/asf/openoffice/trunk@1826398 13f79535-47bb-0310-9956-ffa450edef68
|
| H A D | component.hxx | diff b32aa359 Sat Mar 10 09:06:22 UTC 2018 Damjan Jovanovic <damjan@apache.org> tr;dr: Don't use .map files for main/cppuhelper on Windows, control
symbol visibility using source-level declarations instead.
C++ symbols are mangled differently on Win64 and Win32, and extracting
new symbols from binaries and updating .DEF/.map files that control symbol
visibility is painful. Both Windows and *nix have moved from using .DEF
and .map files to using declarations in the source code instead, of the
form __declspec(dllexport) and __attribute__ ((visibility("default")))
(which we wrap in SAL_DLLPUBLIC_EXPORT).
The GBuild ported modules also have to replace .map files with source code
declarations (and all so far have), as the default symbol visibility in
GBuild is "hidden" and GBuild has no mechanism to use .map files so far.
So for the purpose of the Win64 port, but as a generally good idea and a
necessity for future GBuild ports, re-implement linker symbol visibility
in main/cppuhelper using SAL_DLLPUBLIC_EXPORT declarations in the source
code instead of using .map files. The purpose of .map files is to version
symbols in the ELF binary format on *nix instead of just controlling
visibility, so they still provide that benefit on *nix, but Windows has no
symbol versioning, all dmake does with .map files is convert them to
unversioned .DEF files, which are harder to maintain than source-level
declarations (as they are both mangled and in a separate file, and have
to be specified per method instead of only once per class).
This turned out to cause trouble, as our autodoc tool doesn't have a C
preprocessor, so the "CPPUHELPER_DLLPUBLIC" was breaking generating
documentation, which was breaking the build due to documentation
completeness checks in main/odk. Thus main/autodoc had to be patched to
allow command line parameters passed to it to specify parsing tokens to
ignore, and main/odk had to be patched to pass "CPPUHELPER_DLLPUBLIC" as
the token to ignore.
Patch by: me
git-svn-id: https://svn.apache.org/repos/asf/openoffice/trunk@1826398 13f79535-47bb-0310-9956-ffa450edef68
|
| H A D | component_context.hxx | diff b32aa359 Sat Mar 10 09:06:22 UTC 2018 Damjan Jovanovic <damjan@apache.org> tr;dr: Don't use .map files for main/cppuhelper on Windows, control
symbol visibility using source-level declarations instead.
C++ symbols are mangled differently on Win64 and Win32, and extracting
new symbols from binaries and updating .DEF/.map files that control symbol
visibility is painful. Both Windows and *nix have moved from using .DEF
and .map files to using declarations in the source code instead, of the
form __declspec(dllexport) and __attribute__ ((visibility("default")))
(which we wrap in SAL_DLLPUBLIC_EXPORT).
The GBuild ported modules also have to replace .map files with source code
declarations (and all so far have), as the default symbol visibility in
GBuild is "hidden" and GBuild has no mechanism to use .map files so far.
So for the purpose of the Win64 port, but as a generally good idea and a
necessity for future GBuild ports, re-implement linker symbol visibility
in main/cppuhelper using SAL_DLLPUBLIC_EXPORT declarations in the source
code instead of using .map files. The purpose of .map files is to version
symbols in the ELF binary format on *nix instead of just controlling
visibility, so they still provide that benefit on *nix, but Windows has no
symbol versioning, all dmake does with .map files is convert them to
unversioned .DEF files, which are harder to maintain than source-level
declarations (as they are both mangled and in a separate file, and have
to be specified per method instead of only once per class).
This turned out to cause trouble, as our autodoc tool doesn't have a C
preprocessor, so the "CPPUHELPER_DLLPUBLIC" was breaking generating
documentation, which was breaking the build due to documentation
completeness checks in main/odk. Thus main/autodoc had to be patched to
allow command line parameters passed to it to specify parsing tokens to
ignore, and main/odk had to be patched to pass "CPPUHELPER_DLLPUBLIC" as
the token to ignore.
Patch by: me
git-svn-id: https://svn.apache.org/repos/asf/openoffice/trunk@1826398 13f79535-47bb-0310-9956-ffa450edef68
|
| H A D | exc_hlp.hxx | diff b32aa359 Sat Mar 10 09:06:22 UTC 2018 Damjan Jovanovic <damjan@apache.org> tr;dr: Don't use .map files for main/cppuhelper on Windows, control
symbol visibility using source-level declarations instead.
C++ symbols are mangled differently on Win64 and Win32, and extracting
new symbols from binaries and updating .DEF/.map files that control symbol
visibility is painful. Both Windows and *nix have moved from using .DEF
and .map files to using declarations in the source code instead, of the
form __declspec(dllexport) and __attribute__ ((visibility("default")))
(which we wrap in SAL_DLLPUBLIC_EXPORT).
The GBuild ported modules also have to replace .map files with source code
declarations (and all so far have), as the default symbol visibility in
GBuild is "hidden" and GBuild has no mechanism to use .map files so far.
So for the purpose of the Win64 port, but as a generally good idea and a
necessity for future GBuild ports, re-implement linker symbol visibility
in main/cppuhelper using SAL_DLLPUBLIC_EXPORT declarations in the source
code instead of using .map files. The purpose of .map files is to version
symbols in the ELF binary format on *nix instead of just controlling
visibility, so they still provide that benefit on *nix, but Windows has no
symbol versioning, all dmake does with .map files is convert them to
unversioned .DEF files, which are harder to maintain than source-level
declarations (as they are both mangled and in a separate file, and have
to be specified per method instead of only once per class).
This turned out to cause trouble, as our autodoc tool doesn't have a C
preprocessor, so the "CPPUHELPER_DLLPUBLIC" was breaking generating
documentation, which was breaking the build due to documentation
completeness checks in main/odk. Thus main/autodoc had to be patched to
allow command line parameters passed to it to specify parsing tokens to
ignore, and main/odk had to be patched to pass "CPPUHELPER_DLLPUBLIC" as
the token to ignore.
Patch by: me
git-svn-id: https://svn.apache.org/repos/asf/openoffice/trunk@1826398 13f79535-47bb-0310-9956-ffa450edef68
|
| H A D | factory.hxx | diff b32aa359 Sat Mar 10 09:06:22 UTC 2018 Damjan Jovanovic <damjan@apache.org> tr;dr: Don't use .map files for main/cppuhelper on Windows, control
symbol visibility using source-level declarations instead.
C++ symbols are mangled differently on Win64 and Win32, and extracting
new symbols from binaries and updating .DEF/.map files that control symbol
visibility is painful. Both Windows and *nix have moved from using .DEF
and .map files to using declarations in the source code instead, of the
form __declspec(dllexport) and __attribute__ ((visibility("default")))
(which we wrap in SAL_DLLPUBLIC_EXPORT).
The GBuild ported modules also have to replace .map files with source code
declarations (and all so far have), as the default symbol visibility in
GBuild is "hidden" and GBuild has no mechanism to use .map files so far.
So for the purpose of the Win64 port, but as a generally good idea and a
necessity for future GBuild ports, re-implement linker symbol visibility
in main/cppuhelper using SAL_DLLPUBLIC_EXPORT declarations in the source
code instead of using .map files. The purpose of .map files is to version
symbols in the ELF binary format on *nix instead of just controlling
visibility, so they still provide that benefit on *nix, but Windows has no
symbol versioning, all dmake does with .map files is convert them to
unversioned .DEF files, which are harder to maintain than source-level
declarations (as they are both mangled and in a separate file, and have
to be specified per method instead of only once per class).
This turned out to cause trouble, as our autodoc tool doesn't have a C
preprocessor, so the "CPPUHELPER_DLLPUBLIC" was breaking generating
documentation, which was breaking the build due to documentation
completeness checks in main/odk. Thus main/autodoc had to be patched to
allow command line parameters passed to it to specify parsing tokens to
ignore, and main/odk had to be patched to pass "CPPUHELPER_DLLPUBLIC" as
the token to ignore.
Patch by: me
git-svn-id: https://svn.apache.org/repos/asf/openoffice/trunk@1826398 13f79535-47bb-0310-9956-ffa450edef68
|
| H A D | implbase.hxx | diff b32aa359 Sat Mar 10 09:06:22 UTC 2018 Damjan Jovanovic <damjan@apache.org> tr;dr: Don't use .map files for main/cppuhelper on Windows, control
symbol visibility using source-level declarations instead.
C++ symbols are mangled differently on Win64 and Win32, and extracting
new symbols from binaries and updating .DEF/.map files that control symbol
visibility is painful. Both Windows and *nix have moved from using .DEF
and .map files to using declarations in the source code instead, of the
form __declspec(dllexport) and __attribute__ ((visibility("default")))
(which we wrap in SAL_DLLPUBLIC_EXPORT).
The GBuild ported modules also have to replace .map files with source code
declarations (and all so far have), as the default symbol visibility in
GBuild is "hidden" and GBuild has no mechanism to use .map files so far.
So for the purpose of the Win64 port, but as a generally good idea and a
necessity for future GBuild ports, re-implement linker symbol visibility
in main/cppuhelper using SAL_DLLPUBLIC_EXPORT declarations in the source
code instead of using .map files. The purpose of .map files is to version
symbols in the ELF binary format on *nix instead of just controlling
visibility, so they still provide that benefit on *nix, but Windows has no
symbol versioning, all dmake does with .map files is convert them to
unversioned .DEF files, which are harder to maintain than source-level
declarations (as they are both mangled and in a separate file, and have
to be specified per method instead of only once per class).
This turned out to cause trouble, as our autodoc tool doesn't have a C
preprocessor, so the "CPPUHELPER_DLLPUBLIC" was breaking generating
documentation, which was breaking the build due to documentation
completeness checks in main/odk. Thus main/autodoc had to be patched to
allow command line parameters passed to it to specify parsing tokens to
ignore, and main/odk had to be patched to pass "CPPUHELPER_DLLPUBLIC" as
the token to ignore.
Patch by: me
git-svn-id: https://svn.apache.org/repos/asf/openoffice/trunk@1826398 13f79535-47bb-0310-9956-ffa450edef68
|
| H A D | implbase_ex.hxx | diff b32aa359 Sat Mar 10 09:06:22 UTC 2018 Damjan Jovanovic <damjan@apache.org> tr;dr: Don't use .map files for main/cppuhelper on Windows, control
symbol visibility using source-level declarations instead.
C++ symbols are mangled differently on Win64 and Win32, and extracting
new symbols from binaries and updating .DEF/.map files that control symbol
visibility is painful. Both Windows and *nix have moved from using .DEF
and .map files to using declarations in the source code instead, of the
form __declspec(dllexport) and __attribute__ ((visibility("default")))
(which we wrap in SAL_DLLPUBLIC_EXPORT).
The GBuild ported modules also have to replace .map files with source code
declarations (and all so far have), as the default symbol visibility in
GBuild is "hidden" and GBuild has no mechanism to use .map files so far.
So for the purpose of the Win64 port, but as a generally good idea and a
necessity for future GBuild ports, re-implement linker symbol visibility
in main/cppuhelper using SAL_DLLPUBLIC_EXPORT declarations in the source
code instead of using .map files. The purpose of .map files is to version
symbols in the ELF binary format on *nix instead of just controlling
visibility, so they still provide that benefit on *nix, but Windows has no
symbol versioning, all dmake does with .map files is convert them to
unversioned .DEF files, which are harder to maintain than source-level
declarations (as they are both mangled and in a separate file, and have
to be specified per method instead of only once per class).
This turned out to cause trouble, as our autodoc tool doesn't have a C
preprocessor, so the "CPPUHELPER_DLLPUBLIC" was breaking generating
documentation, which was breaking the build due to documentation
completeness checks in main/odk. Thus main/autodoc had to be patched to
allow command line parameters passed to it to specify parsing tokens to
ignore, and main/odk had to be patched to pass "CPPUHELPER_DLLPUBLIC" as
the token to ignore.
Patch by: me
git-svn-id: https://svn.apache.org/repos/asf/openoffice/trunk@1826398 13f79535-47bb-0310-9956-ffa450edef68
|
| H A D | implementationentry.hxx | diff b32aa359 Sat Mar 10 09:06:22 UTC 2018 Damjan Jovanovic <damjan@apache.org> tr;dr: Don't use .map files for main/cppuhelper on Windows, control
symbol visibility using source-level declarations instead.
C++ symbols are mangled differently on Win64 and Win32, and extracting
new symbols from binaries and updating .DEF/.map files that control symbol
visibility is painful. Both Windows and *nix have moved from using .DEF
and .map files to using declarations in the source code instead, of the
form __declspec(dllexport) and __attribute__ ((visibility("default")))
(which we wrap in SAL_DLLPUBLIC_EXPORT).
The GBuild ported modules also have to replace .map files with source code
declarations (and all so far have), as the default symbol visibility in
GBuild is "hidden" and GBuild has no mechanism to use .map files so far.
So for the purpose of the Win64 port, but as a generally good idea and a
necessity for future GBuild ports, re-implement linker symbol visibility
in main/cppuhelper using SAL_DLLPUBLIC_EXPORT declarations in the source
code instead of using .map files. The purpose of .map files is to version
symbols in the ELF binary format on *nix instead of just controlling
visibility, so they still provide that benefit on *nix, but Windows has no
symbol versioning, all dmake does with .map files is convert them to
unversioned .DEF files, which are harder to maintain than source-level
declarations (as they are both mangled and in a separate file, and have
to be specified per method instead of only once per class).
This turned out to cause trouble, as our autodoc tool doesn't have a C
preprocessor, so the "CPPUHELPER_DLLPUBLIC" was breaking generating
documentation, which was breaking the build due to documentation
completeness checks in main/odk. Thus main/autodoc had to be patched to
allow command line parameters passed to it to specify parsing tokens to
ignore, and main/odk had to be patched to pass "CPPUHELPER_DLLPUBLIC" as
the token to ignore.
Patch by: me
git-svn-id: https://svn.apache.org/repos/asf/openoffice/trunk@1826398 13f79535-47bb-0310-9956-ffa450edef68
|
| H A D | interfacecontainer.h | diff b32aa359 Sat Mar 10 09:06:22 UTC 2018 Damjan Jovanovic <damjan@apache.org> tr;dr: Don't use .map files for main/cppuhelper on Windows, control
symbol visibility using source-level declarations instead.
C++ symbols are mangled differently on Win64 and Win32, and extracting
new symbols from binaries and updating .DEF/.map files that control symbol
visibility is painful. Both Windows and *nix have moved from using .DEF
and .map files to using declarations in the source code instead, of the
form __declspec(dllexport) and __attribute__ ((visibility("default")))
(which we wrap in SAL_DLLPUBLIC_EXPORT).
The GBuild ported modules also have to replace .map files with source code
declarations (and all so far have), as the default symbol visibility in
GBuild is "hidden" and GBuild has no mechanism to use .map files so far.
So for the purpose of the Win64 port, but as a generally good idea and a
necessity for future GBuild ports, re-implement linker symbol visibility
in main/cppuhelper using SAL_DLLPUBLIC_EXPORT declarations in the source
code instead of using .map files. The purpose of .map files is to version
symbols in the ELF binary format on *nix instead of just controlling
visibility, so they still provide that benefit on *nix, but Windows has no
symbol versioning, all dmake does with .map files is convert them to
unversioned .DEF files, which are harder to maintain than source-level
declarations (as they are both mangled and in a separate file, and have
to be specified per method instead of only once per class).
This turned out to cause trouble, as our autodoc tool doesn't have a C
preprocessor, so the "CPPUHELPER_DLLPUBLIC" was breaking generating
documentation, which was breaking the build due to documentation
completeness checks in main/odk. Thus main/autodoc had to be patched to
allow command line parameters passed to it to specify parsing tokens to
ignore, and main/odk had to be patched to pass "CPPUHELPER_DLLPUBLIC" as
the token to ignore.
Patch by: me
git-svn-id: https://svn.apache.org/repos/asf/openoffice/trunk@1826398 13f79535-47bb-0310-9956-ffa450edef68
|
| H A D | servicefactory.hxx | diff b32aa359 Sat Mar 10 09:06:22 UTC 2018 Damjan Jovanovic <damjan@apache.org> tr;dr: Don't use .map files for main/cppuhelper on Windows, control
symbol visibility using source-level declarations instead.
C++ symbols are mangled differently on Win64 and Win32, and extracting
new symbols from binaries and updating .DEF/.map files that control symbol
visibility is painful. Both Windows and *nix have moved from using .DEF
and .map files to using declarations in the source code instead, of the
form __declspec(dllexport) and __attribute__ ((visibility("default")))
(which we wrap in SAL_DLLPUBLIC_EXPORT).
The GBuild ported modules also have to replace .map files with source code
declarations (and all so far have), as the default symbol visibility in
GBuild is "hidden" and GBuild has no mechanism to use .map files so far.
So for the purpose of the Win64 port, but as a generally good idea and a
necessity for future GBuild ports, re-implement linker symbol visibility
in main/cppuhelper using SAL_DLLPUBLIC_EXPORT declarations in the source
code instead of using .map files. The purpose of .map files is to version
symbols in the ELF binary format on *nix instead of just controlling
visibility, so they still provide that benefit on *nix, but Windows has no
symbol versioning, all dmake does with .map files is convert them to
unversioned .DEF files, which are harder to maintain than source-level
declarations (as they are both mangled and in a separate file, and have
to be specified per method instead of only once per class).
This turned out to cause trouble, as our autodoc tool doesn't have a C
preprocessor, so the "CPPUHELPER_DLLPUBLIC" was breaking generating
documentation, which was breaking the build due to documentation
completeness checks in main/odk. Thus main/autodoc had to be patched to
allow command line parameters passed to it to specify parsing tokens to
ignore, and main/odk had to be patched to pass "CPPUHELPER_DLLPUBLIC" as
the token to ignore.
Patch by: me
git-svn-id: https://svn.apache.org/repos/asf/openoffice/trunk@1826398 13f79535-47bb-0310-9956-ffa450edef68
|
| H A D | shlib.hxx | diff b32aa359 Sat Mar 10 09:06:22 UTC 2018 Damjan Jovanovic <damjan@apache.org> tr;dr: Don't use .map files for main/cppuhelper on Windows, control
symbol visibility using source-level declarations instead.
C++ symbols are mangled differently on Win64 and Win32, and extracting
new symbols from binaries and updating .DEF/.map files that control symbol
visibility is painful. Both Windows and *nix have moved from using .DEF
and .map files to using declarations in the source code instead, of the
form __declspec(dllexport) and __attribute__ ((visibility("default")))
(which we wrap in SAL_DLLPUBLIC_EXPORT).
The GBuild ported modules also have to replace .map files with source code
declarations (and all so far have), as the default symbol visibility in
GBuild is "hidden" and GBuild has no mechanism to use .map files so far.
So for the purpose of the Win64 port, but as a generally good idea and a
necessity for future GBuild ports, re-implement linker symbol visibility
in main/cppuhelper using SAL_DLLPUBLIC_EXPORT declarations in the source
code instead of using .map files. The purpose of .map files is to version
symbols in the ELF binary format on *nix instead of just controlling
visibility, so they still provide that benefit on *nix, but Windows has no
symbol versioning, all dmake does with .map files is convert them to
unversioned .DEF files, which are harder to maintain than source-level
declarations (as they are both mangled and in a separate file, and have
to be specified per method instead of only once per class).
This turned out to cause trouble, as our autodoc tool doesn't have a C
preprocessor, so the "CPPUHELPER_DLLPUBLIC" was breaking generating
documentation, which was breaking the build due to documentation
completeness checks in main/odk. Thus main/autodoc had to be patched to
allow command line parameters passed to it to specify parsing tokens to
ignore, and main/odk had to be patched to pass "CPPUHELPER_DLLPUBLIC" as
the token to ignore.
Patch by: me
git-svn-id: https://svn.apache.org/repos/asf/openoffice/trunk@1826398 13f79535-47bb-0310-9956-ffa450edef68
|
| H A D | stdidlclass.hxx | diff b32aa359 Sat Mar 10 09:06:22 UTC 2018 Damjan Jovanovic <damjan@apache.org> tr;dr: Don't use .map files for main/cppuhelper on Windows, control
symbol visibility using source-level declarations instead.
C++ symbols are mangled differently on Win64 and Win32, and extracting
new symbols from binaries and updating .DEF/.map files that control symbol
visibility is painful. Both Windows and *nix have moved from using .DEF
and .map files to using declarations in the source code instead, of the
form __declspec(dllexport) and __attribute__ ((visibility("default")))
(which we wrap in SAL_DLLPUBLIC_EXPORT).
The GBuild ported modules also have to replace .map files with source code
declarations (and all so far have), as the default symbol visibility in
GBuild is "hidden" and GBuild has no mechanism to use .map files so far.
So for the purpose of the Win64 port, but as a generally good idea and a
necessity for future GBuild ports, re-implement linker symbol visibility
in main/cppuhelper using SAL_DLLPUBLIC_EXPORT declarations in the source
code instead of using .map files. The purpose of .map files is to version
symbols in the ELF binary format on *nix instead of just controlling
visibility, so they still provide that benefit on *nix, but Windows has no
symbol versioning, all dmake does with .map files is convert them to
unversioned .DEF files, which are harder to maintain than source-level
declarations (as they are both mangled and in a separate file, and have
to be specified per method instead of only once per class).
This turned out to cause trouble, as our autodoc tool doesn't have a C
preprocessor, so the "CPPUHELPER_DLLPUBLIC" was breaking generating
documentation, which was breaking the build due to documentation
completeness checks in main/odk. Thus main/autodoc had to be patched to
allow command line parameters passed to it to specify parsing tokens to
ignore, and main/odk had to be patched to pass "CPPUHELPER_DLLPUBLIC" as
the token to ignore.
Patch by: me
git-svn-id: https://svn.apache.org/repos/asf/openoffice/trunk@1826398 13f79535-47bb-0310-9956-ffa450edef68
|
| H A D | typeprovider.hxx | diff b32aa359 Sat Mar 10 09:06:22 UTC 2018 Damjan Jovanovic <damjan@apache.org> tr;dr: Don't use .map files for main/cppuhelper on Windows, control
symbol visibility using source-level declarations instead.
C++ symbols are mangled differently on Win64 and Win32, and extracting
new symbols from binaries and updating .DEF/.map files that control symbol
visibility is painful. Both Windows and *nix have moved from using .DEF
and .map files to using declarations in the source code instead, of the
form __declspec(dllexport) and __attribute__ ((visibility("default")))
(which we wrap in SAL_DLLPUBLIC_EXPORT).
The GBuild ported modules also have to replace .map files with source code
declarations (and all so far have), as the default symbol visibility in
GBuild is "hidden" and GBuild has no mechanism to use .map files so far.
So for the purpose of the Win64 port, but as a generally good idea and a
necessity for future GBuild ports, re-implement linker symbol visibility
in main/cppuhelper using SAL_DLLPUBLIC_EXPORT declarations in the source
code instead of using .map files. The purpose of .map files is to version
symbols in the ELF binary format on *nix instead of just controlling
visibility, so they still provide that benefit on *nix, but Windows has no
symbol versioning, all dmake does with .map files is convert them to
unversioned .DEF files, which are harder to maintain than source-level
declarations (as they are both mangled and in a separate file, and have
to be specified per method instead of only once per class).
This turned out to cause trouble, as our autodoc tool doesn't have a C
preprocessor, so the "CPPUHELPER_DLLPUBLIC" was breaking generating
documentation, which was breaking the build due to documentation
completeness checks in main/odk. Thus main/autodoc had to be patched to
allow command line parameters passed to it to specify parsing tokens to
ignore, and main/odk had to be patched to pass "CPPUHELPER_DLLPUBLIC" as
the token to ignore.
Patch by: me
git-svn-id: https://svn.apache.org/repos/asf/openoffice/trunk@1826398 13f79535-47bb-0310-9956-ffa450edef68
|
| /aoo42x/main/cppuhelper/source/ |
| H A D | bootstrap.cxx | diff b32aa359 Sat Mar 10 09:06:22 UTC 2018 Damjan Jovanovic <damjan@apache.org> tr;dr: Don't use .map files for main/cppuhelper on Windows, control
symbol visibility using source-level declarations instead.
C++ symbols are mangled differently on Win64 and Win32, and extracting
new symbols from binaries and updating .DEF/.map files that control symbol
visibility is painful. Both Windows and *nix have moved from using .DEF
and .map files to using declarations in the source code instead, of the
form __declspec(dllexport) and __attribute__ ((visibility("default")))
(which we wrap in SAL_DLLPUBLIC_EXPORT).
The GBuild ported modules also have to replace .map files with source code
declarations (and all so far have), as the default symbol visibility in
GBuild is "hidden" and GBuild has no mechanism to use .map files so far.
So for the purpose of the Win64 port, but as a generally good idea and a
necessity for future GBuild ports, re-implement linker symbol visibility
in main/cppuhelper using SAL_DLLPUBLIC_EXPORT declarations in the source
code instead of using .map files. The purpose of .map files is to version
symbols in the ELF binary format on *nix instead of just controlling
visibility, so they still provide that benefit on *nix, but Windows has no
symbol versioning, all dmake does with .map files is convert them to
unversioned .DEF files, which are harder to maintain than source-level
declarations (as they are both mangled and in a separate file, and have
to be specified per method instead of only once per class).
This turned out to cause trouble, as our autodoc tool doesn't have a C
preprocessor, so the "CPPUHELPER_DLLPUBLIC" was breaking generating
documentation, which was breaking the build due to documentation
completeness checks in main/odk. Thus main/autodoc had to be patched to
allow command line parameters passed to it to specify parsing tokens to
ignore, and main/odk had to be patched to pass "CPPUHELPER_DLLPUBLIC" as
the token to ignore.
Patch by: me
git-svn-id: https://svn.apache.org/repos/asf/openoffice/trunk@1826398 13f79535-47bb-0310-9956-ffa450edef68
|